[net-next-2.6.git] / drivers / video / mb862xx / mb862xxfb_accel.c

/*
 * drivers/mb862xx/mb862xxfb_accel.c
 *
 * Fujitsu Carmine/Coral-P(A)/Lime framebuffer driver acceleration support
 *
 * (C) 2007 Alexander Shishkin <virtuoso@slind.org>
 * (C) 2009 Valentin Sitdikov <v.sitdikov@gmail.com>
 * (C) 2009 Siemens AG
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */
#include <linux/fb.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/slab.h>
#if defined(CONFIG_OF)
#include <linux/of_platform.h>
#endif
#include "mb862xxfb.h"
#include "mb862xx_reg.h"
#include "mb862xxfb_accel.h"

static void mb862xxfb_write_fifo(u32 count, u32 *data, struct fb_info *info)
{
	struct mb862xxfb_par *par = info->par;
	static u32 free;

	u32 total = 0;
	while (total < count) {
		if (free) {
			outreg(geo, GDC_GEO_REG_INPUT_FIFO, data[total]);
			total++;
			free--;
		} else {
			free = (u32) inreg(draw, GDC_REG_FIFO_COUNT);
		}
	}
}

static void mb86290fb_copyarea(struct fb_info *info,
			       const struct fb_copyarea *area)
{
	__u32 cmd[6];

	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
	/* Set raster operation */
	cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
	cmd[2] = GDC_TYPE_BLTCOPYP << 24;

	if (area->sx >= area->dx && area->sy >= area->dy)
		cmd[2] |= GDC_CMD_BLTCOPY_TOP_LEFT << 16;
	else if (area->sx >= area->dx && area->sy <= area->dy)
		cmd[2] |= GDC_CMD_BLTCOPY_BOTTOM_LEFT << 16;
	else if (area->sx <= area->dx && area->sy >= area->dy)
		cmd[2] |= GDC_CMD_BLTCOPY_TOP_RIGHT << 16;
	else
		cmd[2] |= GDC_CMD_BLTCOPY_BOTTOM_RIGHT << 16;

	cmd[3] = (area->sy << 16) | area->sx;
	cmd[4] = (area->dy << 16) | area->dx;
	cmd[5] = (area->height << 16) | area->width;
	mb862xxfb_write_fifo(6, cmd, info);
}

/*
 * Fill in the cmd array /GDC FIFO commands/ to draw a 1bit image.
 * Make sure cmd has enough room!
 */
static void mb86290fb_imageblit1(u32 *cmd, u16 step, u16 dx, u16 dy,
				 u16 width, u16 height, u32 fgcolor,
				 u32 bgcolor, const struct fb_image *image,
				 struct fb_info *info)
{
	int i;
	unsigned const char *line;
	u16 bytes;

	/* set colors and raster operation regs */
	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
	/* Set raster operation */
	cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
	cmd[2] =
	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_FORE_COLOR << 16);
	cmd[3] = fgcolor;
	cmd[4] =
	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_BACK_COLOR << 16);
	cmd[5] = bgcolor;

	i = 0;
	line = image->data;
	bytes = (image->width + 7) >> 3;

	/* and the image */
	cmd[6] = (GDC_TYPE_DRAWBITMAPP << 24) |
	    (GDC_CMD_BITMAP << 16) | (2 + (step * height));
	cmd[7] = (dy << 16) | dx;
	cmd[8] = (height << 16) | width;

	while (i < height) {
		memcpy(&cmd[9 + i * step], line, step << 2);
#ifdef __LITTLE_ENDIAN
		{
			int k = 0;
			for (k = 0; k < step; k++)
				cmd[9 + i * step + k] =
				    cpu_to_be32(cmd[9 + i * step + k]);
		}
#endif
		line += bytes;
		i++;
	}
}

/*
 * Fill in the cmd array /GDC FIFO commands/ to draw a 8bit image.
 * Make sure cmd has enough room!
 */
static void mb86290fb_imageblit8(u32 *cmd, u16 step, u16 dx, u16 dy,
				 u16 width, u16 height, u32 fgcolor,
				 u32 bgcolor, const struct fb_image *image,
				 struct fb_info *info)
{
	int i, j;
	unsigned const char *line, *ptr;
	u16 bytes;

	cmd[0] = (GDC_TYPE_DRAWBITMAPP << 24) |
	    (GDC_CMD_BLT_DRAW << 16) | (2 + (height * step));
	cmd[1] = (dy << 16) | dx;
	cmd[2] = (height << 16) | width;

	i = 0;
	line = ptr = image->data;
	bytes = image->width;

	while (i < height) {
		ptr = line;
		for (j = 0; j < step; j++) {
			cmd[3 + i * step + j] =
			    (((u32 *) (info->pseudo_palette))[*ptr]) & 0xffff;
			ptr++;
			cmd[3 + i * step + j] |=
			    ((((u32 *) (info->
					pseudo_palette))[*ptr]) & 0xffff) << 16;
			ptr++;
		}

		line += bytes;
		i++;
	}
}

/*
 * Fill in the cmd array /GDC FIFO commands/ to draw a 16bit image.
 * Make sure cmd has enough room!
 */
static void mb86290fb_imageblit16(u32 *cmd, u16 step, u16 dx, u16 dy,
				  u16 width, u16 height, u32 fgcolor,
				  u32 bgcolor, const struct fb_image *image,
				  struct fb_info *info)
{
	int i;
	unsigned const char *line;
	u16 bytes;

	i = 0;
	line = image->data;
	bytes = image->width << 1;

	cmd[0] = (GDC_TYPE_DRAWBITMAPP << 24) |
	    (GDC_CMD_BLT_DRAW << 16) | (2 + step * height);
	cmd[1] = (dy << 16) | dx;
	cmd[2] = (height << 16) | width;

	while (i < height) {
		memcpy(&cmd[3 + i * step], line, step);
		line += bytes;
		i++;
	}
}

static void mb86290fb_imageblit(struct fb_info *info,
				const struct fb_image *image)
{
	int mdr;
	u32 *cmd = NULL;
	void (*cmdfn) (u32 *, u16, u16, u16, u16, u16, u32, u32,
		       const struct fb_image *, struct fb_info *) = NULL;
	u32 cmdlen;
	u32 fgcolor = 0, bgcolor = 0;
	u16 step;

	u16 width = image->width, height = image->height;
	u16 dx = image->dx, dy = image->dy;
	int x2, y2, vxres, vyres;

	mdr = (GDC_ROP_COPY << 9);
	x2 = image->dx + image->width;
	y2 = image->dy + image->height;
	vxres = info->var.xres_virtual;
	vyres = info->var.yres_virtual;
	x2 = min(x2, vxres);
	y2 = min(y2, vyres);
	width = x2 - dx;
	height = y2 - dy;

	switch (image->depth) {
	case 1:
		step = (width + 31) >> 5;
		cmdlen = 9 + height * step;
		cmdfn = mb86290fb_imageblit1;
		if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
		    info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
			fgcolor =
			    ((u32 *) (info->pseudo_palette))[image->fg_color];
			bgcolor =
			    ((u32 *) (info->pseudo_palette))[image->bg_color];
		} else {
			fgcolor = image->fg_color;
			bgcolor = image->bg_color;
		}

		break;

	case 8:
		step = (width + 1) >> 1;
		cmdlen = 3 + height * step;
		cmdfn = mb86290fb_imageblit8;
		break;

	case 16:
		step = (width + 1) >> 1;
		cmdlen = 3 + height * step;
		cmdfn = mb86290fb_imageblit16;
		break;

	default:
		cfb_imageblit(info, image);
		return;
	}

	cmd = kmalloc(cmdlen * 4, GFP_DMA);
	if (!cmd)
		return cfb_imageblit(info, image);
	cmdfn(cmd, step, dx, dy, width, height, fgcolor, bgcolor, image, info);
	mb862xxfb_write_fifo(cmdlen, cmd, info);
	kfree(cmd);
}

static void mb86290fb_fillrect(struct fb_info *info,
			       const struct fb_fillrect *rect)
{

	u32 x2, y2, vxres, vyres, height, width, fg;
	u32 cmd[7];

	vxres = info->var.xres_virtual;
	vyres = info->var.yres_virtual;

	if (!rect->width || !rect->height || rect->dx > vxres
	    || rect->dy > vyres)
		return;

	/* We could use hardware clipping but on many cards you get around
	 * hardware clipping by writing to framebuffer directly. */
	x2 = rect->dx + rect->width;
	y2 = rect->dy + rect->height;
	x2 = min(x2, vxres);
	y2 = min(y2, vyres);
	width = x2 - rect->dx;
	height = y2 - rect->dy;
	if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
	    info->fix.visual == FB_VISUAL_DIRECTCOLOR)
		fg = ((u32 *) (info->pseudo_palette))[rect->color];
	else
		fg = rect->color;

	switch (rect->rop) {

	case ROP_XOR:
		/* Set raster operation */
		cmd[1] = (2 << 7) | (GDC_ROP_XOR << 9);
		break;

	case ROP_COPY:
		/* Set raster operation */
		cmd[1] = (2 << 7) | (GDC_ROP_COPY << 9);
		break;

	}

	cmd[0] = (GDC_TYPE_SETREGISTER << 24) | (1 << 16) | GDC_REG_MODE_BITMAP;
	/* cmd[1] set earlier */
	cmd[2] =
	    (GDC_TYPE_SETCOLORREGISTER << 24) | (GDC_CMD_BODY_FORE_COLOR << 16);
	cmd[3] = fg;
	cmd[4] = (GDC_TYPE_DRAWRECTP << 24) | (GDC_CMD_BLT_FILL << 16);
	cmd[5] = (rect->dy << 16) | (rect->dx);
	cmd[6] = (height << 16) | width;

	mb862xxfb_write_fifo(7, cmd, info);
}

void mb862xxfb_init_accel(struct fb_info *info, int xres)
{
	struct mb862xxfb_par *par = info->par;

	if (info->var.bits_per_pixel == 32) {
		info->fbops->fb_fillrect = cfb_fillrect;
		info->fbops->fb_copyarea = cfb_copyarea;
		info->fbops->fb_imageblit = cfb_imageblit;
	} else {
		outreg(disp, GC_L0EM, 3);
		info->fbops->fb_fillrect = mb86290fb_fillrect;
		info->fbops->fb_copyarea = mb86290fb_copyarea;
		info->fbops->fb_imageblit = mb86290fb_imageblit;
	}
	outreg(draw, GDC_REG_DRAW_BASE, 0);
	outreg(draw, GDC_REG_MODE_MISC, 0x8000);
	outreg(draw, GDC_REG_X_RESOLUTION, xres);

	info->flags |=
	    FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT |
	    FBINFO_HWACCEL_IMAGEBLIT;
	info->fix.accel = 0xff;	/*FIXME: add right define */
}
EXPORT_SYMBOL(mb862xxfb_init_accel);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
2ec509b9 VS	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>
da258016	7	* (C) 2009 Valentin Sitdikov <v.sitdikov@gmail.com>
2ec509b9 VS	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>
a71dc148	19	#include <linux/module.h>
2ec509b9	20	#include <linux/pci.h>
5a0e3ad6	21	#include <linux/slab.h>
2ec509b9 VS	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
	29	static 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
	46	static 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	*/
	75	static 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	*/
124	static 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	*/
163	static 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
188	static 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
256	static 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
310	void 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	}
333	EXPORT_SYMBOL(mb862xxfb_init_accel);
a71dc148 RD	334
a71dc148 RD	335	MODULE_LICENSE("GPL v2");