vt_fb.c revision 282247 
1/*-
2 * Copyright (c) 2013 The FreeBSD Foundation
3 * All rights reserved.
4 *
5 * This software was developed by Aleksandr Rybalko under sponsorship from the
6 * FreeBSD Foundation.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: head/sys/dev/vt/hw/fb/vt_fb.c 282247 2015-04-29 20:30:11Z emaste $
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD: head/sys/dev/vt/hw/fb/vt_fb.c 282247 2015-04-29 20:30:11Z emaste $");
34
35#include <sys/param.h>
36#include <sys/systm.h>
37#include <sys/malloc.h>
38#include <sys/queue.h>
39#include <sys/fbio.h>
40#include <dev/vt/vt.h>
41#include <dev/vt/hw/fb/vt_fb.h>
42#include <dev/vt/colors/vt_termcolors.h>
43
44#include <vm/vm.h>
45#include <vm/pmap.h>
46
47static struct vt_driver vt_fb_driver = {
48	.vd_name = "fb",
49	.vd_init = vt_fb_init,
50	.vd_fini = vt_fb_fini,
51	.vd_blank = vt_fb_blank,
52	.vd_bitblt_text = vt_fb_bitblt_text,
53	.vd_bitblt_bmp = vt_fb_bitblt_bitmap,
54	.vd_drawrect = vt_fb_drawrect,
55	.vd_setpixel = vt_fb_setpixel,
56	.vd_postswitch = vt_fb_postswitch,
57	.vd_priority = VD_PRIORITY_GENERIC+10,
58	.vd_fb_ioctl = vt_fb_ioctl,
59	.vd_fb_mmap = vt_fb_mmap,
60	.vd_suspend = vt_fb_suspend,
61	.vd_resume = vt_fb_resume,
62};
63
64VT_DRIVER_DECLARE(vt_fb, vt_fb_driver);
65
66static void
67vt_fb_mem_wr1(struct fb_info *sc, uint32_t o, uint8_t v)
68{
69
70	KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o));
71	*(uint8_t *)(sc->fb_vbase + o) = v;
72}
73
74static void
75vt_fb_mem_wr2(struct fb_info *sc, uint32_t o, uint16_t v)
76{
77
78	KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o));
79	*(uint16_t *)(sc->fb_vbase + o) = v;
80}
81
82static void
83vt_fb_mem_wr4(struct fb_info *sc, uint32_t o, uint32_t v)
84{
85
86	KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o));
87	*(uint32_t *)(sc->fb_vbase + o) = v;
88}
89
90int
91vt_fb_ioctl(struct vt_device *vd, u_long cmd, caddr_t data, struct thread *td)
92{
93	struct fb_info *info;
94	int error = 0;
95
96	info = vd->vd_softc;
97
98	switch (cmd) {
99	case FBIOGTYPE:
100		bcopy(info, (struct fbtype *)data, sizeof(struct fbtype));
101		break;
102
103	case FBIO_GETWINORG:	/* get frame buffer window origin */
104		*(u_int *)data = 0;
105		break;
106
107	case FBIO_GETDISPSTART:	/* get display start address */
108		((video_display_start_t *)data)->x = 0;
109		((video_display_start_t *)data)->y = 0;
110		break;
111
112	case FBIO_GETLINEWIDTH:	/* get scan line width in bytes */
113		*(u_int *)data = info->fb_stride;
114		break;
115
116	case FBIO_BLANK:	/* blank display */
117		if (vd->vd_driver->vd_blank == NULL)
118			return (ENODEV);
119		vd->vd_driver->vd_blank(vd, TC_BLACK);
120		break;
121
122	default:
123		error = ENOIOCTL;
124		break;
125	}
126
127	return (error);
128}
129
130int
131vt_fb_mmap(struct vt_device *vd, vm_ooffset_t offset, vm_paddr_t *paddr,
132    int prot, vm_memattr_t *memattr)
133{
134	struct fb_info *info;
135
136	info = vd->vd_softc;
137
138	if (info->fb_flags & FB_FLAG_NOMMAP)
139		return (ENODEV);
140
141	if (offset >= 0 && offset < info->fb_size) {
142		if (info->fb_pbase == 0) {
143			*paddr = vtophys((uint8_t *)info->fb_vbase + offset);
144		} else {
145			*paddr = info->fb_pbase + offset;
146#ifdef VM_MEMATTR_WRITE_COMBINING
147			*memattr = VM_MEMATTR_WRITE_COMBINING;
148#endif
149		}
150		return (0);
151	}
152
153	return (EINVAL);
154}
155
156void
157vt_fb_setpixel(struct vt_device *vd, int x, int y, term_color_t color)
158{
159	struct fb_info *info;
160	uint32_t c;
161	u_int o;
162
163	info = vd->vd_softc;
164	c = info->fb_cmap[color];
165	o = info->fb_stride * y + x * FBTYPE_GET_BYTESPP(info);
166
167	if (info->fb_flags & FB_FLAG_NOWRITE)
168		return;
169
170	KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer"));
171
172	switch (FBTYPE_GET_BYTESPP(info)) {
173	case 1:
174		vt_fb_mem_wr1(info, o, c);
175		break;
176	case 2:
177		vt_fb_mem_wr2(info, o, c);
178		break;
179	case 3:
180		vt_fb_mem_wr1(info, o, (c >> 16) & 0xff);
181		vt_fb_mem_wr1(info, o + 1, (c >> 8) & 0xff);
182		vt_fb_mem_wr1(info, o + 2, c & 0xff);
183		break;
184	case 4:
185		vt_fb_mem_wr4(info, o, c);
186		break;
187	default:
188		/* panic? */
189		return;
190	}
191
192}
193
194void
195vt_fb_drawrect(struct vt_device *vd, int x1, int y1, int x2, int y2, int fill,
196    term_color_t color)
197{
198	int x, y;
199
200	for (y = y1; y <= y2; y++) {
201		if (fill || (y == y1) || (y == y2)) {
202			for (x = x1; x <= x2; x++)
203				vt_fb_setpixel(vd, x, y, color);
204		} else {
205			vt_fb_setpixel(vd, x1, y, color);
206			vt_fb_setpixel(vd, x2, y, color);
207		}
208	}
209}
210
211void
212vt_fb_blank(struct vt_device *vd, term_color_t color)
213{
214	struct fb_info *info;
215	uint32_t c;
216	u_int o, h;
217
218	info = vd->vd_softc;
219	c = info->fb_cmap[color];
220
221	if (info->fb_flags & FB_FLAG_NOWRITE)
222		return;
223
224	KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer"));
225
226	switch (FBTYPE_GET_BYTESPP(info)) {
227	case 1:
228		for (h = 0; h < info->fb_height; h++)
229			for (o = 0; o < info->fb_stride; o++)
230				vt_fb_mem_wr1(info, h*info->fb_stride + o, c);
231		break;
232	case 2:
233		for (h = 0; h < info->fb_height; h++)
234			for (o = 0; o < info->fb_stride; o += 2)
235				vt_fb_mem_wr2(info, h*info->fb_stride + o, c);
236		break;
237	case 3:
238		for (h = 0; h < info->fb_height; h++)
239			for (o = 0; o < info->fb_stride; o += 3) {
240				vt_fb_mem_wr1(info, h*info->fb_stride + o,
241				    (c >> 16) & 0xff);
242				vt_fb_mem_wr1(info, h*info->fb_stride + o + 1,
243				    (c >> 8) & 0xff);
244				vt_fb_mem_wr1(info, h*info->fb_stride + o + 2,
245				    c & 0xff);
246			}
247		break;
248	case 4:
249		for (h = 0; h < info->fb_height; h++)
250			for (o = 0; o < info->fb_stride; o += 4)
251				vt_fb_mem_wr4(info, h*info->fb_stride + o, c);
252		break;
253	default:
254		/* panic? */
255		return;
256	}
257}
258
259void
260vt_fb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
261    const uint8_t *pattern, const uint8_t *mask,
262    unsigned int width, unsigned int height,
263    unsigned int x, unsigned int y, term_color_t fg, term_color_t bg)
264{
265	struct fb_info *info;
266	uint32_t fgc, bgc, cc, o;
267	int bpp, bpl, xi, yi;
268	int bit, byte;
269
270	info = vd->vd_softc;
271	bpp = FBTYPE_GET_BYTESPP(info);
272	fgc = info->fb_cmap[fg];
273	bgc = info->fb_cmap[bg];
274	bpl = (width + 7) / 8; /* Bytes per source line. */
275
276	if (info->fb_flags & FB_FLAG_NOWRITE)
277		return;
278
279	KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer"));
280
281	/* Bound by right and bottom edges. */
282	if (y + height > vw->vw_draw_area.tr_end.tp_row) {
283		if (y >= vw->vw_draw_area.tr_end.tp_row)
284			return;
285		height = vw->vw_draw_area.tr_end.tp_row - y;
286	}
287	if (x + width > vw->vw_draw_area.tr_end.tp_col) {
288		if (x >= vw->vw_draw_area.tr_end.tp_col)
289			return;
290		width = vw->vw_draw_area.tr_end.tp_col - x;
291	}
292	for (yi = 0; yi < height; yi++) {
293		for (xi = 0; xi < width; xi++) {
294			byte = yi * bpl + xi / 8;
295			bit = 0x80 >> (xi % 8);
296			/* Skip pixel write, if mask bit not set. */
297			if (mask != NULL && (mask[byte] & bit) == 0)
298				continue;
299			o = (y + yi) * info->fb_stride + (x + xi) * bpp;
300			cc = pattern[byte] & bit ? fgc : bgc;
301
302			switch(bpp) {
303			case 1:
304				vt_fb_mem_wr1(info, o, cc);
305				break;
306			case 2:
307				vt_fb_mem_wr2(info, o, cc);
308				break;
309			case 3:
310				/* Packed mode, so unaligned. Byte access. */
311				vt_fb_mem_wr1(info, o, (cc >> 16) & 0xff);
312				vt_fb_mem_wr1(info, o + 1, (cc >> 8) & 0xff);
313				vt_fb_mem_wr1(info, o + 2, cc & 0xff);
314				break;
315			case 4:
316				vt_fb_mem_wr4(info, o, cc);
317				break;
318			default:
319				/* panic? */
320				break;
321			}
322		}
323	}
324}
325
326void
327vt_fb_bitblt_text(struct vt_device *vd, const struct vt_window *vw,
328    const term_rect_t *area)
329{
330	unsigned int col, row, x, y;
331	struct vt_font *vf;
332	term_char_t c;
333	term_color_t fg, bg;
334	const uint8_t *pattern;
335
336	vf = vw->vw_font;
337
338	for (row = area->tr_begin.tp_row; row < area->tr_end.tp_row; ++row) {
339		for (col = area->tr_begin.tp_col; col < area->tr_end.tp_col;
340		    ++col) {
341			x = col * vf->vf_width +
342			    vw->vw_draw_area.tr_begin.tp_col;
343			y = row * vf->vf_height +
344			    vw->vw_draw_area.tr_begin.tp_row;
345
346			c = VTBUF_GET_FIELD(&vw->vw_buf, row, col);
347			pattern = vtfont_lookup(vf, c);
348			vt_determine_colors(c,
349			    VTBUF_ISCURSOR(&vw->vw_buf, row, col), &fg, &bg);
350
351			vt_fb_bitblt_bitmap(vd, vw,
352			    pattern, NULL, vf->vf_width, vf->vf_height,
353			    x, y, fg, bg);
354		}
355	}
356
357#ifndef SC_NO_CUTPASTE
358	if (!vd->vd_mshown)
359		return;
360
361	term_rect_t drawn_area;
362
363	drawn_area.tr_begin.tp_col = area->tr_begin.tp_col * vf->vf_width;
364	drawn_area.tr_begin.tp_row = area->tr_begin.tp_row * vf->vf_height;
365	drawn_area.tr_end.tp_col = area->tr_end.tp_col * vf->vf_width;
366	drawn_area.tr_end.tp_row = area->tr_end.tp_row * vf->vf_height;
367
368	if (vt_is_cursor_in_area(vd, &drawn_area)) {
369		vt_fb_bitblt_bitmap(vd, vw,
370		    vd->vd_mcursor->map, vd->vd_mcursor->mask,
371		    vd->vd_mcursor->width, vd->vd_mcursor->height,
372		    vd->vd_mx_drawn + vw->vw_draw_area.tr_begin.tp_col,
373		    vd->vd_my_drawn + vw->vw_draw_area.tr_begin.tp_row,
374		    vd->vd_mcursor_fg, vd->vd_mcursor_bg);
375	}
376#endif
377}
378
379void
380vt_fb_postswitch(struct vt_device *vd)
381{
382	struct fb_info *info;
383
384	info = vd->vd_softc;
385
386	if (info->enter != NULL)
387		info->enter(info->fb_priv);
388}
389
390static int
391vt_fb_init_cmap(uint32_t *cmap, int depth)
392{
393
394	switch (depth) {
395	case 8:
396		return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB,
397		    0x7, 5, 0x7, 2, 0x3, 0));
398	case 15:
399		return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB,
400		    0x1f, 10, 0x1f, 5, 0x1f, 0));
401	case 16:
402		return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB,
403		    0x1f, 11, 0x3f, 5, 0x1f, 0));
404	case 24:
405	case 32: /* Ignore alpha. */
406		return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB,
407		    0xff, 16, 0xff, 8, 0xff, 0));
408	default:
409		return (1);
410	}
411}
412
413int
414vt_fb_init(struct vt_device *vd)
415{
416	struct fb_info *info;
417	int err;
418
419	info = vd->vd_softc;
420	vd->vd_height = info->fb_height;
421	vd->vd_width = info->fb_width;
422	vd->vd_video_dev = info->fb_video_dev;
423
424	if (info->fb_size == 0)
425		return (CN_DEAD);
426
427	if (info->fb_pbase == 0 && info->fb_vbase == 0)
428		info->fb_flags |= FB_FLAG_NOMMAP;
429
430	if (info->fb_cmsize <= 0) {
431		err = vt_fb_init_cmap(info->fb_cmap, FBTYPE_GET_BPP(info));
432		if (err)
433			return (CN_DEAD);
434		info->fb_cmsize = 16;
435	}
436
437	/* Clear the screen. */
438	vd->vd_driver->vd_blank(vd, TC_BLACK);
439
440	/* Wakeup screen. KMS need this. */
441	vt_fb_postswitch(vd);
442
443	return (CN_INTERNAL);
444}
445
446void
447vt_fb_fini(struct vt_device *vd, void *softc)
448{
449
450	vd->vd_video_dev = NULL;
451}
452
453int
454vt_fb_attach(struct fb_info *info)
455{
456
457	vt_allocate(&vt_fb_driver, info);
458
459	return (0);
460}
461
462int
463vt_fb_detach(struct fb_info *info)
464{
465
466	vt_deallocate(&vt_fb_driver, info);
467
468	return (0);
469}
470
471void
472vt_fb_suspend(struct vt_device *vd)
473{
474
475	vt_suspend(vd);
476}
477
478void
479vt_fb_resume(struct vt_device *vd)
480{
481
482	vt_resume(vd);
483}
484