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