File: /usr/src/linux/drivers/video/fbcon-mac.c
1 /*
2 * linux/drivers/video/fbcon-mac.c -- Low level frame buffer operations for
3 * x bpp packed pixels, font width != 8
4 *
5 * Created 26 Dec 1997 by Michael Schmitz
6 * Based on the old macfb.c 6x11 code by Randy Thelen
7 *
8 * This driver is significantly slower than the 8bit font drivers
9 * and would probably benefit from splitting into drivers for each depth.
10 *
11 * This file is subject to the terms and conditions of the GNU General Public
12 * License. See the file COPYING in the main directory of this archive for
13 */
14
15 #include <linux/module.h>
16 #include <linux/tty.h>
17 #include <linux/console.h>
18 #include <linux/string.h>
19 #include <linux/fb.h>
20 #include <linux/delay.h>
21
22 #include <video/fbcon.h>
23 #include <video/fbcon-mac.h>
24
25
26 /*
27 * variable bpp packed pixels
28 */
29
30 static void plot_pixel_mac(struct display *p, int bw, int pixel_x,
31 int pixel_y);
32 static int get_pixel_mac(struct display *p, int pixel_x, int pixel_y);
33
34 void fbcon_mac_setup(struct display *p)
35 {
36 if (p->line_length)
37 p->next_line = p->line_length;
38 else
39 p->next_line = p->var.xres_virtual>>3;
40 p->next_plane = 0;
41 }
42
43
44 /*
45 * Macintosh
46 */
47 #define PIXEL_BLACK_MAC 0
48 #define PIXEL_WHITE_MAC 1
49 #define PIXEL_INVERT_MAC 2
50
51 void fbcon_mac_bmove(struct display *p, int sy, int sx, int dy, int dx,
52 int height, int width)
53 {
54 int i, j;
55 u8 *dest, *src;
56 int l,r,t,b,w,lo,s;
57 int dl,dr,dt,db,dw,dlo;
58 int move_up;
59
60 src = (u8 *) (p->screen_base + sy * fontheight(p) * p->next_line);
61 dest = (u8 *) (p->screen_base + dy * fontheight(p) * p->next_line);
62
63 if( sx == 0 && width == p->conp->vc_cols) {
64 s = height * fontheight(p) * p->next_line;
65 fb_memmove(dest, src, s);
66 return;
67 }
68
69 l = sx * fontwidth(p);
70 r = l + width * fontwidth(p);
71 t = sy * fontheight(p);
72 b = t + height * fontheight(p);
73
74 dl = dx * fontwidth(p);
75 dr = dl + width * fontwidth(p);
76 dt = dy * fontheight(p);
77 db = dt + height * fontheight(p);
78
79 /* w is the # pixels between two long-aligned points, left and right */
80 w = (r&~31) - ((l+31)&~31);
81 dw = (dr&~31) - ((dl+31)&~31);
82 /* lo is the # pixels between the left edge and a long-aligned left pixel */
83 lo = ((l+31)&~31) - l;
84 dlo = ((dl+31)&~31) - dl;
85
86 /* if dx != sx then, logic has to align the left and right edges for fast moves */
87 if (lo != dlo) {
88 lo = ((l+7)&~7) - l;
89 dlo = ((dl+7)&~7) - dl;
90 w = (r&~7) - ((l+7)&~7);
91 dw = (dr&~7) - ((dl+7)&~7);
92 if (lo != dlo) {
93 unsigned char err_str[128];
94 unsigned short err_buf[256];
95 unsigned long cnt, len;
96 sprintf( err_str, "ERROR: Shift algorithm: sx=%d,sy=%d,dx=%d,dy=%d,w=%d,h=%d,bpp=%d",
97 sx,sy,dx,dy,width,height,p->var.bits_per_pixel);
98 len = strlen(err_str);
99 for (cnt = 0; cnt < len; cnt++)
100 err_buf[cnt] = 0x700 | err_str[cnt];
101 fbcon_mac_putcs(p->conp, p, err_buf, len, 0, 0);
102 /* pause for the user */
103 printk( "ERROR: shift algorithm...\n" );
104 mdelay(5000);
105 return;
106 }
107 }
108
109 s = 0;
110 switch (p->var.bits_per_pixel) {
111 case 1:
112 s = w >> 3;
113 src += lo >> 3;
114 dest += lo >> 3;
115 break;
116 case 2:
117 s = w >> 2;
118 src += lo >> 2;
119 dest += lo >> 2;
120 break;
121 case 4:
122 s = w >> 1;
123 src += lo >> 1;
124 dest += lo >> 1;
125 break;
126 case 8:
127 s = w;
128 src += lo;
129 dest += lo;
130 break;
131 case 16:
132 s = w << 1;
133 src += lo << 1;
134 dest += lo << 1;
135 break;
136 case 32:
137 s = w << 2;
138 src += lo << 2;
139 dest += lo << 2;
140 break;
141 }
142
143 if (sy <= sx) {
144 i = b;
145 move_up = 0;
146 src += height * fontheight(p);
147 dest += height * fontheight(p);
148 } else {
149 i = t;
150 move_up = 1;
151 }
152
153 while (1) {
154 for (i = t; i < b; i++) {
155 j = l;
156
157 for (; j & 31 && j < r; j++)
158 plot_pixel_mac(p, get_pixel_mac(p, j+(dx-sx), i+(dy-sy)), j, i);
159
160 if (j < r) {
161 fb_memmove(dest, src, s);
162 if (move_up) {
163 dest += p->next_line;
164 src += p->next_line;
165 } else {
166 dest -= p->next_line;
167 src -= p->next_line;
168 }
169 j += w;
170 }
171
172 for (; j < r; j++)
173 plot_pixel_mac(p, get_pixel_mac(p, j+(dx-sx), i+(dy-sy)), j, i);
174 }
175
176 if (move_up) {
177 i++;
178 if (i >= b)
179 break;
180 } else {
181 i--;
182 if (i < t)
183 break;
184 }
185 }
186 }
187
188
189 void fbcon_mac_clear(struct vc_data *conp, struct display *p, int sy, int sx,
190 int height, int width)
191 {
192 int pixel;
193 int i, j;
194 int inverse;
195 u8 *dest;
196 int l,r,t,b,w,lo,s;
197
198 inverse = conp ? attr_reverse(p,conp->vc_attr) : 0;
199 pixel = inverse ? PIXEL_WHITE_MAC : PIXEL_BLACK_MAC;
200 dest = (u8 *) (p->screen_base + sy * fontheight(p) * p->next_line);
201
202 if( sx == 0 && width == p->conp->vc_cols) {
203 s = height * fontheight(p) * p->next_line;
204 if (inverse)
205 fb_memclear(dest, s);
206 else
207 fb_memset255(dest, s);
208 }
209
210 l = sx * fontwidth(p);
211 r = l + width * fontwidth(p);
212 t = sy * fontheight(p);
213 b = t + height * fontheight(p);
214 /* w is the # pixels between two long-aligned points, left and right */
215 w = (r&~31) - ((l+31)&~31);
216 /* lo is the # pixels between the left edge and a long-aligned left pixel */
217 lo = ((l+31)&~31) - l;
218 s = 0;
219 switch (p->var.bits_per_pixel) {
220 case 1:
221 s = w >> 3;
222 dest += lo >> 3;
223 break;
224 case 2:
225 s = w >> 2;
226 dest += lo >> 2;
227 break;
228 case 4:
229 s = w >> 1;
230 dest += lo >> 1;
231 break;
232 case 8:
233 s = w;
234 dest += lo;
235 break;
236 case 16:
237 s = w << 1;
238 dest += lo << 1;
239 break;
240 case 32:
241 s = w << 2;
242 dest += lo << 2;
243 break;
244 }
245
246 for (i = t; i < b; i++) {
247 j = l;
248
249 for (; j & 31 && j < r; j++)
250 plot_pixel_mac(p, pixel, j, i);
251
252 if (j < r) {
253 if (PIXEL_WHITE_MAC == pixel)
254 fb_memclear(dest, s);
255 else
256 fb_memset255(dest, s);
257 dest += p->next_line;
258 j += w;
259 }
260
261 for (; j < r; j++)
262 plot_pixel_mac(p, pixel, j, i);
263 }
264 }
265
266
267 void fbcon_mac_putc(struct vc_data *conp, struct display *p, int c, int yy,
268 int xx)
269 {
270 u8 *cdat;
271 u_int rows, bold, ch_reverse, ch_underline;
272 u8 d;
273 int j;
274
275 cdat = p->fontdata+(c&p->charmask)*fontheight(p);
276 bold = attr_bold(p,c);
277 ch_reverse = attr_reverse(p,c);
278 ch_underline = attr_underline(p,c);
279
280 for (rows = 0; rows < fontheight(p); rows++) {
281 d = *cdat++;
282 if (!conp->vc_can_do_color) {
283 if (ch_underline && rows == (fontheight(p)-2))
284 d = 0xff;
285 else if (bold)
286 d |= d>>1;
287 if (ch_reverse)
288 d = ~d;
289 }
290 for (j = 0; j < fontwidth(p); j++) {
291 plot_pixel_mac(p, (d & 0x80) >> 7, (xx*fontwidth(p)) + j, (yy*fontheight(p)) + rows);
292 d <<= 1;
293 }
294 }
295 }
296
297
298 void fbcon_mac_putcs(struct vc_data *conp, struct display *p,
299 const unsigned short *s, int count, int yy, int xx)
300 {
301 u16 c;
302
303 while (count--) {
304 c = scr_readw(s++);
305 fbcon_mac_putc(conp, p, c, yy, xx++);
306 }
307 }
308
309
310 void fbcon_mac_revc(struct display *p, int xx, int yy)
311 {
312 u_int rows, j;
313
314 for (rows = 0; rows < fontheight(p); rows++) {
315 for (j = 0; j < fontwidth(p); j++) {
316 plot_pixel_mac (p, PIXEL_INVERT_MAC, (xx*fontwidth(p))+j, (yy*fontheight(p))+rows);
317 }
318 }
319 }
320
321 static inline void plot_helper(u8 *dest, u8 bit, int bw)
322 {
323 switch (bw) {
324 case PIXEL_BLACK_MAC:
325 fb_writeb( fb_readb(dest) | bit, dest );
326 break;
327 case PIXEL_WHITE_MAC:
328 fb_writeb( fb_readb(dest) & (~bit), dest );
329 break;
330 case PIXEL_INVERT_MAC:
331 fb_writeb( fb_readb(dest) ^ bit, dest );
332 break;
333 default:
334 printk( "ERROR: Unknown pixel value in plot_pixel_mac\n");
335 }
336 }
337
338 /*
339 * plot_pixel_mac
340 */
341 static void plot_pixel_mac(struct display *p, int bw, int pixel_x, int pixel_y)
342 {
343 u8 *dest, bit;
344 u16 *dest16, pix16;
345 u32 *dest32, pix32;
346
347 /* There *are* 68k Macs that support more than 832x624, you know :-) */
348 if (pixel_x < 0 || pixel_y < 0 || pixel_x >= p->var.xres || pixel_y >= p->var.yres) {
349 printk ("ERROR: pixel_x == %d, pixel_y == %d", pixel_x, pixel_y);
350 mdelay(1000);
351 return;
352 }
353
354 switch (p->var.bits_per_pixel) {
355 case 1:
356 dest = (u8 *) ((pixel_x >> 3) + p->screen_base + pixel_y * p->next_line);
357 bit = 0x80 >> (pixel_x & 7);
358 plot_helper(dest, bit, bw);
359 break;
360
361 case 2:
362 dest = (u8 *) ((pixel_x >> 2) + p->screen_base + pixel_y * p->next_line);
363 bit = 0xC0 >> ((pixel_x & 3) << 1);
364 plot_helper(dest, bit, bw);
365 break;
366
367 case 4:
368 dest = (u8 *) ((pixel_x >> 1) + p->screen_base + pixel_y * p->next_line);
369 bit = 0xF0 >> ((pixel_x & 1) << 2);
370 plot_helper(dest, bit, bw);
371 break;
372
373 case 8:
374 dest = (u8 *) (pixel_x + p->screen_base + pixel_y * p->next_line);
375 bit = 0xFF;
376 plot_helper(dest, bit, bw);
377 break;
378
379 /* FIXME: You can't access framebuffer directly like this! */
380 case 16:
381 dest16 = (u16 *) ((pixel_x *2) + p->screen_base + pixel_y * p->next_line);
382 pix16 = 0xFFFF;
383 switch (bw) {
384 case PIXEL_BLACK_MAC: *dest16 = ~pix16; break;
385 case PIXEL_WHITE_MAC: *dest16 = pix16; break;
386 case PIXEL_INVERT_MAC: *dest16 ^= pix16; break;
387 default: printk( "ERROR: Unknown pixel value in plot_pixel_mac\n");
388 }
389 break;
390
391 case 32:
392 dest32 = (u32 *) ((pixel_x *4) + p->screen_base + pixel_y * p->next_line);
393 pix32 = 0xFFFFFFFF;
394 switch (bw) {
395 case PIXEL_BLACK_MAC: *dest32 = ~pix32; break;
396 case PIXEL_WHITE_MAC: *dest32 = pix32; break;
397 case PIXEL_INVERT_MAC: *dest32 ^= pix32; break;
398 default: printk( "ERROR: Unknown pixel value in plot_pixel_mac\n");
399 }
400 break;
401 }
402 }
403
404 static int get_pixel_mac(struct display *p, int pixel_x, int pixel_y)
405 {
406 u8 *dest, bit;
407 u16 *dest16;
408 u32 *dest32;
409 u8 pixel=0;
410
411 switch (p->var.bits_per_pixel) {
412 case 1:
413 dest = (u8 *) ((pixel_x / 8) + p->screen_base + pixel_y * p->next_line);
414 bit = 0x80 >> (pixel_x & 7);
415 pixel = *dest & bit;
416 break;
417 case 2:
418 dest = (u8 *) ((pixel_x / 4) + p->screen_base + pixel_y * p->next_line);
419 bit = 0xC0 >> (pixel_x & 3);
420 pixel = *dest & bit;
421 break;
422 case 4:
423 dest = (u8 *) ((pixel_x / 2) + p->screen_base + pixel_y * p->next_line);
424 bit = 0xF0 >> (pixel_x & 1);
425 pixel = *dest & bit;
426 break;
427 case 8:
428 dest = (u8 *) (pixel_x + p->screen_base + pixel_y * p->next_line);
429 pixel = *dest;
430 break;
431 case 16:
432 dest16 = (u16 *) ((pixel_x *2) + p->screen_base + pixel_y * p->next_line);
433 pixel = *dest16 ? 1 : 0;
434 break;
435 case 32:
436 dest32 = (u32 *) ((pixel_x *4) + p->screen_base + pixel_y * p->next_line);
437 pixel = *dest32 ? 1 : 0;
438 break;
439 }
440
441 return pixel ? PIXEL_BLACK_MAC : PIXEL_WHITE_MAC;
442 }
443
444
445 /*
446 * `switch' for the low level operations
447 */
448
449 struct display_switch fbcon_mac = {
450 setup: fbcon_mac_setup,
451 bmove: fbcon_redraw_bmove,
452 clear: fbcon_redraw_clear,
453 putc: fbcon_mac_putc,
454 putcs: fbcon_mac_putcs,
455 revc: fbcon_mac_revc,
456 fontwidthmask: FONTWIDTHRANGE(1,8)
457 };
458
459
460 #ifdef MODULE
461 MODULE_LICENSE("GPL");
462
463 int init_module(void)
464 {
465 return 0;
466 }
467
468 void cleanup_module(void)
469 {}
470 #endif /* MODULE */
471
472
473 /*
474 * Visible symbols for modules
475 */
476
477 EXPORT_SYMBOL(fbcon_mac);
478 EXPORT_SYMBOL(fbcon_mac_setup);
479 EXPORT_SYMBOL(fbcon_mac_bmove);
480 EXPORT_SYMBOL(fbcon_mac_clear);
481 EXPORT_SYMBOL(fbcon_mac_putc);
482 EXPORT_SYMBOL(fbcon_mac_putcs);
483 EXPORT_SYMBOL(fbcon_mac_revc);
484