vivid-osd.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * vivid-osd.c - osd support for testing overlays.
  4 *
  5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  6 */
  7
  8#include <linux/module.h>
  9#include <linux/errno.h>
 10#include <linux/kernel.h>
 11#include <linux/init.h>
 12#include <linux/sched.h>
 13#include <linux/slab.h>
 14#include <linux/font.h>
 15#include <linux/mutex.h>
 16#include <linux/videodev2.h>
 17#include <linux/kthread.h>
 18#include <linux/freezer.h>
 19#include <linux/fb.h>
 20#include <media/videobuf2-vmalloc.h>
 21#include <media/v4l2-device.h>
 22#include <media/v4l2-ioctl.h>
 23#include <media/v4l2-ctrls.h>
 24#include <media/v4l2-fh.h>
 25#include <media/v4l2-event.h>
 26#include <media/v4l2-common.h>
 27
 28#include "vivid-core.h"
 29#include "vivid-osd.h"
 30
 31#define MAX_OSD_WIDTH  720
 32#define MAX_OSD_HEIGHT 576
 33
 34/*
 35 * Order: white, yellow, cyan, green, magenta, red, blue, black,
 36 * and same again with the alpha bit set (if any)
 37 */
 38static const u16 rgb555[16] = {
 39	0x7fff, 0x7fe0, 0x03ff, 0x03e0, 0x7c1f, 0x7c00, 0x001f, 0x0000,
 40	0xffff, 0xffe0, 0x83ff, 0x83e0, 0xfc1f, 0xfc00, 0x801f, 0x8000
 41};
 42
 43static const u16 rgb565[16] = {
 44	0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000,
 45	0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000
 46};
 47
 48unsigned int vivid_fb_green_bits(struct vivid_dev *dev)
 49{
 50	return dev->fb_defined.green.length;
 51}
 52
 53void vivid_fb_clear(struct vivid_dev *dev)
 54{
 55	void *p = dev->video_vbase;
 56	const u16 *rgb = rgb555;
 57	unsigned x, y;
 58
 59	if (vivid_fb_green_bits(dev) == 6)
 60		rgb = rgb565;
 61
 62	for (y = 0; y < dev->display_height; y++) {
 63		u16 *d = p;
 64
 65		for (x = 0; x < dev->display_width; x++)
 66			d[x] = rgb[(y / 16 + x / 16) % 16];
 67		p += dev->display_byte_stride;
 68	}
 69}
 70
 71/* --------------------------------------------------------------------- */
 72
 73static int vivid_fb_ioctl(struct fb_info *info, unsigned cmd, unsigned long arg)
 74{
 75	struct vivid_dev *dev = (struct vivid_dev *)info->par;
 76
 77	switch (cmd) {
 78	case FBIOGET_VBLANK: {
 79		struct fb_vblank vblank;
 80
 81		memset(&vblank, 0, sizeof(vblank));
 82		vblank.flags = FB_VBLANK_HAVE_COUNT | FB_VBLANK_HAVE_VCOUNT |
 83			FB_VBLANK_HAVE_VSYNC;
 84		vblank.count = 0;
 85		vblank.vcount = 0;
 86		vblank.hcount = 0;
 87		if (copy_to_user((void __user *)arg, &vblank, sizeof(vblank)))
 88			return -EFAULT;
 89		return 0;
 90	}
 91
 92	default:
 93		dprintk(dev, 1, "Unknown ioctl %08x\n", cmd);
 94		return -EINVAL;
 95	}
 96	return 0;
 97}
 98
 99/* Framebuffer device handling */
100
101static int vivid_fb_set_var(struct vivid_dev *dev, struct fb_var_screeninfo *var)
102{
103	dprintk(dev, 1, "vivid_fb_set_var\n");
104
105	if (var->bits_per_pixel != 16) {
106		dprintk(dev, 1, "vivid_fb_set_var - Invalid bpp\n");
107		return -EINVAL;
108	}
109	dev->display_byte_stride = var->xres * dev->bytes_per_pixel;
110
111	return 0;
112}
113
114static int vivid_fb_get_fix(struct vivid_dev *dev, struct fb_fix_screeninfo *fix)
115{
116	dprintk(dev, 1, "vivid_fb_get_fix\n");
117	memset(fix, 0, sizeof(struct fb_fix_screeninfo));
118	strscpy(fix->id, "vioverlay fb", sizeof(fix->id));
119	fix->smem_start = dev->video_pbase;
120	fix->smem_len = dev->video_buffer_size;
121	fix->type = FB_TYPE_PACKED_PIXELS;
122	fix->visual = FB_VISUAL_TRUECOLOR;
123	fix->xpanstep = 1;
124	fix->ypanstep = 1;
125	fix->ywrapstep = 0;
126	fix->line_length = dev->display_byte_stride;
127	fix->accel = FB_ACCEL_NONE;
128	return 0;
129}
130
131/* Check the requested display mode, returning -EINVAL if we can't
132   handle it. */
133
134static int _vivid_fb_check_var(struct fb_var_screeninfo *var, struct vivid_dev *dev)
135{
136	dprintk(dev, 1, "vivid_fb_check_var\n");
137
138	var->bits_per_pixel = 16;
139	if (var->green.length == 5) {
140		var->red.offset = 10;
141		var->red.length = 5;
142		var->green.offset = 5;
143		var->green.length = 5;
144		var->blue.offset = 0;
145		var->blue.length = 5;
146		var->transp.offset = 15;
147		var->transp.length = 1;
148	} else {
149		var->red.offset = 11;
150		var->red.length = 5;
151		var->green.offset = 5;
152		var->green.length = 6;
153		var->blue.offset = 0;
154		var->blue.length = 5;
155		var->transp.offset = 0;
156		var->transp.length = 0;
157	}
158	var->xoffset = var->yoffset = 0;
159	var->left_margin = var->upper_margin = 0;
160	var->nonstd = 0;
161
162	var->vmode &= ~FB_VMODE_MASK;
163	var->vmode |= FB_VMODE_NONINTERLACED;
164
165	/* Dummy values */
166	var->hsync_len = 24;
167	var->vsync_len = 2;
168	var->pixclock = 84316;
169	var->right_margin = 776;
170	var->lower_margin = 591;
171	return 0;
172}
173
174static int vivid_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
175{
176	struct vivid_dev *dev = (struct vivid_dev *) info->par;
177
178	dprintk(dev, 1, "vivid_fb_check_var\n");
179	return _vivid_fb_check_var(var, dev);
180}
181
182static int vivid_fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
183{
184	return 0;
185}
186
187static int vivid_fb_set_par(struct fb_info *info)
188{
189	int rc = 0;
190	struct vivid_dev *dev = (struct vivid_dev *) info->par;
191
192	dprintk(dev, 1, "vivid_fb_set_par\n");
193
194	rc = vivid_fb_set_var(dev, &info->var);
195	vivid_fb_get_fix(dev, &info->fix);
196	return rc;
197}
198
199static int vivid_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
200				unsigned blue, unsigned transp,
201				struct fb_info *info)
202{
203	u32 color, *palette;
204
205	if (regno >= info->cmap.len)
206		return -EINVAL;
207
208	color = ((transp & 0xFF00) << 16) | ((red & 0xFF00) << 8) |
209		 (green & 0xFF00) | ((blue & 0xFF00) >> 8);
210	if (regno >= 16)
211		return -EINVAL;
212
213	palette = info->pseudo_palette;
214	if (info->var.bits_per_pixel == 16) {
215		switch (info->var.green.length) {
216		case 6:
217			color = (red & 0xf800) |
218				((green & 0xfc00) >> 5) |
219				((blue & 0xf800) >> 11);
220			break;
221		case 5:
222			color = ((red & 0xf800) >> 1) |
223				((green & 0xf800) >> 6) |
224				((blue & 0xf800) >> 11) |
225				(transp ? 0x8000 : 0);
226			break;
227		}
228	}
229	palette[regno] = color;
230	return 0;
231}
232
233/* We don't really support blanking. All this does is enable or
234   disable the OSD. */
235static int vivid_fb_blank(int blank_mode, struct fb_info *info)
236{
237	struct vivid_dev *dev = (struct vivid_dev *)info->par;
238
239	dprintk(dev, 1, "Set blanking mode : %d\n", blank_mode);
240	switch (blank_mode) {
241	case FB_BLANK_UNBLANK:
242		break;
243	case FB_BLANK_NORMAL:
244	case FB_BLANK_HSYNC_SUSPEND:
245	case FB_BLANK_VSYNC_SUSPEND:
246	case FB_BLANK_POWERDOWN:
247		break;
248	}
249	return 0;
250}
251
252static const struct fb_ops vivid_fb_ops = {
253	.owner = THIS_MODULE,
254	FB_DEFAULT_IOMEM_OPS,
255	.fb_check_var   = vivid_fb_check_var,
256	.fb_set_par     = vivid_fb_set_par,
257	.fb_setcolreg   = vivid_fb_setcolreg,
258	.fb_cursor      = NULL,
259	.fb_ioctl       = vivid_fb_ioctl,
260	.fb_pan_display = vivid_fb_pan_display,
261	.fb_blank       = vivid_fb_blank,
262};
263
264/* Initialization */
265
266
267/* Setup our initial video mode */
268static int vivid_fb_init_vidmode(struct vivid_dev *dev)
269{
270	struct v4l2_rect start_window;
271
272	/* Color mode */
273
274	dev->bits_per_pixel = 16;
275	dev->bytes_per_pixel = dev->bits_per_pixel / 8;
276
277	start_window.width = MAX_OSD_WIDTH;
278	start_window.left = 0;
279
280	dev->display_byte_stride = start_window.width * dev->bytes_per_pixel;
281
282	/* Vertical size & position */
283
284	start_window.height = MAX_OSD_HEIGHT;
285	start_window.top = 0;
286
287	dev->display_width = start_window.width;
288	dev->display_height = start_window.height;
289
290	/* Generate a valid fb_var_screeninfo */
291
292	dev->fb_defined.xres = dev->display_width;
293	dev->fb_defined.yres = dev->display_height;
294	dev->fb_defined.xres_virtual = dev->display_width;
295	dev->fb_defined.yres_virtual = dev->display_height;
296	dev->fb_defined.bits_per_pixel = dev->bits_per_pixel;
297	dev->fb_defined.vmode = FB_VMODE_NONINTERLACED;
298	dev->fb_defined.left_margin = start_window.left + 1;
299	dev->fb_defined.upper_margin = start_window.top + 1;
300	dev->fb_defined.accel_flags = FB_ACCEL_NONE;
301	dev->fb_defined.nonstd = 0;
302	/* set default to 1:5:5:5 */
303	dev->fb_defined.green.length = 5;
304
305	/* We've filled in the most data, let the usual mode check
306	   routine fill in the rest. */
307	_vivid_fb_check_var(&dev->fb_defined, dev);
308
309	/* Generate valid fb_fix_screeninfo */
310
311	vivid_fb_get_fix(dev, &dev->fb_fix);
312
313	/* Generate valid fb_info */
314
315	dev->fb_info.node = -1;
316	dev->fb_info.par = dev;
317	dev->fb_info.var = dev->fb_defined;
318	dev->fb_info.fix = dev->fb_fix;
319	dev->fb_info.screen_base = (u8 __iomem *)dev->video_vbase;
320	dev->fb_info.fbops = &vivid_fb_ops;
321
322	/* Supply some monitor specs. Bogus values will do for now */
323	dev->fb_info.monspecs.hfmin = 8000;
324	dev->fb_info.monspecs.hfmax = 70000;
325	dev->fb_info.monspecs.vfmin = 10;
326	dev->fb_info.monspecs.vfmax = 100;
327
328	/* Allocate color map */
329	if (fb_alloc_cmap(&dev->fb_info.cmap, 256, 1)) {
330		pr_err("abort, unable to alloc cmap\n");
331		return -ENOMEM;
332	}
333
334	/* Allocate the pseudo palette */
335	dev->fb_info.pseudo_palette = kmalloc_array(16, sizeof(u32), GFP_KERNEL);
336
337	return dev->fb_info.pseudo_palette ? 0 : -ENOMEM;
338}
339
340/* Release any memory we've grabbed */
341static void vivid_fb_release_buffers(struct vivid_dev *dev)
342{
343	if (dev->video_vbase == NULL)
344		return;
345
346	/* Release cmap */
347	if (dev->fb_info.cmap.len)
348		fb_dealloc_cmap(&dev->fb_info.cmap);
349
350	/* Release pseudo palette */
351	kfree(dev->fb_info.pseudo_palette);
352	kfree(dev->video_vbase);
353}
354
355/* Initialize the specified card */
356
357int vivid_fb_init(struct vivid_dev *dev)
358{
359	int ret;
360
361	dev->video_buffer_size = MAX_OSD_HEIGHT * MAX_OSD_WIDTH * 2;
362	dev->video_vbase = kzalloc(dev->video_buffer_size, GFP_KERNEL);
363	if (dev->video_vbase == NULL)
364		return -ENOMEM;
365	dev->video_pbase = virt_to_phys(dev->video_vbase);
366
367	pr_info("Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
368			dev->video_pbase, dev->video_vbase,
369			dev->video_buffer_size / 1024);
370
371	/* Set the startup video mode information */
372	ret = vivid_fb_init_vidmode(dev);
373	if (ret) {
374		vivid_fb_release_buffers(dev);
375		return ret;
376	}
377
378	vivid_fb_clear(dev);
379
380	/* Register the framebuffer */
381	if (register_framebuffer(&dev->fb_info) < 0) {
382		vivid_fb_release_buffers(dev);
383		return -EINVAL;
384	}
385
386	/* Set the card to the requested mode */
387	vivid_fb_set_par(&dev->fb_info);
388
389	v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
390		  dev->fb_info.node);
391
392	return 0;
393
394}
395
396void vivid_fb_deinit(struct vivid_dev *dev)
397{
398	v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n", dev->fb_info.node);
399	unregister_framebuffer(&dev->fb_info);
400	vivid_fb_release_buffers(dev);
401}