1/*
2 * drivers/mb862xx/mb862xxfb_accel.c
3 *
4 * Fujitsu Carmine/Coral-P(A)/Lime framebuffer driver acceleration support
5 *
6 * (C) 2007 Alexander Shishkin <virtuoso@slind.org>
7 * (C) 2009 Valentin Sitdikov <v.sitdikov@gmail.com>
8 * (C) 2009 Siemens AG
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 */
15#include <linux/fb.h>
16#include <linux/delay.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/module.h>
20#include <linux/pci.h>
21#include <linux/slab.h>
22#if defined(CONFIG_OF)
23#include <linux/of_platform.h>
24#endif
25#include "mb862xxfb.h"
26#include "mb862xx_reg.h"
27#include "mb862xxfb_accel.h"
28
29static void mb862xxfb_write_fifo(u32 count, u32 *data, struct fb_info *info)
30{
31	struct mb862xxfb_par *par = info->par;
32	static u32 free;
33
34	u32 total = 0;
35	while (total < count) {
36		if (free) {
37			outreg(geo, GDC_GEO_REG_INPUT_FIFO, data[total]);
38			total++;
39			free--;
40		} else {
41			free = (u32) inreg(draw, GDC_REG_FIFO_COUNT);
42		}
43	}
44}
45
46static void mb86290fb_copyarea(struct fb_info *info,
47			       const struct fb_copyarea *area)
48{
49	__u32 cmd[6];
50
51	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
52	/* Set raster operation */
53	cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
54	cmd[2] = GDC_TYPE_BLTCOPYP << 24;
55
56	if (area->sx >= area->dx && area->sy >= area->dy)
57		cmd[2] |= GDC_CMD_BLTCOPY_TOP_LEFT << 16;
58	else if (area->sx >= area->dx && area->sy <= area->dy)
59		cmd[2] |= GDC_CMD_BLTCOPY_BOTTOM_LEFT << 16;
60	else if (area->sx <= area->dx && area->sy >= area->dy)
61		cmd[2] |= GDC_CMD_BLTCOPY_TOP_RIGHT << 16;
62	else
63		cmd[2] |= GDC_CMD_BLTCOPY_BOTTOM_RIGHT << 16;
64
65	cmd[3] = (area->sy << 16) | area->sx;
66	cmd[4] = (area->dy << 16) | area->dx;
67	cmd[5] = (area->height << 16) | area->width;
68	mb862xxfb_write_fifo(6, cmd, info);
69}
70
71/*
72 * Fill in the cmd array /GDC FIFO commands/ to draw a 1bit image.
73 * Make sure cmd has enough room!
74 */
75static void mb86290fb_imageblit1(u32 *cmd, u16 step, u16 dx, u16 dy,
76				 u16 width, u16 height, u32 fgcolor,
77				 u32 bgcolor, const struct fb_image *image,
78				 struct fb_info *info)
79{
80	int i;
81	unsigned const char *line;
82	u16 bytes;
83
84	/* set colors and raster operation regs */
85	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
86	/* Set raster operation */
87	cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
88	cmd[2] =
89	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_FORE_COLOR << 16);
90	cmd[3] = fgcolor;
91	cmd[4] =
92	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_BACK_COLOR << 16);
93	cmd[5] = bgcolor;
94
95	i = 0;
96	line = image->data;
97	bytes = (image->width + 7) >> 3;
98
99	/* and the image */
100	cmd[6] = (GDC_TYPE_DRAWBITMAPP << 24) |
101	    (GDC_CMD_BITMAP << 16) | (2 + (step * height));
102	cmd[7] = (dy << 16) | dx;
103	cmd[8] = (height << 16) | width;
104
105	while (i < height) {
106		memcpy(&cmd[9 + i * step], line, step << 2);
107#ifdef __LITTLE_ENDIAN
108		{
109			int k = 0;
110			for (k = 0; k < step; k++)
111				cmd[9 + i * step + k] =
112				    cpu_to_be32(cmd[9 + i * step + k]);
113		}
114#endif
115		line += bytes;
116		i++;
117	}
118}
119
120/*
121 * Fill in the cmd array /GDC FIFO commands/ to draw a 8bit image.
122 * Make sure cmd has enough room!
123 */
124static void mb86290fb_imageblit8(u32 *cmd, u16 step, u16 dx, u16 dy,
125				 u16 width, u16 height, u32 fgcolor,
126				 u32 bgcolor, const struct fb_image *image,
127				 struct fb_info *info)
128{
129	int i, j;
130	unsigned const char *line, *ptr;
131	u16 bytes;
132
133	cmd[0] = (GDC_TYPE_DRAWBITMAPP << 24) |
134	    (GDC_CMD_BLT_DRAW << 16) | (2 + (height * step));
135	cmd[1] = (dy << 16) | dx;
136	cmd[2] = (height << 16) | width;
137
138	i = 0;
139	line = ptr = image->data;
140	bytes = image->width;
141
142	while (i < height) {
143		ptr = line;
144		for (j = 0; j < step; j++) {
145			cmd[3 + i * step + j] =
146			    (((u32 *) (info->pseudo_palette))[*ptr]) & 0xffff;
147			ptr++;
148			cmd[3 + i * step + j] |=
149			    ((((u32 *) (info->
150					pseudo_palette))[*ptr]) & 0xffff) << 16;
151			ptr++;
152		}
153
154		line += bytes;
155		i++;
156	}
157}
158
159/*
160 * Fill in the cmd array /GDC FIFO commands/ to draw a 16bit image.
161 * Make sure cmd has enough room!
162 */
163static void mb86290fb_imageblit16(u32 *cmd, u16 step, u16 dx, u16 dy,
164				  u16 width, u16 height, u32 fgcolor,
165				  u32 bgcolor, const struct fb_image *image,
166				  struct fb_info *info)
167{
168	int i;
169	unsigned const char *line;
170	u16 bytes;
171
172	i = 0;
173	line = image->data;
174	bytes = image->width << 1;
175
176	cmd[0] = (GDC_TYPE_DRAWBITMAPP << 24) |
177	    (GDC_CMD_BLT_DRAW << 16) | (2 + step * height);
178	cmd[1] = (dy << 16) | dx;
179	cmd[2] = (height << 16) | width;
180
181	while (i < height) {
182		memcpy(&cmd[3 + i * step], line, step);
183		line += bytes;
184		i++;
185	}
186}
187
188static void mb86290fb_imageblit(struct fb_info *info,
189				const struct fb_image *image)
190{
191	int mdr;
192	u32 *cmd = NULL;
193	void (*cmdfn) (u32 *, u16, u16, u16, u16, u16, u32, u32,
194		       const struct fb_image *, struct fb_info *) = NULL;
195	u32 cmdlen;
196	u32 fgcolor = 0, bgcolor = 0;
197	u16 step;
198
199	u16 width = image->width, height = image->height;
200	u16 dx = image->dx, dy = image->dy;
201	int x2, y2, vxres, vyres;
202
203	mdr = (GDC_ROP_COPY << 9);
204	x2 = image->dx + image->width;
205	y2 = image->dy + image->height;
206	vxres = info->var.xres_virtual;
207	vyres = info->var.yres_virtual;
208	x2 = min(x2, vxres);
209	y2 = min(y2, vyres);
210	width = x2 - dx;
211	height = y2 - dy;
212
213	switch (image->depth) {
214	case 1:
215		step = (width + 31) >> 5;
216		cmdlen = 9 + height * step;
217		cmdfn = mb86290fb_imageblit1;
218		if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
219		    info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
220			fgcolor =
221			    ((u32 *) (info->pseudo_palette))[image->fg_color];
222			bgcolor =
223			    ((u32 *) (info->pseudo_palette))[image->bg_color];
224		} else {
225			fgcolor = image->fg_color;
226			bgcolor = image->bg_color;
227		}
228
229		break;
230
231	case 8:
232		step = (width + 1) >> 1;
233		cmdlen = 3 + height * step;
234		cmdfn = mb86290fb_imageblit8;
235		break;
236
237	case 16:
238		step = (width + 1) >> 1;
239		cmdlen = 3 + height * step;
240		cmdfn = mb86290fb_imageblit16;
241		break;
242
243	default:
244		cfb_imageblit(info, image);
245		return;
246	}
247
248	cmd = kmalloc(cmdlen * 4, GFP_DMA);
249	if (!cmd)
250		return cfb_imageblit(info, image);
251	cmdfn(cmd, step, dx, dy, width, height, fgcolor, bgcolor, image, info);
252	mb862xxfb_write_fifo(cmdlen, cmd, info);
253	kfree(cmd);
254}
255
256static void mb86290fb_fillrect(struct fb_info *info,
257			       const struct fb_fillrect *rect)
258{
259
260	u32 x2, y2, vxres, vyres, height, width, fg;
261	u32 cmd[7];
262
263	vxres = info->var.xres_virtual;
264	vyres = info->var.yres_virtual;
265
266	if (!rect->width || !rect->height || rect->dx > vxres
267	    || rect->dy > vyres)
268		return;
269
270	/* We could use hardware clipping but on many cards you get around
271	 * hardware clipping by writing to framebuffer directly. */
272	x2 = rect->dx + rect->width;
273	y2 = rect->dy + rect->height;
274	x2 = min(x2, vxres);
275	y2 = min(y2, vyres);
276	width = x2 - rect->dx;
277	height = y2 - rect->dy;
278	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
279	    info->fix.visual == FB_VISUAL_DIRECTCOLOR)
280		fg = ((u32 *) (info->pseudo_palette))[rect->color];
281	else
282		fg = rect->color;
283
284	switch (rect->rop) {
285
286	case ROP_XOR:
287		/* Set raster operation */
288		cmd[1] = (2 << 7) | (GDC_ROP_XOR << 9);
289		break;
290
291	case ROP_COPY:
292		/* Set raster operation */
293		cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
294		break;
295
296	}
297
298	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
299	/* cmd[1] set earlier */
300	cmd[2] =
301	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_FORE_COLOR << 16);
302	cmd[3] = fg;
303	cmd[4] = (GDC_TYPE_DRAWRECTP << 24) | (GDC_CMD_BLT_FILL << 16);
304	cmd[5] = (rect->dy << 16) | (rect->dx);
305	cmd[6] = (height << 16) | width;
306
307	mb862xxfb_write_fifo(7, cmd, info);
308}
309
310void mb862xxfb_init_accel(struct fb_info *info, int xres)
311{
312	struct mb862xxfb_par *par = info->par;
313
314	if (info->var.bits_per_pixel == 32) {
315		info->fbops->fb_fillrect = cfb_fillrect;
316		info->fbops->fb_copyarea = cfb_copyarea;
317		info->fbops->fb_imageblit = cfb_imageblit;
318	} else {
319		outreg(disp, GC_L0EM, 3);
320		info->fbops->fb_fillrect = mb86290fb_fillrect;
321		info->fbops->fb_copyarea = mb86290fb_copyarea;
322		info->fbops->fb_imageblit = mb86290fb_imageblit;
323	}
324	outreg(draw, GDC_REG_DRAW_BASE, 0);
325	outreg(draw, GDC_REG_MODE_MISC, 0x8000);
326	outreg(draw, GDC_REG_X_RESOLUTION, xres);
327
328	info->flags |=
329	    FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT |
330	    FBINFO_HWACCEL_IMAGEBLIT;
331	info->fix.accel = 0xff;	/*FIXME: add right define */
332}
333EXPORT_SYMBOL(mb862xxfb_init_accel);
334
335MODULE_LICENSE("GPL v2");
336