Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/drivers/video/S3Triofb.c -- Open Firmware based frame buffer device | |
3 | * | |
4 | * Copyright (C) 1997 Peter De Schrijver | |
5 | * | |
6 | * This driver is partly based on the PowerMac console driver: | |
7 | * | |
8 | * Copyright (C) 1996 Paul Mackerras | |
9 | * | |
10 | * and on the Open Firmware based frame buffer device: | |
11 | * | |
12 | * Copyright (C) 1997 Geert Uytterhoeven | |
13 | * | |
14 | * This file is subject to the terms and conditions of the GNU General Public | |
15 | * License. See the file COPYING in the main directory of this archive for | |
16 | * more details. | |
17 | */ | |
18 | ||
19 | /* | |
20 | Bugs : + OF dependencies should be removed. | |
21 | + This driver should be merged with the CyberVision driver. The | |
22 | CyberVision is a Zorro III implementation of the S3Trio64 chip. | |
23 | ||
24 | */ | |
25 | ||
26 | #include <linux/config.h> | |
27 | #include <linux/kernel.h> | |
28 | #include <linux/module.h> | |
29 | #include <linux/errno.h> | |
30 | #include <linux/string.h> | |
31 | #include <linux/mm.h> | |
32 | #include <linux/tty.h> | |
33 | #include <linux/slab.h> | |
34 | #include <linux/vmalloc.h> | |
35 | #include <linux/delay.h> | |
36 | #include <linux/interrupt.h> | |
37 | #include <linux/fb.h> | |
38 | #include <linux/init.h> | |
39 | #include <linux/selection.h> | |
40 | #include <asm/io.h> | |
41 | #include <asm/prom.h> | |
42 | #include <asm/pci-bridge.h> | |
43 | #include <linux/pci.h> | |
44 | ||
45 | #include <video/fbcon.h> | |
46 | #include <video/fbcon-cfb8.h> | |
47 | #include <video/s3blit.h> | |
48 | ||
49 | ||
50 | #define mem_in8(addr) in_8((void *)(addr)) | |
51 | #define mem_in16(addr) in_le16((void *)(addr)) | |
52 | #define mem_in32(addr) in_le32((void *)(addr)) | |
53 | ||
54 | #define mem_out8(val, addr) out_8((void *)(addr), val) | |
55 | #define mem_out16(val, addr) out_le16((void *)(addr), val) | |
56 | #define mem_out32(val, addr) out_le32((void *)(addr), val) | |
57 | ||
58 | #define IO_OUT16VAL(v, r) (((v) << 8) | (r)) | |
59 | ||
60 | static struct display disp; | |
61 | static struct fb_info fb_info; | |
62 | static struct { u_char red, green, blue, pad; } palette[256]; | |
63 | static char s3trio_name[16] = "S3Trio "; | |
64 | static char *s3trio_base; | |
65 | ||
66 | static struct fb_fix_screeninfo fb_fix; | |
67 | static struct fb_var_screeninfo fb_var = { 0, }; | |
68 | ||
69 | ||
70 | /* | |
71 | * Interface used by the world | |
72 | */ | |
73 | ||
74 | static void __init s3triofb_of_init(struct device_node *dp); | |
75 | static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con, | |
76 | struct fb_info *info); | |
77 | static int s3trio_get_var(struct fb_var_screeninfo *var, int con, | |
78 | struct fb_info *info); | |
79 | static int s3trio_set_var(struct fb_var_screeninfo *var, int con, | |
80 | struct fb_info *info); | |
81 | static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con, | |
82 | struct fb_info *info); | |
83 | static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue, | |
84 | u_int transp, struct fb_info *info); | |
85 | static int s3trio_pan_display(struct fb_var_screeninfo *var, int con, | |
86 | struct fb_info *info); | |
87 | static void s3triofb_blank(int blank, struct fb_info *info); | |
88 | ||
89 | /* | |
90 | * Interface to the low level console driver | |
91 | */ | |
92 | ||
93 | int s3triofb_init(void); | |
94 | static int s3triofbcon_switch(int con, struct fb_info *info); | |
95 | static int s3triofbcon_updatevar(int con, struct fb_info *info); | |
96 | ||
97 | /* | |
98 | * Text console acceleration | |
99 | */ | |
100 | ||
101 | #ifdef FBCON_HAS_CFB8 | |
102 | static struct display_switch fbcon_trio8; | |
103 | #endif | |
104 | ||
105 | /* | |
106 | * Accelerated Functions used by the low level console driver | |
107 | */ | |
108 | ||
109 | static void Trio_WaitQueue(u_short fifo); | |
110 | static void Trio_WaitBlit(void); | |
111 | static void Trio_BitBLT(u_short curx, u_short cury, u_short destx, | |
112 | u_short desty, u_short width, u_short height, | |
113 | u_short mode); | |
114 | static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height, | |
115 | u_short mode, u_short color); | |
116 | static void Trio_MoveCursor(u_short x, u_short y); | |
117 | ||
118 | ||
119 | /* | |
120 | * Internal routines | |
121 | */ | |
122 | ||
123 | static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, | |
124 | u_int *transp, struct fb_info *info); | |
125 | ||
126 | static struct fb_ops s3trio_ops = { | |
127 | .owner = THIS_MODULE, | |
128 | .fb_get_fix = s3trio_get_fix, | |
129 | .fb_get_var = s3trio_get_var, | |
130 | .fb_set_var = s3trio_set_var, | |
131 | .fb_get_cmap = s3trio_get_cmap, | |
132 | .fb_set_cmap = gen_set_cmap, | |
133 | .fb_setcolreg = s3trio_setcolreg, | |
134 | .fb_pan_display =s3trio_pan_display, | |
135 | .fb_blank = s3triofb_blank, | |
136 | }; | |
137 | ||
138 | /* | |
139 | * Get the Fixed Part of the Display | |
140 | */ | |
141 | ||
142 | static int s3trio_get_fix(struct fb_fix_screeninfo *fix, int con, | |
143 | struct fb_info *info) | |
144 | { | |
145 | memcpy(fix, &fb_fix, sizeof(fb_fix)); | |
146 | return 0; | |
147 | } | |
148 | ||
149 | ||
150 | /* | |
151 | * Get the User Defined Part of the Display | |
152 | */ | |
153 | ||
154 | static int s3trio_get_var(struct fb_var_screeninfo *var, int con, | |
155 | struct fb_info *info) | |
156 | { | |
157 | memcpy(var, &fb_var, sizeof(fb_var)); | |
158 | return 0; | |
159 | } | |
160 | ||
161 | ||
162 | /* | |
163 | * Set the User Defined Part of the Display | |
164 | */ | |
165 | ||
166 | static int s3trio_set_var(struct fb_var_screeninfo *var, int con, | |
167 | struct fb_info *info) | |
168 | { | |
169 | if (var->xres > fb_var.xres || var->yres > fb_var.yres || | |
170 | var->bits_per_pixel > fb_var.bits_per_pixel ) | |
171 | /* || var->nonstd || var->vmode != FB_VMODE_NONINTERLACED) */ | |
172 | return -EINVAL; | |
173 | if (var->xres_virtual > fb_var.xres_virtual) { | |
174 | outw(IO_OUT16VAL((var->xres_virtual /8) & 0xff, 0x13), 0x3d4); | |
175 | outw(IO_OUT16VAL(((var->xres_virtual /8 ) & 0x300) >> 3, 0x51), 0x3d4); | |
176 | fb_var.xres_virtual = var->xres_virtual; | |
177 | fb_fix.line_length = var->xres_virtual; | |
178 | } | |
179 | fb_var.yres_virtual = var->yres_virtual; | |
180 | memcpy(var, &fb_var, sizeof(fb_var)); | |
181 | return 0; | |
182 | } | |
183 | ||
184 | ||
185 | /* | |
186 | * Pan or Wrap the Display | |
187 | * | |
188 | * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag | |
189 | */ | |
190 | ||
191 | static int s3trio_pan_display(struct fb_var_screeninfo *var, int con, | |
192 | struct fb_info *info) | |
193 | { | |
194 | unsigned int base; | |
195 | ||
196 | if (var->xoffset > (var->xres_virtual - var->xres)) | |
197 | return -EINVAL; | |
198 | if (var->yoffset > (var->yres_virtual - var->yres)) | |
199 | return -EINVAL; | |
200 | ||
201 | fb_var.xoffset = var->xoffset; | |
202 | fb_var.yoffset = var->yoffset; | |
203 | ||
204 | base = var->yoffset * fb_fix.line_length + var->xoffset; | |
205 | ||
206 | outw(IO_OUT16VAL((base >> 8) & 0xff, 0x0c),0x03D4); | |
207 | outw(IO_OUT16VAL(base & 0xff, 0x0d),0x03D4); | |
208 | outw(IO_OUT16VAL((base >> 16) & 0xf, 0x69),0x03D4); | |
209 | return 0; | |
210 | } | |
211 | ||
212 | ||
213 | /* | |
214 | * Get the Colormap | |
215 | */ | |
216 | ||
217 | static int s3trio_get_cmap(struct fb_cmap *cmap, int kspc, int con, | |
218 | struct fb_info *info) | |
219 | { | |
220 | if (con == info->currcon) /* current console? */ | |
221 | return fb_get_cmap(cmap, kspc, s3trio_getcolreg, info); | |
222 | else if (fb_display[con].cmap.len) /* non default colormap? */ | |
223 | fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2); | |
224 | else | |
225 | fb_copy_cmap(fb_default_cmap(1 << fb_display[con].var.bits_per_pixel), | |
226 | cmap, kspc ? 0 : 2); | |
227 | return 0; | |
228 | } | |
229 | ||
230 | int __init s3triofb_init(void) | |
231 | { | |
232 | struct device_node *dp; | |
233 | ||
234 | dp = find_devices("S3Trio"); | |
235 | if (dp != 0) | |
236 | s3triofb_of_init(dp); | |
237 | return 0; | |
238 | } | |
239 | ||
240 | void __init s3trio_resetaccel(void){ | |
241 | ||
242 | ||
243 | #define EC01_ENH_ENB 0x0005 | |
244 | #define EC01_LAW_ENB 0x0010 | |
245 | #define EC01_MMIO_ENB 0x0020 | |
246 | ||
247 | #define EC00_RESET 0x8000 | |
248 | #define EC00_ENABLE 0x4000 | |
249 | #define MF_MULT_MISC 0xE000 | |
250 | #define SRC_FOREGROUND 0x0020 | |
251 | #define SRC_BACKGROUND 0x0000 | |
252 | #define MIX_SRC 0x0007 | |
253 | #define MF_T_CLIP 0x1000 | |
254 | #define MF_L_CLIP 0x2000 | |
255 | #define MF_B_CLIP 0x3000 | |
256 | #define MF_R_CLIP 0x4000 | |
257 | #define MF_PIX_CONTROL 0xA000 | |
258 | #define MFA_SRC_FOREGR_MIX 0x0000 | |
259 | #define MF_PIX_CONTROL 0xA000 | |
260 | ||
261 | outw(EC00_RESET, 0x42e8); | |
262 | inw( 0x42e8); | |
263 | outw(EC00_ENABLE, 0x42e8); | |
264 | inw( 0x42e8); | |
265 | outw(EC01_ENH_ENB | EC01_LAW_ENB, | |
266 | 0x4ae8); | |
267 | outw(MF_MULT_MISC, 0xbee8); /* 16 bit I/O registers */ | |
268 | ||
269 | /* Now set some basic accelerator registers */ | |
270 | Trio_WaitQueue(0x0400); | |
271 | outw(SRC_FOREGROUND | MIX_SRC, 0xbae8); | |
272 | outw(SRC_BACKGROUND | MIX_SRC, 0xb6e8);/* direct color*/ | |
273 | outw(MF_T_CLIP | 0, 0xbee8 ); /* clip virtual area */ | |
274 | outw(MF_L_CLIP | 0, 0xbee8 ); | |
275 | outw(MF_R_CLIP | (640 - 1), 0xbee8); | |
276 | outw(MF_B_CLIP | (480 - 1), 0xbee8); | |
277 | Trio_WaitQueue(0x0400); | |
278 | outw(0xffff, 0xaae8); /* Enable all planes */ | |
279 | outw(0xffff, 0xaae8); /* Enable all planes */ | |
280 | outw( MF_PIX_CONTROL | MFA_SRC_FOREGR_MIX, 0xbee8); | |
281 | } | |
282 | ||
283 | int __init s3trio_init(struct device_node *dp){ | |
284 | ||
285 | u_char bus, dev; | |
286 | unsigned int t32; | |
287 | unsigned short cmd; | |
288 | ||
289 | pci_device_loc(dp,&bus,&dev); | |
290 | pcibios_read_config_dword(bus, dev, PCI_VENDOR_ID, &t32); | |
291 | if(t32 == (PCI_DEVICE_ID_S3_TRIO << 16) + PCI_VENDOR_ID_S3) { | |
292 | pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_0, &t32); | |
293 | pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_1, &t32); | |
294 | pcibios_read_config_word(bus, dev, PCI_COMMAND,&cmd); | |
295 | ||
296 | pcibios_write_config_word(bus, dev, PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MEMORY); | |
297 | ||
298 | pcibios_write_config_dword(bus, dev, PCI_BASE_ADDRESS_0,0xffffffff); | |
299 | pcibios_read_config_dword(bus, dev, PCI_BASE_ADDRESS_0, &t32); | |
300 | ||
301 | /* This is a gross hack as OF only maps enough memory for the framebuffer and | |
302 | we want to use MMIO too. We should find out which chunk of address space | |
303 | we can use here */ | |
304 | pcibios_write_config_dword(bus,dev,PCI_BASE_ADDRESS_0,0xc6000000); | |
305 | ||
306 | /* unlock s3 */ | |
307 | ||
308 | outb(0x01, 0x3C3); | |
309 | ||
310 | outb(inb(0x03CC) | 1, 0x3c2); | |
311 | ||
312 | outw(IO_OUT16VAL(0x48, 0x38),0x03D4); | |
313 | outw(IO_OUT16VAL(0xA0, 0x39),0x03D4); | |
314 | outb(0x33,0x3d4); | |
315 | outw(IO_OUT16VAL((inb(0x3d5) & ~(0x2 | 0x10 | 0x40)) | | |
316 | 0x20, 0x33), 0x3d4); | |
317 | ||
318 | outw(IO_OUT16VAL(0x6, 0x8), 0x3c4); | |
319 | ||
320 | /* switch to MMIO only mode */ | |
321 | ||
322 | outb(0x58, 0x3d4); | |
323 | outw(IO_OUT16VAL(inb(0x3d5) | 3 | 0x10, 0x58), 0x3d4); | |
324 | outw(IO_OUT16VAL(8, 0x53), 0x3d4); | |
325 | ||
326 | /* switch off I/O accesses */ | |
327 | ||
328 | #if 0 | |
329 | pcibios_write_config_word(bus, dev, PCI_COMMAND, | |
330 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY); | |
331 | #endif | |
332 | return 1; | |
333 | } | |
334 | ||
335 | return 0; | |
336 | } | |
337 | ||
338 | ||
339 | /* | |
340 | * Initialisation | |
341 | * We heavily rely on OF for the moment. This needs fixing. | |
342 | */ | |
343 | ||
344 | static void __init s3triofb_of_init(struct device_node *dp) | |
345 | { | |
346 | int i, *pp, len; | |
347 | unsigned long address, size; | |
348 | u_long *CursorBase; | |
349 | ||
350 | strncat(s3trio_name, dp->name, sizeof(s3trio_name)); | |
351 | s3trio_name[sizeof(s3trio_name)-1] = '\0'; | |
352 | strcpy(fb_fix.id, s3trio_name); | |
353 | ||
354 | if((pp = (int *)get_property(dp, "vendor-id", &len)) != NULL | |
355 | && *pp!=PCI_VENDOR_ID_S3) { | |
356 | printk("%s: can't find S3 Trio board\n", dp->full_name); | |
357 | return; | |
358 | } | |
359 | ||
360 | if((pp = (int *)get_property(dp, "device-id", &len)) != NULL | |
361 | && *pp!=PCI_DEVICE_ID_S3_TRIO) { | |
362 | printk("%s: can't find S3 Trio board\n", dp->full_name); | |
363 | return; | |
364 | } | |
365 | ||
366 | if ((pp = (int *)get_property(dp, "depth", &len)) != NULL | |
367 | && len == sizeof(int) && *pp != 8) { | |
368 | printk("%s: can't use depth = %d\n", dp->full_name, *pp); | |
369 | return; | |
370 | } | |
371 | if ((pp = (int *)get_property(dp, "width", &len)) != NULL | |
372 | && len == sizeof(int)) | |
373 | fb_var.xres = fb_var.xres_virtual = *pp; | |
374 | if ((pp = (int *)get_property(dp, "height", &len)) != NULL | |
375 | && len == sizeof(int)) | |
376 | fb_var.yres = fb_var.yres_virtual = *pp; | |
377 | if ((pp = (int *)get_property(dp, "linebytes", &len)) != NULL | |
378 | && len == sizeof(int)) | |
379 | fb_fix.line_length = *pp; | |
380 | else | |
381 | fb_fix.line_length = fb_var.xres_virtual; | |
382 | fb_fix.smem_len = fb_fix.line_length*fb_var.yres; | |
383 | ||
384 | address = 0xc6000000; | |
385 | size = 64*1024*1024; | |
386 | if (!request_mem_region(address, size, "S3triofb")) | |
387 | return; | |
388 | ||
389 | s3trio_init(dp); | |
390 | s3trio_base = ioremap(address, size); | |
391 | fb_fix.smem_start = address; | |
392 | fb_fix.type = FB_TYPE_PACKED_PIXELS; | |
393 | fb_fix.type_aux = 0; | |
394 | fb_fix.accel = FB_ACCEL_S3_TRIO64; | |
395 | fb_fix.mmio_start = address+0x1000000; | |
396 | fb_fix.mmio_len = 0x1000000; | |
397 | ||
398 | fb_fix.xpanstep = 1; | |
399 | fb_fix.ypanstep = 1; | |
400 | ||
401 | s3trio_resetaccel(); | |
402 | ||
403 | mem_out8(0x30, s3trio_base+0x1008000 + 0x03D4); | |
404 | mem_out8(0x2d, s3trio_base+0x1008000 + 0x03D4); | |
405 | mem_out8(0x2e, s3trio_base+0x1008000 + 0x03D4); | |
406 | ||
407 | mem_out8(0x50, s3trio_base+0x1008000 + 0x03D4); | |
408 | ||
409 | /* disable HW cursor */ | |
410 | ||
411 | mem_out8(0x39, s3trio_base+0x1008000 + 0x03D4); | |
412 | mem_out8(0xa0, s3trio_base+0x1008000 + 0x03D5); | |
413 | ||
414 | mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); | |
415 | mem_out8(0, s3trio_base+0x1008000 + 0x03D5); | |
416 | ||
417 | mem_out8(0x4e, s3trio_base+0x1008000 + 0x03D4); | |
418 | mem_out8(0, s3trio_base+0x1008000 + 0x03D5); | |
419 | ||
420 | mem_out8(0x4f, s3trio_base+0x1008000 + 0x03D4); | |
421 | mem_out8(0, s3trio_base+0x1008000 + 0x03D5); | |
422 | ||
423 | /* init HW cursor */ | |
424 | ||
425 | CursorBase = (u_long *)(s3trio_base + 2*1024*1024 - 0x400); | |
426 | for (i = 0; i < 8; i++) { | |
427 | *(CursorBase +(i*4)) = 0xffffff00; | |
428 | *(CursorBase+1+(i*4)) = 0xffff0000; | |
429 | *(CursorBase+2+(i*4)) = 0xffff0000; | |
430 | *(CursorBase+3+(i*4)) = 0xffff0000; | |
431 | } | |
432 | for (i = 8; i < 64; i++) { | |
433 | *(CursorBase +(i*4)) = 0xffff0000; | |
434 | *(CursorBase+1+(i*4)) = 0xffff0000; | |
435 | *(CursorBase+2+(i*4)) = 0xffff0000; | |
436 | *(CursorBase+3+(i*4)) = 0xffff0000; | |
437 | } | |
438 | ||
439 | ||
440 | mem_out8(0x4c, s3trio_base+0x1008000 + 0x03D4); | |
441 | mem_out8(((2*1024 - 1)&0xf00)>>8, s3trio_base+0x1008000 + 0x03D5); | |
442 | ||
443 | mem_out8(0x4d, s3trio_base+0x1008000 + 0x03D4); | |
444 | mem_out8((2*1024 - 1) & 0xff, s3trio_base+0x1008000 + 0x03D5); | |
445 | ||
446 | mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); | |
447 | mem_in8(s3trio_base+0x1008000 + 0x03D4); | |
448 | ||
449 | mem_out8(0x4a, s3trio_base+0x1008000 + 0x03D4); | |
450 | mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); | |
451 | mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); | |
452 | mem_out8(0x80, s3trio_base+0x1008000 + 0x03D5); | |
453 | ||
454 | mem_out8(0x4b, s3trio_base+0x1008000 + 0x03D4); | |
455 | mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); | |
456 | mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); | |
457 | mem_out8(0x00, s3trio_base+0x1008000 + 0x03D5); | |
458 | ||
459 | mem_out8(0x45, s3trio_base+0x1008000 + 0x03D4); | |
460 | mem_out8(0, s3trio_base+0x1008000 + 0x03D5); | |
461 | ||
462 | /* setup default color table */ | |
463 | ||
464 | for(i = 0; i < 16; i++) { | |
465 | int j = color_table[i]; | |
466 | palette[i].red=default_red[j]; | |
467 | palette[i].green=default_grn[j]; | |
468 | palette[i].blue=default_blu[j]; | |
469 | } | |
470 | ||
471 | s3trio_setcolreg(255, 56, 100, 160, 0, NULL /* not used */); | |
472 | s3trio_setcolreg(254, 0, 0, 0, 0, NULL /* not used */); | |
473 | memset((char *)s3trio_base, 0, 640*480); | |
474 | ||
475 | #if 0 | |
476 | Trio_RectFill(0, 0, 90, 90, 7, 1); | |
477 | #endif | |
478 | ||
479 | fb_fix.visual = FB_VISUAL_PSEUDOCOLOR ; | |
480 | fb_var.xoffset = fb_var.yoffset = 0; | |
481 | fb_var.bits_per_pixel = 8; | |
482 | fb_var.grayscale = 0; | |
483 | fb_var.red.offset = fb_var.green.offset = fb_var.blue.offset = 0; | |
484 | fb_var.red.length = fb_var.green.length = fb_var.blue.length = 8; | |
485 | fb_var.red.msb_right = fb_var.green.msb_right = fb_var.blue.msb_right = 0; | |
486 | fb_var.transp.offset = fb_var.transp.length = fb_var.transp.msb_right = 0; | |
487 | fb_var.nonstd = 0; | |
488 | fb_var.activate = 0; | |
489 | fb_var.height = fb_var.width = -1; | |
490 | fb_var.accel_flags = FB_ACCELF_TEXT; | |
491 | #warning FIXME: always obey fb_var.accel_flags | |
492 | fb_var.pixclock = 1; | |
493 | fb_var.left_margin = fb_var.right_margin = 0; | |
494 | fb_var.upper_margin = fb_var.lower_margin = 0; | |
495 | fb_var.hsync_len = fb_var.vsync_len = 0; | |
496 | fb_var.sync = 0; | |
497 | fb_var.vmode = FB_VMODE_NONINTERLACED; | |
498 | ||
499 | disp.var = fb_var; | |
500 | disp.cmap.start = 0; | |
501 | disp.cmap.len = 0; | |
502 | disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL; | |
503 | disp.visual = fb_fix.visual; | |
504 | disp.type = fb_fix.type; | |
505 | disp.type_aux = fb_fix.type_aux; | |
506 | disp.ypanstep = 0; | |
507 | disp.ywrapstep = 0; | |
508 | disp.line_length = fb_fix.line_length; | |
509 | disp.can_soft_blank = 1; | |
510 | disp.inverse = 0; | |
511 | #ifdef FBCON_HAS_CFB8 | |
512 | if (fb_var.accel_flags & FB_ACCELF_TEXT) | |
513 | disp.dispsw = &fbcon_trio8; | |
514 | else | |
515 | disp.dispsw = &fbcon_cfb8; | |
516 | #else | |
517 | disp.dispsw = &fbcon_dummy; | |
518 | #endif | |
519 | disp.scrollmode = fb_var.accel_flags & FB_ACCELF_TEXT ? 0 : SCROLL_YREDRAW; | |
520 | ||
521 | strcpy(fb_info.modename, "Trio64 "); | |
522 | strncat(fb_info.modename, dp->full_name, sizeof(fb_info.modename)); | |
523 | fb_info.currcon = -1; | |
524 | fb_info.fbops = &s3trio_ops; | |
525 | fb_info.screen_base = s3trio_base; | |
526 | #if 0 | |
527 | fb_info.fbvar_num = 1; | |
528 | fb_info.fbvar = &fb_var; | |
529 | #endif | |
530 | fb_info.disp = &disp; | |
531 | fb_info.fontname[0] = '\0'; | |
532 | fb_info.changevar = NULL; | |
533 | fb_info.switch_con = &s3triofbcon_switch; | |
534 | fb_info.updatevar = &s3triofbcon_updatevar; | |
535 | #if 0 | |
536 | fb_info.setcmap = &s3triofbcon_setcmap; | |
537 | #endif | |
538 | ||
539 | fb_info.flags = FBINFO_FLAG_DEFAULT; | |
540 | if (register_framebuffer(&fb_info) < 0) | |
541 | return; | |
542 | ||
543 | printk("fb%d: S3 Trio frame buffer device on %s\n", | |
544 | fb_info.node, dp->full_name); | |
545 | } | |
546 | ||
547 | ||
548 | static int s3triofbcon_switch(int con, struct fb_info *info) | |
549 | { | |
550 | /* Do we have to save the colormap? */ | |
551 | if (fb_display[info->currcon].cmap.len) | |
552 | fb_get_cmap(&fb_display[info->currcon].cmap, 1, s3trio_getcolreg, info); | |
553 | ||
554 | info->currcon = con; | |
555 | /* Install new colormap */ | |
556 | do_install_cmap(con,info); | |
557 | return 0; | |
558 | } | |
559 | ||
560 | /* | |
561 | * Update the `var' structure (called by fbcon.c) | |
562 | */ | |
563 | ||
564 | static int s3triofbcon_updatevar(int con, struct fb_info *info) | |
565 | { | |
566 | /* Nothing */ | |
567 | return 0; | |
568 | } | |
569 | ||
570 | /* | |
571 | * Blank the display. | |
572 | */ | |
573 | ||
574 | static int s3triofb_blank(int blank, struct fb_info *info) | |
575 | { | |
576 | unsigned char x; | |
577 | ||
578 | mem_out8(0x1, s3trio_base+0x1008000 + 0x03c4); | |
579 | x = mem_in8(s3trio_base+0x1008000 + 0x03c5); | |
580 | mem_out8((x & (~0x20)) | (blank << 5), s3trio_base+0x1008000 + 0x03c5); | |
581 | return 0; | |
582 | } | |
583 | ||
584 | /* | |
585 | * Read a single color register and split it into | |
586 | * colors/transparent. Return != 0 for invalid regno. | |
587 | */ | |
588 | ||
589 | static int s3trio_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, | |
590 | u_int *transp, struct fb_info *info) | |
591 | { | |
592 | if (regno > 255) | |
593 | return 1; | |
594 | *red = (palette[regno].red << 8) | palette[regno].red; | |
595 | *green = (palette[regno].green << 8) | palette[regno].green; | |
596 | *blue = (palette[regno].blue << 8) | palette[regno].blue; | |
597 | *transp = 0; | |
598 | return 0; | |
599 | } | |
600 | ||
601 | ||
602 | /* | |
603 | * Set a single color register. Return != 0 for invalid regno. | |
604 | */ | |
605 | ||
606 | static int s3trio_setcolreg(u_int regno, u_int red, u_int green, u_int blue, | |
607 | u_int transp, struct fb_info *info) | |
608 | { | |
609 | if (regno > 255) | |
610 | return 1; | |
611 | ||
612 | red >>= 8; | |
613 | green >>= 8; | |
614 | blue >>= 8; | |
615 | palette[regno].red = red; | |
616 | palette[regno].green = green; | |
617 | palette[regno].blue = blue; | |
618 | ||
619 | mem_out8(regno,s3trio_base+0x1008000 + 0x3c8); | |
620 | mem_out8((red & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); | |
621 | mem_out8((green & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); | |
622 | mem_out8((blue & 0xff) >> 2,s3trio_base+0x1008000 + 0x3c9); | |
623 | ||
624 | return 0; | |
625 | } | |
626 | ||
627 | static void Trio_WaitQueue(u_short fifo) { | |
628 | ||
629 | u_short status; | |
630 | ||
631 | do | |
632 | { | |
633 | status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8); | |
634 | } while (!(status & fifo)); | |
635 | ||
636 | } | |
637 | ||
638 | static void Trio_WaitBlit(void) { | |
639 | ||
640 | u_short status; | |
641 | ||
642 | do | |
643 | { | |
644 | status = mem_in16(s3trio_base + 0x1000000 + 0x9AE8); | |
645 | } while (status & 0x200); | |
646 | ||
647 | } | |
648 | ||
649 | static void Trio_BitBLT(u_short curx, u_short cury, u_short destx, | |
650 | u_short desty, u_short width, u_short height, | |
651 | u_short mode) { | |
652 | ||
653 | u_short blitcmd = 0xc011; | |
654 | ||
655 | /* Set drawing direction */ | |
656 | /* -Y, X maj, -X (default) */ | |
657 | ||
658 | if (curx > destx) | |
659 | blitcmd |= 0x0020; /* Drawing direction +X */ | |
660 | else { | |
661 | curx += (width - 1); | |
662 | destx += (width - 1); | |
663 | } | |
664 | ||
665 | if (cury > desty) | |
666 | blitcmd |= 0x0080; /* Drawing direction +Y */ | |
667 | else { | |
668 | cury += (height - 1); | |
669 | desty += (height - 1); | |
670 | } | |
671 | ||
672 | Trio_WaitQueue(0x0400); | |
673 | ||
674 | outw(0xa000, 0xBEE8); | |
675 | outw(0x60 | mode, 0xBAE8); | |
676 | ||
677 | outw(curx, 0x86E8); | |
678 | outw(cury, 0x82E8); | |
679 | ||
680 | outw(destx, 0x8EE8); | |
681 | outw(desty, 0x8AE8); | |
682 | ||
683 | outw(height - 1, 0xBEE8); | |
684 | outw(width - 1, 0x96E8); | |
685 | ||
686 | outw(blitcmd, 0x9AE8); | |
687 | ||
688 | } | |
689 | ||
690 | static void Trio_RectFill(u_short x, u_short y, u_short width, u_short height, | |
691 | u_short mode, u_short color) { | |
692 | ||
693 | u_short blitcmd = 0x40b1; | |
694 | ||
695 | Trio_WaitQueue(0x0400); | |
696 | ||
697 | outw(0xa000, 0xBEE8); | |
698 | outw((0x20 | mode), 0xBAE8); | |
699 | outw(0xe000, 0xBEE8); | |
700 | outw(color, 0xA6E8); | |
701 | outw(x, 0x86E8); | |
702 | outw(y, 0x82E8); | |
703 | outw((height - 1), 0xBEE8); | |
704 | outw((width - 1), 0x96E8); | |
705 | outw(blitcmd, 0x9AE8); | |
706 | ||
707 | } | |
708 | ||
709 | ||
710 | static void Trio_MoveCursor(u_short x, u_short y) { | |
711 | ||
712 | mem_out8(0x39, s3trio_base + 0x1008000 + 0x3d4); | |
713 | mem_out8(0xa0, s3trio_base + 0x1008000 + 0x3d5); | |
714 | ||
715 | mem_out8(0x46, s3trio_base + 0x1008000 + 0x3d4); | |
716 | mem_out8((x & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5); | |
717 | mem_out8(0x47, s3trio_base + 0x1008000 + 0x3d4); | |
718 | mem_out8(x & 0x00ff, s3trio_base + 0x1008000 + 0x3d5); | |
719 | ||
720 | mem_out8(0x48, s3trio_base + 0x1008000 + 0x3d4); | |
721 | mem_out8((y & 0x0700) >> 8, s3trio_base + 0x1008000 + 0x3d5); | |
722 | mem_out8(0x49, s3trio_base + 0x1008000 + 0x3d4); | |
723 | mem_out8(y & 0x00ff, s3trio_base + 0x1008000 + 0x3d5); | |
724 | ||
725 | } | |
726 | ||
727 | ||
728 | /* | |
729 | * Text console acceleration | |
730 | */ | |
731 | ||
732 | #ifdef FBCON_HAS_CFB8 | |
733 | static void fbcon_trio8_bmove(struct display *p, int sy, int sx, int dy, | |
734 | int dx, int height, int width) | |
735 | { | |
736 | sx *= 8; dx *= 8; width *= 8; | |
737 | Trio_BitBLT((u_short)sx, (u_short)(sy*fontheight(p)), (u_short)dx, | |
738 | (u_short)(dy*fontheight(p)), (u_short)width, | |
739 | (u_short)(height*fontheight(p)), (u_short)S3_NEW); | |
740 | } | |
741 | ||
742 | static void fbcon_trio8_clear(struct vc_data *conp, struct display *p, int sy, | |
743 | int sx, int height, int width) | |
744 | { | |
745 | unsigned char bg; | |
746 | ||
747 | sx *= 8; width *= 8; | |
748 | bg = attr_bgcol_ec(p,conp); | |
749 | Trio_RectFill((u_short)sx, | |
750 | (u_short)(sy*fontheight(p)), | |
751 | (u_short)width, | |
752 | (u_short)(height*fontheight(p)), | |
753 | (u_short)S3_NEW, | |
754 | (u_short)bg); | |
755 | } | |
756 | ||
757 | static void fbcon_trio8_putc(struct vc_data *conp, struct display *p, int c, | |
758 | int yy, int xx) | |
759 | { | |
760 | Trio_WaitBlit(); | |
761 | fbcon_cfb8_putc(conp, p, c, yy, xx); | |
762 | } | |
763 | ||
764 | static void fbcon_trio8_putcs(struct vc_data *conp, struct display *p, | |
765 | const unsigned short *s, int count, int yy, int xx) | |
766 | { | |
767 | Trio_WaitBlit(); | |
768 | fbcon_cfb8_putcs(conp, p, s, count, yy, xx); | |
769 | } | |
770 | ||
771 | static void fbcon_trio8_revc(struct display *p, int xx, int yy) | |
772 | { | |
773 | Trio_WaitBlit(); | |
774 | fbcon_cfb8_revc(p, xx, yy); | |
775 | } | |
776 | ||
777 | static struct display_switch fbcon_trio8 = { | |
778 | .setup = fbcon_cfb8_setup, | |
779 | .bmove = fbcon_trio8_bmove, | |
780 | .clear = fbcon_trio8_clear, | |
781 | .putc = fbcon_trio8_putc, | |
782 | .putcs = fbcon_trio8_putcs, | |
783 | .revc = fbcon_trio8_revc, | |
784 | .clear_margins = fbcon_cfb8_clear_margins, | |
785 | .fontwidthmask = FONTWIDTH(8) | |
786 | }; | |
787 | #endif | |
788 | ||
789 | MODULE_LICENSE("GPL"); |