]>
git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/media/platform/vivid/vivid-osd.c
2 * vivid-osd.c - osd support for testing overlays.
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
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.
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
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>
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>
40 #include "vivid-core.h"
41 #include "vivid-osd.h"
43 #define MAX_OSD_WIDTH 720
44 #define MAX_OSD_HEIGHT 576
47 * Order: white, yellow, cyan, green, magenta, red, blue, black,
48 * and same again with the alpha bit set (if any)
50 static const u16 rgb555
[16] = {
51 0x7fff, 0x7fe0, 0x03ff, 0x03e0, 0x7c1f, 0x7c00, 0x001f, 0x0000,
52 0xffff, 0xffe0, 0x83ff, 0x83e0, 0xfc1f, 0xfc00, 0x801f, 0x8000
55 static const u16 rgb565
[16] = {
56 0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000,
57 0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000
60 void vivid_clear_fb(struct vivid_dev
*dev
)
62 void *p
= dev
->video_vbase
;
63 const u16
*rgb
= rgb555
;
66 if (dev
->fb_defined
.green
.length
== 6)
69 for (y
= 0; y
< dev
->display_height
; y
++) {
72 for (x
= 0; x
< dev
->display_width
; x
++)
73 d
[x
] = rgb
[(y
/ 16 + x
/ 16) % 16];
74 p
+= dev
->display_byte_stride
;
78 /* --------------------------------------------------------------------- */
80 static int vivid_fb_ioctl(struct fb_info
*info
, unsigned cmd
, unsigned long arg
)
82 struct vivid_dev
*dev
= (struct vivid_dev
*)info
->par
;
85 case FBIOGET_VBLANK
: {
86 struct fb_vblank vblank
;
88 vblank
.flags
= FB_VBLANK_HAVE_COUNT
| FB_VBLANK_HAVE_VCOUNT
|
93 if (copy_to_user((void __user
*)arg
, &vblank
, sizeof(vblank
)))
99 dprintk(dev
, 1, "Unknown ioctl %08x\n", cmd
);
105 /* Framebuffer device handling */
107 static int vivid_fb_set_var(struct vivid_dev
*dev
, struct fb_var_screeninfo
*var
)
109 dprintk(dev
, 1, "vivid_fb_set_var\n");
111 if (var
->bits_per_pixel
!= 16) {
112 dprintk(dev
, 1, "vivid_fb_set_var - Invalid bpp\n");
115 dev
->display_byte_stride
= var
->xres
* dev
->bytes_per_pixel
;
120 static int vivid_fb_get_fix(struct vivid_dev
*dev
, struct fb_fix_screeninfo
*fix
)
122 dprintk(dev
, 1, "vivid_fb_get_fix\n");
123 memset(fix
, 0, sizeof(struct fb_fix_screeninfo
));
124 strlcpy(fix
->id
, "vioverlay fb", sizeof(fix
->id
));
125 fix
->smem_start
= dev
->video_pbase
;
126 fix
->smem_len
= dev
->video_buffer_size
;
127 fix
->type
= FB_TYPE_PACKED_PIXELS
;
128 fix
->visual
= FB_VISUAL_TRUECOLOR
;
132 fix
->line_length
= dev
->display_byte_stride
;
133 fix
->accel
= FB_ACCEL_NONE
;
137 /* Check the requested display mode, returning -EINVAL if we can't
140 static int _vivid_fb_check_var(struct fb_var_screeninfo
*var
, struct vivid_dev
*dev
)
142 dprintk(dev
, 1, "vivid_fb_check_var\n");
144 var
->bits_per_pixel
= 16;
145 if (var
->green
.length
== 5) {
146 var
->red
.offset
= 10;
148 var
->green
.offset
= 5;
149 var
->green
.length
= 5;
150 var
->blue
.offset
= 0;
151 var
->blue
.length
= 5;
152 var
->transp
.offset
= 15;
153 var
->transp
.length
= 1;
155 var
->red
.offset
= 11;
157 var
->green
.offset
= 5;
158 var
->green
.length
= 6;
159 var
->blue
.offset
= 0;
160 var
->blue
.length
= 5;
161 var
->transp
.offset
= 0;
162 var
->transp
.length
= 0;
164 var
->xoffset
= var
->yoffset
= 0;
165 var
->left_margin
= var
->upper_margin
= 0;
168 var
->vmode
&= ~FB_VMODE_MASK
;
169 var
->vmode
= FB_VMODE_NONINTERLACED
;
174 var
->pixclock
= 84316;
175 var
->right_margin
= 776;
176 var
->lower_margin
= 591;
180 static int vivid_fb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
182 struct vivid_dev
*dev
= (struct vivid_dev
*) info
->par
;
184 dprintk(dev
, 1, "vivid_fb_check_var\n");
185 return _vivid_fb_check_var(var
, dev
);
188 static int vivid_fb_pan_display(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
193 static int vivid_fb_set_par(struct fb_info
*info
)
196 struct vivid_dev
*dev
= (struct vivid_dev
*) info
->par
;
198 dprintk(dev
, 1, "vivid_fb_set_par\n");
200 rc
= vivid_fb_set_var(dev
, &info
->var
);
201 vivid_fb_get_fix(dev
, &info
->fix
);
205 static int vivid_fb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
206 unsigned blue
, unsigned transp
,
207 struct fb_info
*info
)
211 if (regno
>= info
->cmap
.len
)
214 color
= ((transp
& 0xFF00) << 16) | ((red
& 0xFF00) << 8) |
215 (green
& 0xFF00) | ((blue
& 0xFF00) >> 8);
219 palette
= info
->pseudo_palette
;
220 if (info
->var
.bits_per_pixel
== 16) {
221 switch (info
->var
.green
.length
) {
223 color
= (red
& 0xf800) |
224 ((green
& 0xfc00) >> 5) |
225 ((blue
& 0xf800) >> 11);
228 color
= ((red
& 0xf800) >> 1) |
229 ((green
& 0xf800) >> 6) |
230 ((blue
& 0xf800) >> 11) |
231 (transp
? 0x8000 : 0);
235 palette
[regno
] = color
;
239 /* We don't really support blanking. All this does is enable or
241 static int vivid_fb_blank(int blank_mode
, struct fb_info
*info
)
243 struct vivid_dev
*dev
= (struct vivid_dev
*)info
->par
;
245 dprintk(dev
, 1, "Set blanking mode : %d\n", blank_mode
);
246 switch (blank_mode
) {
247 case FB_BLANK_UNBLANK
:
249 case FB_BLANK_NORMAL
:
250 case FB_BLANK_HSYNC_SUSPEND
:
251 case FB_BLANK_VSYNC_SUSPEND
:
252 case FB_BLANK_POWERDOWN
:
258 static struct fb_ops vivid_fb_ops
= {
259 .owner
= THIS_MODULE
,
260 .fb_check_var
= vivid_fb_check_var
,
261 .fb_set_par
= vivid_fb_set_par
,
262 .fb_setcolreg
= vivid_fb_setcolreg
,
263 .fb_fillrect
= cfb_fillrect
,
264 .fb_copyarea
= cfb_copyarea
,
265 .fb_imageblit
= cfb_imageblit
,
267 .fb_ioctl
= vivid_fb_ioctl
,
268 .fb_pan_display
= vivid_fb_pan_display
,
269 .fb_blank
= vivid_fb_blank
,
275 /* Setup our initial video mode */
276 static int vivid_fb_init_vidmode(struct vivid_dev
*dev
)
278 struct v4l2_rect start_window
;
282 dev
->bits_per_pixel
= 16;
283 dev
->bytes_per_pixel
= dev
->bits_per_pixel
/ 8;
285 start_window
.width
= MAX_OSD_WIDTH
;
286 start_window
.left
= 0;
288 dev
->display_byte_stride
= start_window
.width
* dev
->bytes_per_pixel
;
290 /* Vertical size & position */
292 start_window
.height
= MAX_OSD_HEIGHT
;
293 start_window
.top
= 0;
295 dev
->display_width
= start_window
.width
;
296 dev
->display_height
= start_window
.height
;
298 /* Generate a valid fb_var_screeninfo */
300 dev
->fb_defined
.xres
= dev
->display_width
;
301 dev
->fb_defined
.yres
= dev
->display_height
;
302 dev
->fb_defined
.xres_virtual
= dev
->display_width
;
303 dev
->fb_defined
.yres_virtual
= dev
->display_height
;
304 dev
->fb_defined
.bits_per_pixel
= dev
->bits_per_pixel
;
305 dev
->fb_defined
.vmode
= FB_VMODE_NONINTERLACED
;
306 dev
->fb_defined
.left_margin
= start_window
.left
+ 1;
307 dev
->fb_defined
.upper_margin
= start_window
.top
+ 1;
308 dev
->fb_defined
.accel_flags
= FB_ACCEL_NONE
;
309 dev
->fb_defined
.nonstd
= 0;
310 /* set default to 1:5:5:5 */
311 dev
->fb_defined
.green
.length
= 5;
313 /* We've filled in the most data, let the usual mode check
314 routine fill in the rest. */
315 _vivid_fb_check_var(&dev
->fb_defined
, dev
);
317 /* Generate valid fb_fix_screeninfo */
319 vivid_fb_get_fix(dev
, &dev
->fb_fix
);
321 /* Generate valid fb_info */
323 dev
->fb_info
.node
= -1;
324 dev
->fb_info
.flags
= FBINFO_FLAG_DEFAULT
;
325 dev
->fb_info
.fbops
= &vivid_fb_ops
;
326 dev
->fb_info
.par
= dev
;
327 dev
->fb_info
.var
= dev
->fb_defined
;
328 dev
->fb_info
.fix
= dev
->fb_fix
;
329 dev
->fb_info
.screen_base
= (u8 __iomem
*)dev
->video_vbase
;
330 dev
->fb_info
.fbops
= &vivid_fb_ops
;
332 /* Supply some monitor specs. Bogus values will do for now */
333 dev
->fb_info
.monspecs
.hfmin
= 8000;
334 dev
->fb_info
.monspecs
.hfmax
= 70000;
335 dev
->fb_info
.monspecs
.vfmin
= 10;
336 dev
->fb_info
.monspecs
.vfmax
= 100;
338 /* Allocate color map */
339 if (fb_alloc_cmap(&dev
->fb_info
.cmap
, 256, 1)) {
340 pr_err("abort, unable to alloc cmap\n");
344 /* Allocate the pseudo palette */
345 dev
->fb_info
.pseudo_palette
= kmalloc_array(16, sizeof(u32
), GFP_KERNEL
);
347 return dev
->fb_info
.pseudo_palette
? 0 : -ENOMEM
;
350 /* Release any memory we've grabbed */
351 void vivid_fb_release_buffers(struct vivid_dev
*dev
)
353 if (dev
->video_vbase
== NULL
)
357 if (dev
->fb_info
.cmap
.len
)
358 fb_dealloc_cmap(&dev
->fb_info
.cmap
);
360 /* Release pseudo palette */
361 kfree(dev
->fb_info
.pseudo_palette
);
362 kfree((void *)dev
->video_vbase
);
365 /* Initialize the specified card */
367 int vivid_fb_init(struct vivid_dev
*dev
)
371 dev
->video_buffer_size
= MAX_OSD_HEIGHT
* MAX_OSD_WIDTH
* 2;
372 dev
->video_vbase
= kzalloc(dev
->video_buffer_size
, GFP_KERNEL
| GFP_DMA32
);
373 if (dev
->video_vbase
== NULL
)
375 dev
->video_pbase
= virt_to_phys(dev
->video_vbase
);
377 pr_info("Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
378 dev
->video_pbase
, dev
->video_vbase
,
379 dev
->video_buffer_size
/ 1024);
381 /* Set the startup video mode information */
382 ret
= vivid_fb_init_vidmode(dev
);
384 vivid_fb_release_buffers(dev
);
390 /* Register the framebuffer */
391 if (register_framebuffer(&dev
->fb_info
) < 0) {
392 vivid_fb_release_buffers(dev
);
396 /* Set the card to the requested mode */
397 vivid_fb_set_par(&dev
->fb_info
);