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 */
38 static const u16 rgb555[16] = {
39 0x7fff, 0x7fe0, 0x03ff, 0x03e0, 0x7c1f, 0x7c00, 0x001f, 0x0000,
40 0xffff, 0xffe0, 0x83ff, 0x83e0, 0xfc1f, 0xfc00, 0x801f, 0x8000
41 };
42
43 static const u16 rgb565[16] = {
44 0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000,
45 0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000
46 };
47
vivid_fb_green_bits(struct vivid_dev * dev)48 unsigned int vivid_fb_green_bits(struct vivid_dev *dev)
49 {
50 return dev->fb_defined.green.length;
51 }
52
vivid_fb_clear(struct vivid_dev * dev)53 void 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
vivid_fb_ioctl(struct fb_info * info,unsigned cmd,unsigned long arg)73 static 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
vivid_fb_set_var(struct vivid_dev * dev,struct fb_var_screeninfo * var)101 static 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
vivid_fb_get_fix(struct vivid_dev * dev,struct fb_fix_screeninfo * fix)114 static 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
_vivid_fb_check_var(struct fb_var_screeninfo * var,struct vivid_dev * dev)134 static 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
vivid_fb_check_var(struct fb_var_screeninfo * var,struct fb_info * info)174 static 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
vivid_fb_pan_display(struct fb_var_screeninfo * var,struct fb_info * info)182 static int vivid_fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
183 {
184 return 0;
185 }
186
vivid_fb_set_par(struct fb_info * info)187 static 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
vivid_fb_setcolreg(unsigned regno,unsigned red,unsigned green,unsigned blue,unsigned transp,struct fb_info * info)199 static 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. */
vivid_fb_blank(int blank_mode,struct fb_info * info)235 static 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
252 static 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 */
vivid_fb_init_vidmode(struct vivid_dev * dev)268 static 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 */
vivid_fb_release_buffers(struct vivid_dev * dev)341 static 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
vivid_fb_init(struct vivid_dev * dev)357 int 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
vivid_fb_deinit(struct vivid_dev * dev)396 void 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 }
402