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