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