?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / video / tgafb.c
bloba78ca6a01094cf01a37397d99363af33a3391e94
1 /*
2 * linux/drivers/video/tgafb.c -- DEC 21030 TGA frame buffer device
3 *
4 * Copyright (C) 1995 Jay Estabrook
5 * Copyright (C) 1997 Geert Uytterhoeven
6 * Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha
7 * Copyright (C) 2002 Richard Henderson
8 * Copyright (C) 2006, 2007 Maciej W. Rozycki
9 *
10 * This file is subject to the terms and conditions of the GNU General Public
11 * License. See the file COPYING in the main directory of this archive for
12 * more details.
13 */
14
15 #include <linux/bitrev.h>
16 #include <linux/compiler.h>
17 #include <linux/delay.h>
18 #include <linux/device.h>
19 #include <linux/errno.h>
20 #include <linux/fb.h>
21 #include <linux/init.h>
22 #include <linux/ioport.h>
23 #include <linux/kernel.h>
24 #include <linux/mm.h>
25 #include <linux/module.h>
26 #include <linux/pci.h>
27 #include <linux/selection.h>
28 #include <linux/string.h>
29 #include <linux/tc.h>
30
31 #include <asm/io.h>
32
33 #include <video/tgafb.h>
34
35 #ifdef CONFIG_PCI
36 #define TGA_BUS_PCI(dev) (dev->bus == &pci_bus_type)
37 #else
38 #define TGA_BUS_PCI(dev) 0
39 #endif
40
41 #ifdef CONFIG_TC
42 #define TGA_BUS_TC(dev) (dev->bus == &tc_bus_type)
43 #else
44 #define TGA_BUS_TC(dev) 0
45 #endif
46
47 /*
48 * Local functions.
49 */
50
51 static int tgafb_check_var(struct fb_var_screeninfo *, struct fb_info *);
52 static int tgafb_set_par(struct fb_info *);
53 static void tgafb_set_pll(struct tga_par *, int);
54 static int tgafb_setcolreg(unsigned, unsigned, unsigned, unsigned,
55 unsigned, struct fb_info *);
56 static int tgafb_blank(int, struct fb_info *);
57 static void tgafb_init_fix(struct fb_info *);
58
59 static void tgafb_imageblit(struct fb_info *, const struct fb_image *);
60 static void tgafb_fillrect(struct fb_info *, const struct fb_fillrect *);
61 static void tgafb_copyarea(struct fb_info *, const struct fb_copyarea *);
62 static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
63
64 static int tgafb_register(struct device *dev);
65 static void tgafb_unregister(struct device *dev);
66
67 static const char *mode_option;
68 static const char *mode_option_pci = "640x480@60";
69 static const char *mode_option_tc = "1280x1024@72";
70
71
72 static struct pci_driver tgafb_pci_driver;
73 static struct tc_driver tgafb_tc_driver;
74
75 /*
76 * Frame buffer operations
77 */
78
79 static struct fb_ops tgafb_ops = {
80 .owner = THIS_MODULE,
81 .fb_check_var = tgafb_check_var,
82 .fb_set_par = tgafb_set_par,
83 .fb_setcolreg = tgafb_setcolreg,
84 .fb_blank = tgafb_blank,
85 .fb_pan_display = tgafb_pan_display,
86 .fb_fillrect = tgafb_fillrect,
87 .fb_copyarea = tgafb_copyarea,
88 .fb_imageblit = tgafb_imageblit,
89 };
90
91
92 #ifdef CONFIG_PCI
93 /*
94 * PCI registration operations
95 */
96 static int tgafb_pci_register(struct pci_dev *, const struct pci_device_id *);
97 static void tgafb_pci_unregister(struct pci_dev *);
98
99 static struct pci_device_id const tgafb_pci_table[] = {
100 { PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA) },
101 { }
102 };
103 MODULE_DEVICE_TABLE(pci, tgafb_pci_table);
104
105 static struct pci_driver tgafb_pci_driver = {
106 .name = "tgafb",
107 .id_table = tgafb_pci_table,
108 .probe = tgafb_pci_register,
109 .remove = tgafb_pci_unregister,
110 };
111
112 static int tgafb_pci_register(struct pci_dev *pdev,
113 const struct pci_device_id *ent)
114 {
115 return tgafb_register(&pdev->dev);
116 }
117
118 static void tgafb_pci_unregister(struct pci_dev *pdev)
119 {
120 tgafb_unregister(&pdev->dev);
121 }
122 #endif /* CONFIG_PCI */
123
124 #ifdef CONFIG_TC
125 /*
126 * TC registration operations
127 */
128 static int tgafb_tc_register(struct device *);
129 static int tgafb_tc_unregister(struct device *);
130
131 static struct tc_device_id const tgafb_tc_table[] = {
132 { "DEC ", "PMAGD-AA" },
133 { "DEC ", "PMAGD " },
134 { }
135 };
136 MODULE_DEVICE_TABLE(tc, tgafb_tc_table);
137
138 static struct tc_driver tgafb_tc_driver = {
139 .id_table = tgafb_tc_table,
140 .driver = {
141 .name = "tgafb",
142 .bus = &tc_bus_type,
143 .probe = tgafb_tc_register,
144 .remove = tgafb_tc_unregister,
145 },
146 };
147
148 static int tgafb_tc_register(struct device *dev)
149 {
150 int status = tgafb_register(dev);
151 if (!status)
152 get_device(dev);
153 return status;
154 }
155
156 static int tgafb_tc_unregister(struct device *dev)
157 {
158 put_device(dev);
159 tgafb_unregister(dev);
160 return 0;
161 }
162 #endif /* CONFIG_TC */
163
164
165 /**
166 * tgafb_check_var - Optional function. Validates a var passed in.
167 * @var: frame buffer variable screen structure
168 * @info: frame buffer structure that represents a single frame buffer
169 */
170 static int
171 tgafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
172 {
173 struct tga_par *par = (struct tga_par *)info->par;
174
175 if (par->tga_type == TGA_TYPE_8PLANE) {
176 if (var->bits_per_pixel != 8)
177 return -EINVAL;
178 } else {
179 if (var->bits_per_pixel != 32)
180 return -EINVAL;
181 }
182 var->red.length = var->green.length = var->blue.length = 8;
183 if (var->bits_per_pixel == 32) {
184 var->red.offset = 16;
185 var->green.offset = 8;
186 var->blue.offset = 0;
187 }
188
189 if (var->xres_virtual != var->xres || var->yres_virtual != var->yres)
190 return -EINVAL;
191 if (var->xres * var->yres * (var->bits_per_pixel >> 3) > info->fix.smem_len)
192 return -EINVAL;
193 if (var->nonstd)
194 return -EINVAL;
195 if (1000000000 / var->pixclock > TGA_PLL_MAX_FREQ)
196 return -EINVAL;
197 if ((var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
198 return -EINVAL;
199
200 /* Some of the acceleration routines assume the line width is
201 a multiple of 64 bytes. */
202 if (var->xres * (par->tga_type == TGA_TYPE_8PLANE ? 1 : 4) % 64)
203 return -EINVAL;
204
205 return 0;
206 }
207
208 /**
209 * tgafb_set_par - Optional function. Alters the hardware state.
210 * @info: frame buffer structure that represents a single frame buffer
211 */
212 static int
213 tgafb_set_par(struct fb_info *info)
214 {
215 static unsigned int const deep_presets[4] = {
216 0x00004000,
217 0x0000440d,
218 0xffffffff,
219 0x0000441d
220 };
221 static unsigned int const rasterop_presets[4] = {
222 0x00000003,
223 0x00000303,
224 0xffffffff,
225 0x00000303
226 };
227 static unsigned int const mode_presets[4] = {
228 0x00000000,
229 0x00000300,
230 0xffffffff,
231 0x00000300
232 };
233 static unsigned int const base_addr_presets[4] = {
234 0x00000000,
235 0x00000001,
236 0xffffffff,
237 0x00000001
238 };
239
240 struct tga_par *par = (struct tga_par *) info->par;
241 int tga_bus_pci = TGA_BUS_PCI(par->dev);
242 int tga_bus_tc = TGA_BUS_TC(par->dev);
243 u32 htimings, vtimings, pll_freq;
244 u8 tga_type;
245 int i;
246
247 /* Encode video timings. */
248 htimings = (((info->var.xres/4) & TGA_HORIZ_ACT_LSB)
249 | (((info->var.xres/4) & 0x600 << 19) & TGA_HORIZ_ACT_MSB));
250 vtimings = (info->var.yres & TGA_VERT_ACTIVE);
251 htimings |= ((info->var.right_margin/4) << 9) & TGA_HORIZ_FP;
252 vtimings |= (info->var.lower_margin << 11) & TGA_VERT_FP;
253 htimings |= ((info->var.hsync_len/4) << 14) & TGA_HORIZ_SYNC;
254 vtimings |= (info->var.vsync_len << 16) & TGA_VERT_SYNC;
255 htimings |= ((info->var.left_margin/4) << 21) & TGA_HORIZ_BP;
256 vtimings |= (info->var.upper_margin << 22) & TGA_VERT_BP;
257
258 if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
259 htimings |= TGA_HORIZ_POLARITY;
260 if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
261 vtimings |= TGA_VERT_POLARITY;
262
263 par->htimings = htimings;
264 par->vtimings = vtimings;
265
266 par->sync_on_green = !!(info->var.sync & FB_SYNC_ON_GREEN);
267
268 /* Store other useful values in par. */
269 par->xres = info->var.xres;
270 par->yres = info->var.yres;
271 par->pll_freq = pll_freq = 1000000000 / info->var.pixclock;
272 par->bits_per_pixel = info->var.bits_per_pixel;
273 info->fix.line_length = par->xres * (par->bits_per_pixel >> 3);
274
275 tga_type = par->tga_type;
276
277 /* First, disable video. */
278 TGA_WRITE_REG(par, TGA_VALID_VIDEO | TGA_VALID_BLANK, TGA_VALID_REG);
279
280 /* Write the DEEP register. */
281 while (TGA_READ_REG(par, TGA_CMD_STAT_REG) & 1) /* wait for not busy */
282 continue;
283 mb();
284 TGA_WRITE_REG(par, deep_presets[tga_type] |
285 (par->sync_on_green ? 0x0 : 0x00010000),
286 TGA_DEEP_REG);
287 while (TGA_READ_REG(par, TGA_CMD_STAT_REG) & 1) /* wait for not busy */
288 continue;
289 mb();
290
291 /* Write some more registers. */
292 TGA_WRITE_REG(par, rasterop_presets[tga_type], TGA_RASTEROP_REG);
293 TGA_WRITE_REG(par, mode_presets[tga_type], TGA_MODE_REG);
294 TGA_WRITE_REG(par, base_addr_presets[tga_type], TGA_BASE_ADDR_REG);
295
296 /* Calculate & write the PLL. */
297 tgafb_set_pll(par, pll_freq);
298
299 /* Write some more registers. */
300 TGA_WRITE_REG(par, 0xffffffff, TGA_PLANEMASK_REG);
301 TGA_WRITE_REG(par, 0xffffffff, TGA_PIXELMASK_REG);
302
303 /* Init video timing regs. */
304 TGA_WRITE_REG(par, htimings, TGA_HORIZ_REG);
305 TGA_WRITE_REG(par, vtimings, TGA_VERT_REG);
306
307 /* Initialise RAMDAC. */
308 if (tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
309
310 /* Init BT485 RAMDAC registers. */
311 BT485_WRITE(par, 0xa2 | (par->sync_on_green ? 0x8 : 0x0),
312 BT485_CMD_0);
313 BT485_WRITE(par, 0x01, BT485_ADDR_PAL_WRITE);
314 BT485_WRITE(par, 0x14, BT485_CMD_3); /* cursor 64x64 */
315 BT485_WRITE(par, 0x40, BT485_CMD_1);
316 BT485_WRITE(par, 0x20, BT485_CMD_2); /* cursor off, for now */
317 BT485_WRITE(par, 0xff, BT485_PIXEL_MASK);
318
319 /* Fill palette registers. */
320 BT485_WRITE(par, 0x00, BT485_ADDR_PAL_WRITE);
321 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
322
323 for (i = 0; i < 256 * 3; i += 4) {
324 TGA_WRITE_REG(par, 0x55 | (BT485_DATA_PAL << 8),
325 TGA_RAMDAC_REG);
326 TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
327 TGA_RAMDAC_REG);
328 TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
329 TGA_RAMDAC_REG);
330 TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
331 TGA_RAMDAC_REG);
332 }
333
334 } else if (tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
335
336 /* Init BT459 RAMDAC registers. */
337 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_0, 0x40);
338 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_1, 0x00);
339 BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_2,
340 (par->sync_on_green ? 0xc0 : 0x40));
341
342 BT459_WRITE(par, BT459_REG_ACC, BT459_CUR_CMD_REG, 0x00);
343
344 /* Fill the palette. */
345 BT459_LOAD_ADDR(par, 0x0000);
346 TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
347
348 for (i = 0; i < 256 * 3; i += 4) {
349 TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
350 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
351 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
352 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
353 }
354
355 } else { /* 24-plane or 24plusZ */
356
357 /* Init BT463 RAMDAC registers. */
358 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_0, 0x40);
359 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_1, 0x08);
360 BT463_WRITE(par, BT463_REG_ACC, BT463_CMD_REG_2,
361 (par->sync_on_green ? 0xc0 : 0x40));
362
363 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_0, 0xff);
364 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_1, 0xff);
365 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_2, 0xff);
366 BT463_WRITE(par, BT463_REG_ACC, BT463_READ_MASK_3, 0x0f);
367
368 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_0, 0x00);
369 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_1, 0x00);
370 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_2, 0x00);
371 BT463_WRITE(par, BT463_REG_ACC, BT463_BLINK_MASK_3, 0x00);
372
373 /* Fill the palette. */
374 BT463_LOAD_ADDR(par, 0x0000);
375 TGA_WRITE_REG(par, BT463_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
376
377 #ifdef CONFIG_HW_CONSOLE
378 for (i = 0; i < 16; i++) {
379 int j = color_table[i];
380
381 TGA_WRITE_REG(par, default_red[j], TGA_RAMDAC_REG);
382 TGA_WRITE_REG(par, default_grn[j], TGA_RAMDAC_REG);
383 TGA_WRITE_REG(par, default_blu[j], TGA_RAMDAC_REG);
384 }
385 for (i = 0; i < 512 * 3; i += 4) {
386 #else
387 for (i = 0; i < 528 * 3; i += 4) {
388 #endif
389 TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
390 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
391 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
392 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
393 }
394
395 /* Fill window type table after start of vertical retrace. */
396 while (!(TGA_READ_REG(par, TGA_INTR_STAT_REG) & 0x01))
397 continue;
398 TGA_WRITE_REG(par, 0x01, TGA_INTR_STAT_REG);
399 mb();
400 while (!(TGA_READ_REG(par, TGA_INTR_STAT_REG) & 0x01))
401 continue;
402 TGA_WRITE_REG(par, 0x01, TGA_INTR_STAT_REG);
403
404 BT463_LOAD_ADDR(par, BT463_WINDOW_TYPE_BASE);
405 TGA_WRITE_REG(par, BT463_REG_ACC << 2, TGA_RAMDAC_SETUP_REG);
406
407 for (i = 0; i < 16; i++) {
408 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
409 TGA_WRITE_REG(par, 0x01, TGA_RAMDAC_REG);
410 TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
411 }
412
413 }
414
415 /* Finally, enable video scan (and pray for the monitor... :-) */
416 TGA_WRITE_REG(par, TGA_VALID_VIDEO, TGA_VALID_REG);
417
418 return 0;
419 }
420
421 #define DIFFCHECK(X) \
422 do { \
423 if (m <= 0x3f) { \
424 int delta = f - (TGA_PLL_BASE_FREQ * (X)) / (r << shift); \
425 if (delta < 0) \
426 delta = -delta; \
427 if (delta < min_diff) \
428 min_diff = delta, vm = m, va = a, vr = r; \
429 } \
430 } while (0)
431
432 static void
433 tgafb_set_pll(struct tga_par *par, int f)
434 {
435 int n, shift, base, min_diff, target;
436 int r,a,m,vm = 34, va = 1, vr = 30;
437
438 for (r = 0 ; r < 12 ; r++)
439 TGA_WRITE_REG(par, !r, TGA_CLOCK_REG);
440
441 if (f > TGA_PLL_MAX_FREQ)
442 f = TGA_PLL_MAX_FREQ;
443
444 if (f >= TGA_PLL_MAX_FREQ / 2)
445 shift = 0;
446 else if (f >= TGA_PLL_MAX_FREQ / 4)
447 shift = 1;
448 else
449 shift = 2;
450
451 TGA_WRITE_REG(par, shift & 1, TGA_CLOCK_REG);
452 TGA_WRITE_REG(par, shift >> 1, TGA_CLOCK_REG);
453
454 for (r = 0 ; r < 10 ; r++)
455 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
456
457 if (f <= 120000) {
458 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
459 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
460 }
461 else if (f <= 200000) {
462 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
463 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
464 }
465 else {
466 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
467 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
468 }
469
470 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
471 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
472 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
473 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
474 TGA_WRITE_REG(par, 0, TGA_CLOCK_REG);
475 TGA_WRITE_REG(par, 1, TGA_CLOCK_REG);
476
477 target = (f << shift) / TGA_PLL_BASE_FREQ;
478 min_diff = TGA_PLL_MAX_FREQ;
479
480 r = 7 / target;
481 if (!r) r = 1;
482
483 base = target * r;
484 while (base < 449) {
485 for (n = base < 7 ? 7 : base; n < base + target && n < 449; n++) {
486 m = ((n + 3) / 7) - 1;
487 a = 0;
488 DIFFCHECK((m + 1) * 7);
489 m++;
490 DIFFCHECK((m + 1) * 7);
491 m = (n / 6) - 1;
492 if ((a = n % 6))
493 DIFFCHECK(n);
494 }
495 r++;
496 base += target;
497 }
498
499 vr--;
500
501 for (r = 0; r < 8; r++)
502 TGA_WRITE_REG(par, (vm >> r) & 1, TGA_CLOCK_REG);
503 for (r = 0; r < 8 ; r++)
504 TGA_WRITE_REG(par, (va >> r) & 1, TGA_CLOCK_REG);
505 for (r = 0; r < 7 ; r++)
506 TGA_WRITE_REG(par, (vr >> r) & 1, TGA_CLOCK_REG);
507 TGA_WRITE_REG(par, ((vr >> 7) & 1)|2, TGA_CLOCK_REG);
508 }
509
510
511 /**
512 * tgafb_setcolreg - Optional function. Sets a color register.
513 * @regno: boolean, 0 copy local, 1 get_user() function
514 * @red: frame buffer colormap structure
515 * @green: The green value which can be up to 16 bits wide
516 * @blue: The blue value which can be up to 16 bits wide.
517 * @transp: If supported the alpha value which can be up to 16 bits wide.
518 * @info: frame buffer info structure
519 */
520 static int
521 tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
522 unsigned transp, struct fb_info *info)
523 {
524 struct tga_par *par = (struct tga_par *) info->par;
525 int tga_bus_pci = TGA_BUS_PCI(par->dev);
526 int tga_bus_tc = TGA_BUS_TC(par->dev);
527
528 if (regno > 255)
529 return 1;
530 red >>= 8;
531 green >>= 8;
532 blue >>= 8;
533
534 if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
535 BT485_WRITE(par, regno, BT485_ADDR_PAL_WRITE);
536 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
537 TGA_WRITE_REG(par, red|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
538 TGA_WRITE_REG(par, green|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
539 TGA_WRITE_REG(par, blue|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
540 } else if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
541 BT459_LOAD_ADDR(par, regno);
542 TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
543 TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
544 TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
545 TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
546 } else {
547 if (regno < 16) {
548 u32 value = (regno << 16) | (regno << 8) | regno;
549 ((u32 *)info->pseudo_palette)[regno] = value;
550 }
551 BT463_LOAD_ADDR(par, regno);
552 TGA_WRITE_REG(par, BT463_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
553 TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
554 TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
555 TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
556 }
557
558 return 0;
559 }
560
561
562 /**
563 * tgafb_blank - Optional function. Blanks the display.
564 * @blank_mode: the blank mode we want.
565 * @info: frame buffer structure that represents a single frame buffer
566 */
567 static int
568 tgafb_blank(int blank, struct fb_info *info)
569 {
570 struct tga_par *par = (struct tga_par *) info->par;
571 u32 vhcr, vvcr, vvvr;
572 unsigned long flags;
573
574 local_irq_save(flags);
575
576 vhcr = TGA_READ_REG(par, TGA_HORIZ_REG);
577 vvcr = TGA_READ_REG(par, TGA_VERT_REG);
578 vvvr = TGA_READ_REG(par, TGA_VALID_REG);
579 vvvr &= ~(TGA_VALID_VIDEO | TGA_VALID_BLANK);
580
581 switch (blank) {
582 case FB_BLANK_UNBLANK: /* Unblanking */
583 if (par->vesa_blanked) {
584 TGA_WRITE_REG(par, vhcr & 0xbfffffff, TGA_HORIZ_REG);
585 TGA_WRITE_REG(par, vvcr & 0xbfffffff, TGA_VERT_REG);
586 par->vesa_blanked = 0;
587 }
588 TGA_WRITE_REG(par, vvvr | TGA_VALID_VIDEO, TGA_VALID_REG);
589 break;
590
591 case FB_BLANK_NORMAL: /* Normal blanking */
592 TGA_WRITE_REG(par, vvvr | TGA_VALID_VIDEO | TGA_VALID_BLANK,
593 TGA_VALID_REG);
594 break;
595
596 case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
597 TGA_WRITE_REG(par, vvcr | 0x40000000, TGA_VERT_REG);
598 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
599 par->vesa_blanked = 1;
600 break;
601
602 case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
603 TGA_WRITE_REG(par, vhcr | 0x40000000, TGA_HORIZ_REG);
604 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
605 par->vesa_blanked = 1;
606 break;
607
608 case FB_BLANK_POWERDOWN: /* Poweroff */
609 TGA_WRITE_REG(par, vhcr | 0x40000000, TGA_HORIZ_REG);
610 TGA_WRITE_REG(par, vvcr | 0x40000000, TGA_VERT_REG);
611 TGA_WRITE_REG(par, vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
612 par->vesa_blanked = 1;
613 break;
614 }
615
616 local_irq_restore(flags);
617 return 0;
618 }
619
620
621 /*
622 * Acceleration.
623 */
624
625 static void
626 tgafb_mono_imageblit(struct fb_info *info, const struct fb_image *image)
627 {
628 struct tga_par *par = (struct tga_par *) info->par;
629 u32 fgcolor, bgcolor, dx, dy, width, height, vxres, vyres, pixelmask;
630 unsigned long rincr, line_length, shift, pos, is8bpp;
631 unsigned long i, j;
632 const unsigned char *data;
633 void __iomem *regs_base;
634 void __iomem *fb_base;
635
636 is8bpp = info->var.bits_per_pixel == 8;
637
638 dx = image->dx;
639 dy = image->dy;
640 width = image->width;
641 height = image->height;
642 vxres = info->var.xres_virtual;
643 vyres = info->var.yres_virtual;
644 line_length = info->fix.line_length;
645 rincr = (width + 7) / 8;
646
647 /* A shift below cannot cope with. */
648 if (unlikely(width == 0))
649 return;
650 /* Crop the image to the screen. */
651 if (dx > vxres || dy > vyres)
652 return;
653 if (dx + width > vxres)
654 width = vxres - dx;
655 if (dy + height > vyres)
656 height = vyres - dy;
657
658 regs_base = par->tga_regs_base;
659 fb_base = par->tga_fb_base;
660
661 /* Expand the color values to fill 32-bits. */
662 /* ??? Would be nice to notice colour changes elsewhere, so
663 that we can do this only when necessary. */
664 fgcolor = image->fg_color;
665 bgcolor = image->bg_color;
666 if (is8bpp) {
667 fgcolor |= fgcolor << 8;
668 fgcolor |= fgcolor << 16;
669 bgcolor |= bgcolor << 8;
670 bgcolor |= bgcolor << 16;
671 } else {
672 if (fgcolor < 16)
673 fgcolor = ((u32 *)info->pseudo_palette)[fgcolor];
674 if (bgcolor < 16)
675 bgcolor = ((u32 *)info->pseudo_palette)[bgcolor];
676 }
677 __raw_writel(fgcolor, regs_base + TGA_FOREGROUND_REG);
678 __raw_writel(bgcolor, regs_base + TGA_BACKGROUND_REG);
679
680 /* Acquire proper alignment; set up the PIXELMASK register
681 so that we only write the proper character cell. */
682 pos = dy * line_length;
683 if (is8bpp) {
684 pos += dx;
685 shift = pos & 3;
686 pos &= -4;
687 } else {
688 pos += dx * 4;
689 shift = (pos & 7) >> 2;
690 pos &= -8;
691 }
692
693 data = (const unsigned char *) image->data;
694
695 /* Enable opaque stipple mode. */
696 __raw_writel((is8bpp
697 ? TGA_MODE_SBM_8BPP | TGA_MODE_OPAQUE_STIPPLE
698 : TGA_MODE_SBM_24BPP | TGA_MODE_OPAQUE_STIPPLE),
699 regs_base + TGA_MODE_REG);
700
701 if (width + shift <= 32) {
702 unsigned long bwidth;
703
704 /* Handle common case of imaging a single character, in
705 a font less than or 32 pixels wide. */
706
707 /* Avoid a shift by 32; width > 0 implied. */
708 pixelmask = (2ul << (width - 1)) - 1;
709 pixelmask <<= shift;
710 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
711 wmb();
712
713 bwidth = (width + 7) / 8;
714
715 for (i = 0; i < height; ++i) {
716 u32 mask = 0;
717
718 /* The image data is bit big endian; we need
719 little endian. */
720 for (j = 0; j < bwidth; ++j)
721 mask |= bitrev8(data[j]) << (j * 8);
722
723 __raw_writel(mask << shift, fb_base + pos);
724
725 pos += line_length;
726 data += rincr;
727 }
728 wmb();
729 __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
730 } else if (shift == 0) {
731 unsigned long pos0 = pos;
732 const unsigned char *data0 = data;
733 unsigned long bincr = (is8bpp ? 8 : 8*4);
734 unsigned long bwidth;
735
736 /* Handle another common case in which accel_putcs
737 generates a large bitmap, which happens to be aligned.
738 Allow the tail to be misaligned. This case is
739 interesting because we've not got to hold partial
740 bytes across the words being written. */
741
742 wmb();
743
744 bwidth = (width / 8) & -4;
745 for (i = 0; i < height; ++i) {
746 for (j = 0; j < bwidth; j += 4) {
747 u32 mask = 0;
748 mask |= bitrev8(data[j+0]) << (0 * 8);
749 mask |= bitrev8(data[j+1]) << (1 * 8);
750 mask |= bitrev8(data[j+2]) << (2 * 8);
751 mask |= bitrev8(data[j+3]) << (3 * 8);
752 __raw_writel(mask, fb_base + pos + j*bincr);
753 }
754 pos += line_length;
755 data += rincr;
756 }
757 wmb();
758
759 pixelmask = (1ul << (width & 31)) - 1;
760 if (pixelmask) {
761 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
762 wmb();
763
764 pos = pos0 + bwidth*bincr;
765 data = data0 + bwidth;
766 bwidth = ((width & 31) + 7) / 8;
767
768 for (i = 0; i < height; ++i) {
769 u32 mask = 0;
770 for (j = 0; j < bwidth; ++j)
771 mask |= bitrev8(data[j]) << (j * 8);
772 __raw_writel(mask, fb_base + pos);
773 pos += line_length;
774 data += rincr;
775 }
776 wmb();
777 __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
778 }
779 } else {
780 unsigned long pos0 = pos;
781 const unsigned char *data0 = data;
782 unsigned long bincr = (is8bpp ? 8 : 8*4);
783 unsigned long bwidth;
784
785 /* Finally, handle the generic case of misaligned start.
786 Here we split the write into 16-bit spans. This allows
787 us to use only one pixel mask, instead of four as would
788 be required by writing 24-bit spans. */
789
790 pixelmask = 0xffff << shift;
791 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
792 wmb();
793
794 bwidth = (width / 8) & -2;
795 for (i = 0; i < height; ++i) {
796 for (j = 0; j < bwidth; j += 2) {
797 u32 mask = 0;
798 mask |= bitrev8(data[j+0]) << (0 * 8);
799 mask |= bitrev8(data[j+1]) << (1 * 8);
800 mask <<= shift;
801 __raw_writel(mask, fb_base + pos + j*bincr);
802 }
803 pos += line_length;
804 data += rincr;
805 }
806 wmb();
807
808 pixelmask = ((1ul << (width & 15)) - 1) << shift;
809 if (pixelmask) {
810 __raw_writel(pixelmask, regs_base + TGA_PIXELMASK_REG);
811 wmb();
812
813 pos = pos0 + bwidth*bincr;
814 data = data0 + bwidth;
815 bwidth = (width & 15) > 8;
816
817 for (i = 0; i < height; ++i) {
818 u32 mask = bitrev8(data[0]);
819 if (bwidth)
820 mask |= bitrev8(data[1]) << 8;
821 mask <<= shift;
822 __raw_writel(mask, fb_base + pos);
823 pos += line_length;
824 data += rincr;
825 }
826 wmb();
827 }
828 __raw_writel(0xffffffff, regs_base + TGA_PIXELMASK_REG);
829 }
830
831 /* Disable opaque stipple mode. */
832 __raw_writel((is8bpp
833 ? TGA_MODE_SBM_8BPP | TGA_MODE_SIMPLE
834 : TGA_MODE_SBM_24BPP | TGA_MODE_SIMPLE),
835 regs_base + TGA_MODE_REG);
836 }
837
838 static void
839 tgafb_clut_imageblit(struct fb_info *info, const struct fb_image *image)
840 {
841 struct tga_par *par = (struct tga_par *) info->par;
842 u32 color, dx, dy, width, height, vxres, vyres;
843 u32 *palette = ((u32 *)info->pseudo_palette);
844 unsigned long pos, line_length, i, j;
845 const unsigned char *data;
846 void __iomem *regs_base, *fb_base;
847
848 dx = image->dx;
849 dy = image->dy;
850 width = image->width;
851 height = image->height;
852 vxres = info->var.xres_virtual;
853 vyres = info->var.yres_virtual;
854 line_length = info->fix.line_length;
855
856 /* Crop the image to the screen. */
857 if (dx > vxres || dy > vyres)
858 return;
859 if (dx + width > vxres)
860 width = vxres - dx;
861 if (dy + height > vyres)
862 height = vyres - dy;
863
864 regs_base = par->tga_regs_base;
865 fb_base = par->tga_fb_base;
866
867 pos = dy * line_length + (dx * 4);
868 data = image->data;
869
870 /* Now copy the image, color_expanding via the palette. */
871 for (i = 0; i < height; i++) {
872 for (j = 0; j < width; j++) {
873 color = palette[*data++];
874 __raw_writel(color, fb_base + pos + j*4);
875 }
876 pos += line_length;
877 }
878 }
879
880 /**
881 * tgafb_imageblit - REQUIRED function. Can use generic routines if
882 * non acclerated hardware and packed pixel based.
883 * Copies a image from system memory to the screen.
884 *
885 * @info: frame buffer structure that represents a single frame buffer
886 * @image: structure defining the image.
887 */
888 static void
889 tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
890 {
891 unsigned int is8bpp = info->var.bits_per_pixel == 8;
892
893 /* If a mono image, regardless of FB depth, go do it. */
894 if (image->depth == 1) {
895 tgafb_mono_imageblit(info, image);
896 return;
897 }
898
899 /* For copies that aren't pixel expansion, there's little we
900 can do better than the generic code. */
901 /* ??? There is a DMA write mode; I wonder if that could be
902 made to pull the data from the image buffer... */
903 if (image->depth == info->var.bits_per_pixel) {
904 cfb_imageblit(info, image);
905 return;
906 }
907
908 /* If 24-plane FB and the image is 8-plane with CLUT, we can do it. */
909 if (!is8bpp && image->depth == 8) {
910 tgafb_clut_imageblit(info, image);
911 return;
912 }
913
914 /* Silently return... */
915 }
916
917 /**
918 * tgafb_fillrect - REQUIRED function. Can use generic routines if
919 * non acclerated hardware and packed pixel based.
920 * Draws a rectangle on the screen.
921 *
922 * @info: frame buffer structure that represents a single frame buffer
923 * @rect: structure defining the rectagle and operation.
924 */
925 static void
926 tgafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
927 {
928 struct tga_par *par = (struct tga_par *) info->par;
929 int is8bpp = info->var.bits_per_pixel == 8;
930 u32 dx, dy, width, height, vxres, vyres, color;
931 unsigned long pos, align, line_length, i, j;
932 void __iomem *regs_base;
933 void __iomem *fb_base;
934
935 dx = rect->dx;
936 dy = rect->dy;
937 width = rect->width;
938 height = rect->height;
939 vxres = info->var.xres_virtual;
940 vyres = info->var.yres_virtual;
941 line_length = info->fix.line_length;
942 regs_base = par->tga_regs_base;
943 fb_base = par->tga_fb_base;
944
945 /* Crop the rectangle to the screen. */
946 if (dx > vxres || dy > vyres || !width || !height)
947 return;
948 if (dx + width > vxres)
949 width = vxres - dx;
950 if (dy + height > vyres)
951 height = vyres - dy;
952
953 pos = dy * line_length + dx * (is8bpp ? 1 : 4);
954
955 /* ??? We could implement ROP_XOR with opaque fill mode
956 and a RasterOp setting of GXxor, but as far as I can
957 tell, this mode is not actually used in the kernel.
958 Thus I am ignoring it for now. */
959 if (rect->rop != ROP_COPY) {
960 cfb_fillrect(info, rect);
961 return;
962 }
963
964 /* Expand the color value to fill 8 pixels. */
965 color = rect->color;
966 if (is8bpp) {
967 color |= color << 8;
968 color |= color << 16;
969 __raw_writel(color, regs_base + TGA_BLOCK_COLOR0_REG);
970 __raw_writel(color, regs_base + TGA_BLOCK_COLOR1_REG);
971 } else {
972 if (color < 16)
973 color = ((u32 *)info->pseudo_palette)[color];
974 __raw_writel(color, regs_base + TGA_BLOCK_COLOR0_REG);
975 __raw_writel(color, regs_base + TGA_BLOCK_COLOR1_REG);
976 __raw_writel(color, regs_base + TGA_BLOCK_COLOR2_REG);
977 __raw_writel(color, regs_base + TGA_BLOCK_COLOR3_REG);
978 __raw_writel(color, regs_base + TGA_BLOCK_COLOR4_REG);
979 __raw_writel(color, regs_base + TGA_BLOCK_COLOR5_REG);
980 __raw_writel(color, regs_base + TGA_BLOCK_COLOR6_REG);
981 __raw_writel(color, regs_base + TGA_BLOCK_COLOR7_REG);
982 }
983
984 /* The DATA register holds the fill mask for block fill mode.
985 Since we're not stippling, this is all ones. */
986 __raw_writel(0xffffffff, regs_base + TGA_DATA_REG);
987
988 /* Enable block fill mode. */
989 __raw_writel((is8bpp
990 ? TGA_MODE_SBM_8BPP | TGA_MODE_BLOCK_FILL
991 : TGA_MODE_SBM_24BPP | TGA_MODE_BLOCK_FILL),
992 regs_base + TGA_MODE_REG);
993 wmb();
994
995 /* We can fill 2k pixels per operation. Notice blocks that fit
996 the width of the screen so that we can take advantage of this
997 and fill more than one line per write. */
998 if (width == line_length)
999 width *= height, height = 1;
1000
1001 /* The write into the frame buffer must be aligned to 4 bytes,
1002 but we are allowed to encode the offset within the word in
1003 the data word written. */
1004 align = (pos & 3) << 16;
1005 pos &= -4;
1006
1007 if (width <= 2048) {
1008 u32 data;
1009
1010 data = (width - 1) | align;
1011
1012 for (i = 0; i < height; ++i) {
1013 __raw_writel(data, fb_base + pos);
1014 pos += line_length;
1015 }
1016 } else {
1017 unsigned long Bpp = (is8bpp ? 1 : 4);
1018 unsigned long nwidth = width & -2048;
1019 u32 fdata, ldata;
1020
1021 fdata = (2048 - 1) | align;
1022 ldata = ((width & 2047) - 1) | align;
1023
1024 for (i = 0; i < height; ++i) {
1025 for (j = 0; j < nwidth; j += 2048)
1026 __raw_writel(fdata, fb_base + pos + j*Bpp);
1027 if (j < width)
1028 __raw_writel(ldata, fb_base + pos + j*Bpp);
1029 pos += line_length;
1030 }
1031 }
1032 wmb();
1033
1034 /* Disable block fill mode. */
1035 __raw_writel((is8bpp
1036 ? TGA_MODE_SBM_8BPP | TGA_MODE_SIMPLE
1037 : TGA_MODE_SBM_24BPP | TGA_MODE_SIMPLE),
1038 regs_base + TGA_MODE_REG);
1039 }
1040
1041 /**
1042 * tgafb_copyarea - REQUIRED function. Can use generic routines if
1043 * non acclerated hardware and packed pixel based.
1044 * Copies on area of the screen to another area.
1045 *
1046 * @info: frame buffer structure that represents a single frame buffer
1047 * @area: structure defining the source and destination.
1048 */
1049
1050 /* Handle the special case of copying entire lines, e.g. during scrolling.
1051 We can avoid a lot of needless computation in this case. In the 8bpp
1052 case we need to use the COPY64 registers instead of mask writes into
1053 the frame buffer to achieve maximum performance. */
1054
1055 static inline void
1056 copyarea_line_8bpp(struct fb_info *info, u32 dy, u32 sy,
1057 u32 height, u32 width)
1058 {
1059 struct tga_par *par = (struct tga_par *) info->par;
1060 void __iomem *tga_regs = par->tga_regs_base;
1061 unsigned long dpos, spos, i, n64;
1062
1063 /* Set up the MODE and PIXELSHIFT registers. */
1064 __raw_writel(TGA_MODE_SBM_8BPP | TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1065 __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1066 wmb();
1067
1068 n64 = (height * width) / 64;
1069
1070 if (sy < dy) {
1071 spos = (sy + height) * width;
1072 dpos = (dy + height) * width;
1073
1074 for (i = 0; i < n64; ++i) {
1075 spos -= 64;
1076 dpos -= 64;
1077 __raw_writel(spos, tga_regs+TGA_COPY64_SRC);
1078 wmb();
1079 __raw_writel(dpos, tga_regs+TGA_COPY64_DST);
1080 wmb();
1081 }
1082 } else {
1083 spos = sy * width;
1084 dpos = dy * width;
1085
1086 for (i = 0; i < n64; ++i) {
1087 __raw_writel(spos, tga_regs+TGA_COPY64_SRC);
1088 wmb();
1089 __raw_writel(dpos, tga_regs+TGA_COPY64_DST);
1090 wmb();
1091 spos += 64;
1092 dpos += 64;
1093 }
1094 }
1095
1096 /* Reset the MODE register to normal. */
1097 __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1098 }
1099
1100 static inline void
1101 copyarea_line_32bpp(struct fb_info *info, u32 dy, u32 sy,
1102 u32 height, u32 width)
1103 {
1104 struct tga_par *par = (struct tga_par *) info->par;
1105 void __iomem *tga_regs = par->tga_regs_base;
1106 void __iomem *tga_fb = par->tga_fb_base;
1107 void __iomem *src;
1108 void __iomem *dst;
1109 unsigned long i, n16;
1110
1111 /* Set up the MODE and PIXELSHIFT registers. */
1112 __raw_writel(TGA_MODE_SBM_24BPP | TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1113 __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1114 wmb();
1115
1116 n16 = (height * width) / 16;
1117
1118 if (sy < dy) {
1119 src = tga_fb + (sy + height) * width * 4;
1120 dst = tga_fb + (dy + height) * width * 4;
1121
1122 for (i = 0; i < n16; ++i) {
1123 src -= 64;
1124 dst -= 64;
1125 __raw_writel(0xffff, src);
1126 wmb();
1127 __raw_writel(0xffff, dst);
1128 wmb();
1129 }
1130 } else {
1131 src = tga_fb + sy * width * 4;
1132 dst = tga_fb + dy * width * 4;
1133
1134 for (i = 0; i < n16; ++i) {
1135 __raw_writel(0xffff, src);
1136 wmb();
1137 __raw_writel(0xffff, dst);
1138 wmb();
1139 src += 64;
1140 dst += 64;
1141 }
1142 }
1143
1144 /* Reset the MODE register to normal. */
1145 __raw_writel(TGA_MODE_SBM_24BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1146 }
1147
1148 /* The (almost) general case of backward copy in 8bpp mode. */
1149 static inline void
1150 copyarea_8bpp(struct fb_info *info, u32 dx, u32 dy, u32 sx, u32 sy,
1151 u32 height, u32 width, u32 line_length,
1152 const struct fb_copyarea *area)
1153 {
1154 struct tga_par *par = (struct tga_par *) info->par;
1155 unsigned i, yincr;
1156 int depos, sepos, backward, last_step, step;
1157 u32 mask_last;
1158 unsigned n32;
1159 void __iomem *tga_regs;
1160 void __iomem *tga_fb;
1161
1162 /* Do acceleration only if we are aligned on 8 pixels */
1163 if ((dx | sx | width) & 7) {
1164 cfb_copyarea(info, area);
1165 return;
1166 }
1167
1168 yincr = line_length;
1169 if (dy > sy) {
1170 dy += height - 1;
1171 sy += height - 1;
1172 yincr = -yincr;
1173 }
1174 backward = dy == sy && dx > sx && dx < sx + width;
1175
1176 /* Compute the offsets and alignments in the frame buffer.
1177 More than anything else, these control how we do copies. */
1178 depos = dy * line_length + dx;
1179 sepos = sy * line_length + sx;
1180 if (backward)
1181 depos += width, sepos += width;
1182
1183 /* Next copy full words at a time. */
1184 n32 = width / 32;
1185 last_step = width % 32;
1186
1187 /* Finally copy the unaligned head of the span. */
1188 mask_last = (1ul << last_step) - 1;
1189
1190 if (!backward) {
1191 step = 32;
1192 last_step = 32;
1193 } else {
1194 step = -32;
1195 last_step = -last_step;
1196 sepos -= 32;
1197 depos -= 32;
1198 }
1199
1200 tga_regs = par->tga_regs_base;
1201 tga_fb = par->tga_fb_base;
1202
1203 /* Set up the MODE and PIXELSHIFT registers. */
1204 __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_COPY, tga_regs+TGA_MODE_REG);
1205 __raw_writel(0, tga_regs+TGA_PIXELSHIFT_REG);
1206 wmb();
1207
1208 for (i = 0; i < height; ++i) {
1209 unsigned long j;
1210 void __iomem *sfb;
1211 void __iomem *dfb;
1212
1213 sfb = tga_fb + sepos;
1214 dfb = tga_fb + depos;
1215
1216 for (j = 0; j < n32; j++) {
1217 if (j < 2 && j + 1 < n32 && !backward &&
1218 !(((unsigned long)sfb | (unsigned long)dfb) & 63)) {
1219 do {
1220 __raw_writel(sfb - tga_fb, tga_regs+TGA_COPY64_SRC);
1221 wmb();
1222 __raw_writel(dfb - tga_fb, tga_regs+TGA_COPY64_DST);
1223 wmb();
1224 sfb += 64;
1225 dfb += 64;
1226 j += 2;
1227 } while (j + 1 < n32);
1228 j--;
1229 continue;
1230 }
1231 __raw_writel(0xffffffff, sfb);
1232 wmb();
1233 __raw_writel(0xffffffff, dfb);
1234 wmb();
1235 sfb += step;
1236 dfb += step;
1237 }
1238
1239 if (mask_last) {
1240 sfb += last_step - step;
1241 dfb += last_step - step;
1242 __raw_writel(mask_last, sfb);
1243 wmb();
1244 __raw_writel(mask_last, dfb);
1245 wmb();
1246 }
1247
1248 sepos += yincr;
1249 depos += yincr;
1250 }
1251
1252 /* Reset the MODE register to normal. */
1253 __raw_writel(TGA_MODE_SBM_8BPP|TGA_MODE_SIMPLE, tga_regs+TGA_MODE_REG);
1254 }
1255
1256 static void
1257 tgafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
1258 {
1259 unsigned long dx, dy, width, height, sx, sy, vxres, vyres;
1260 unsigned long line_length, bpp;
1261
1262 dx = area->dx;
1263 dy = area->dy;
1264 width = area->width;
1265 height = area->height;
1266 sx = area->sx;
1267 sy = area->sy;
1268 vxres = info->var.xres_virtual;
1269 vyres = info->var.yres_virtual;
1270 line_length = info->fix.line_length;
1271
1272 /* The top left corners must be in the virtual screen. */
1273 if (dx > vxres || sx > vxres || dy > vyres || sy > vyres)
1274 return;
1275
1276 /* Clip the destination. */
1277 if (dx + width > vxres)
1278 width = vxres - dx;
1279 if (dy + height > vyres)
1280 height = vyres - dy;
1281
1282 /* The source must be completely inside the virtual screen. */
1283 if (sx + width > vxres || sy + height > vyres)
1284 return;
1285
1286 bpp = info->var.bits_per_pixel;
1287
1288 /* Detect copies of the entire line. */
1289 if (width * (bpp >> 3) == line_length) {
1290 if (bpp == 8)
1291 copyarea_line_8bpp(info, dy, sy, height, width);
1292 else
1293 copyarea_line_32bpp(info, dy, sy, height, width);
1294 }
1295
1296 /* ??? The documentation is unclear to me exactly how the pixelshift
1297 register works in 32bpp mode. Since I don't have hardware to test,
1298 give up for now and fall back on the generic routines. */
1299 else if (bpp == 32)
1300 cfb_copyarea(info, area);
1301
1302 else
1303 copyarea_8bpp(info, dx, dy, sx, sy, height,
1304 width, line_length, area);
1305 }
1306
1307
1308 /*
1309 * Initialisation
1310 */
1311
1312 static void
1313 tgafb_init_fix(struct fb_info *info)
1314 {
1315 struct tga_par *par = (struct tga_par *)info->par;
1316 int tga_bus_pci = TGA_BUS_PCI(par->dev);
1317 int tga_bus_tc = TGA_BUS_TC(par->dev);
1318 u8 tga_type = par->tga_type;
1319 const char *tga_type_name = NULL;
1320 unsigned memory_size;
1321
1322 switch (tga_type) {
1323 case TGA_TYPE_8PLANE:
1324 if (tga_bus_pci)
1325 tga_type_name = "Digital ZLXp-E1";
1326 if (tga_bus_tc)
1327 tga_type_name = "Digital ZLX-E1";
1328 memory_size = 2097152;
1329 break;
1330 case TGA_TYPE_24PLANE:
1331 if (tga_bus_pci)
1332 tga_type_name = "Digital ZLXp-E2";
1333 if (tga_bus_tc)
1334 tga_type_name = "Digital ZLX-E2";
1335 memory_size = 8388608;
1336 break;
1337 case TGA_TYPE_24PLUSZ:
1338 if (tga_bus_pci)
1339 tga_type_name = "Digital ZLXp-E3";
1340 if (tga_bus_tc)
1341 tga_type_name = "Digital ZLX-E3";
1342 memory_size = 16777216;
1343 break;
1344 default:
1345 tga_type_name = "Unknown";
1346 memory_size = 16777216;
1347 break;
1348 }
1349
1350 strlcpy(info->fix.id, tga_type_name, sizeof(info->fix.id));
1351
1352 info->fix.type = FB_TYPE_PACKED_PIXELS;
1353 info->fix.type_aux = 0;
1354 info->fix.visual = (tga_type == TGA_TYPE_8PLANE
1355 ? FB_VISUAL_PSEUDOCOLOR
1356 : FB_VISUAL_DIRECTCOLOR);
1357
1358 info->fix.smem_start = (size_t) par->tga_fb_base;
1359 info->fix.smem_len = memory_size;
1360 info->fix.mmio_start = (size_t) par->tga_regs_base;
1361 info->fix.mmio_len = 512;
1362
1363 info->fix.xpanstep = 0;
1364 info->fix.ypanstep = 0;
1365 info->fix.ywrapstep = 0;
1366
1367 info->fix.accel = FB_ACCEL_DEC_TGA;
1368
1369 /*
1370 * These are needed by fb_set_logo_truepalette(), so we
1371 * set them here for 24-plane cards.
1372 */
1373 if (tga_type != TGA_TYPE_8PLANE) {
1374 info->var.red.length = 8;
1375 info->var.green.length = 8;
1376 info->var.blue.length = 8;
1377 info->var.red.offset = 16;
1378 info->var.green.offset = 8;
1379 info->var.blue.offset = 0;
1380 }
1381 }
1382
1383 static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
1384 {
1385 /* We just use this to catch switches out of graphics mode. */
1386 tgafb_set_par(info); /* A bit of overkill for BASE_ADDR reset. */
1387 return 0;
1388 }
1389
1390 static int tgafb_register(struct device *dev)
1391 {
1392 static const struct fb_videomode modedb_tc = {
1393 /* 1280x1024 @ 72 Hz, 76.8 kHz hsync */
1394 "1280x1024@72", 0, 1280, 1024, 7645, 224, 28, 33, 3, 160, 3,
1395 FB_SYNC_ON_GREEN, FB_VMODE_NONINTERLACED
1396 };
1397
1398 static unsigned int const fb_offset_presets[4] = {
1399 TGA_8PLANE_FB_OFFSET,
1400 TGA_24PLANE_FB_OFFSET,
1401 0xffffffff,
1402 TGA_24PLUSZ_FB_OFFSET
1403 };
1404
1405 const struct fb_videomode *modedb_tga = NULL;
1406 resource_size_t bar0_start = 0, bar0_len = 0;
1407 const char *mode_option_tga = NULL;
1408 int tga_bus_pci = TGA_BUS_PCI(dev);
1409 int tga_bus_tc = TGA_BUS_TC(dev);
1410 unsigned int modedbsize_tga = 0;
1411 void __iomem *mem_base;
1412 struct fb_info *info;
1413 struct tga_par *par;
1414 u8 tga_type;
1415 int ret = 0;
1416
1417 /* Enable device in PCI config. */
1418 if (tga_bus_pci && pci_enable_device(to_pci_dev(dev))) {
1419 printk(KERN_ERR "tgafb: Cannot enable PCI device\n");
1420 return -ENODEV;
1421 }
1422
1423 /* Allocate the fb and par structures. */
1424 info = framebuffer_alloc(sizeof(struct tga_par), dev);
1425 if (!info) {
1426 printk(KERN_ERR "tgafb: Cannot allocate memory\n");
1427 return -ENOMEM;
1428 }
1429
1430 par = info->par;
1431 dev_set_drvdata(dev, info);
1432
1433 /* Request the mem regions. */
1434 ret = -ENODEV;
1435 if (tga_bus_pci) {
1436 bar0_start = pci_resource_start(to_pci_dev(dev), 0);
1437 bar0_len = pci_resource_len(to_pci_dev(dev), 0);
1438 }
1439 if (tga_bus_tc) {
1440 bar0_start = to_tc_dev(dev)->resource.start;
1441 bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
1442 }
1443 if (!request_mem_region (bar0_start, bar0_len, "tgafb")) {
1444 printk(KERN_ERR "tgafb: cannot reserve FB region\n");
1445 goto err0;
1446 }
1447
1448 /* Map the framebuffer. */
1449 mem_base = ioremap_nocache(bar0_start, bar0_len);
1450 if (!mem_base) {
1451 printk(KERN_ERR "tgafb: Cannot map MMIO\n");
1452 goto err1;
1453 }
1454
1455 /* Grab info about the card. */
1456 tga_type = (readl(mem_base) >> 12) & 0x0f;
1457 par->dev = dev;
1458 par->tga_mem_base = mem_base;
1459 par->tga_fb_base = mem_base + fb_offset_presets[tga_type];
1460 par->tga_regs_base = mem_base + TGA_REGS_OFFSET;
1461 par->tga_type = tga_type;
1462 if (tga_bus_pci)
1463 par->tga_chip_rev = (to_pci_dev(dev))->revision;
1464 if (tga_bus_tc)
1465 par->tga_chip_rev = TGA_READ_REG(par, TGA_START_REG) & 0xff;
1466
1467 /* Setup framebuffer. */
1468 info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA |
1469 FBINFO_HWACCEL_IMAGEBLIT | FBINFO_HWACCEL_FILLRECT;
1470 info->fbops = &tgafb_ops;
1471 info->screen_base = par->tga_fb_base;
1472 info->pseudo_palette = par->palette;
1473
1474 /* This should give a reasonable default video mode. */
1475 if (tga_bus_pci) {
1476 mode_option_tga = mode_option_pci;
1477 }
1478 if (tga_bus_tc) {
1479 mode_option_tga = mode_option_tc;
1480 modedb_tga = &modedb_tc;
1481 modedbsize_tga = 1;
1482 }
1483
1484 tgafb_init_fix(info);
1485
1486 ret = fb_find_mode(&info->var, info,
1487 mode_option ? mode_option : mode_option_tga,
1488 modedb_tga, modedbsize_tga, NULL,
1489 tga_type == TGA_TYPE_8PLANE ? 8 : 32);
1490 if (ret == 0 || ret == 4) {
1491 printk(KERN_ERR "tgafb: Could not find valid video mode\n");
1492 ret = -EINVAL;
1493 goto err1;
1494 }
1495
1496 if (fb_alloc_cmap(&info->cmap, 256, 0)) {
1497 printk(KERN_ERR "tgafb: Could not allocate color map\n");
1498 ret = -ENOMEM;
1499 goto err1;
1500 }
1501
1502 tgafb_set_par(info);
1503
1504 if (register_framebuffer(info) < 0) {
1505 printk(KERN_ERR "tgafb: Could not register framebuffer\n");
1506 ret = -EINVAL;
1507 goto err2;
1508 }
1509
1510 if (tga_bus_pci) {
1511 pr_info("tgafb: DC21030 [TGA] detected, rev=0x%02x\n",
1512 par->tga_chip_rev);
1513 pr_info("tgafb: at PCI bus %d, device %d, function %d\n",
1514 to_pci_dev(dev)->bus->number,
1515 PCI_SLOT(to_pci_dev(dev)->devfn),
1516 PCI_FUNC(to_pci_dev(dev)->devfn));
1517 }
1518 if (tga_bus_tc)
1519 pr_info("tgafb: SFB+ detected, rev=0x%02x\n",
1520 par->tga_chip_rev);
1521 pr_info("fb%d: %s frame buffer device at 0x%lx\n",
1522 info->node, info->fix.id, (long)bar0_start);
1523
1524 return 0;
1525
1526 err2:
1527 fb_dealloc_cmap(&info->cmap);
1528 err1:
1529 if (mem_base)
1530 iounmap(mem_base);
1531 release_mem_region(bar0_start, bar0_len);
1532 err0:
1533 framebuffer_release(info);
1534 return ret;
1535 }
1536
1537 static void tgafb_unregister(struct device *dev)
1538 {
1539 resource_size_t bar0_start = 0, bar0_len = 0;
1540 int tga_bus_pci = TGA_BUS_PCI(dev);
1541 int tga_bus_tc = TGA_BUS_TC(dev);
1542 struct fb_info *info = NULL;
1543 struct tga_par *par;
1544
1545 info = dev_get_drvdata(dev);
1546 if (!info)
1547 return;
1548
1549 par = info->par;
1550 unregister_framebuffer(info);
1551 fb_dealloc_cmap(&info->cmap);
1552 iounmap(par->tga_mem_base);
1553 if (tga_bus_pci) {
1554 bar0_start = pci_resource_start(to_pci_dev(dev), 0);
1555 bar0_len = pci_resource_len(to_pci_dev(dev), 0);
1556 }
1557 if (tga_bus_tc) {
1558 bar0_start = to_tc_dev(dev)->resource.start;
1559 bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
1560 }
1561 release_mem_region(bar0_start, bar0_len);
1562 framebuffer_release(info);
1563 }
1564
1565 static void tgafb_exit(void)
1566 {
1567 tc_unregister_driver(&tgafb_tc_driver);
1568 pci_unregister_driver(&tgafb_pci_driver);
1569 }
1570
1571 #ifndef MODULE
1572 static int tgafb_setup(char *arg)
1573 {
1574 char *this_opt;
1575
1576 if (arg && *arg) {
1577 while ((this_opt = strsep(&arg, ","))) {
1578 if (!*this_opt)
1579 continue;
1580 if (!strncmp(this_opt, "mode:", 5))
1581 mode_option = this_opt+5;
1582 else
1583 printk(KERN_ERR
1584 "tgafb: unknown parameter %s\n",
1585 this_opt);
1586 }
1587 }
1588
1589 return 0;
1590 }
1591 #endif /* !MODULE */
1592
1593 static int tgafb_init(void)
1594 {
1595 int status;
1596 #ifndef MODULE
1597 char *option = NULL;
1598
1599 if (fb_get_options("tgafb", &option))
1600 return -ENODEV;
1601 tgafb_setup(option);
1602 #endif
1603 status = pci_register_driver(&tgafb_pci_driver);
1604 if (!status)
1605 status = tc_register_driver(&tgafb_tc_driver);
1606 return status;
1607 }
1608
1609 /*
1610 * Modularisation
1611 */
1612
1613 module_init(tgafb_init);
1614 module_exit(tgafb_exit);
1615
1616 MODULE_DESCRIPTION("Framebuffer driver for TGA/SFB+ chipset");
1617 MODULE_LICENSE("GPL");
Linux with added FPC-III support