mb862xxfb_accel.c

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