kernel/drivers/media/platform/vivid/vivid-osd.c

   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  */
  50 static const u16 rgb555[16] = {
  51         0x7fff, 0x7fe0, 0x03ff, 0x03e0, 0x7c1f, 0x7c00, 0x001f, 0x0000,
  52         0xffff, 0xffe0, 0x83ff, 0x83e0, 0xfc1f, 0xfc00, 0x801f, 0x8000
  53 };
  54
  55 static const u16 rgb565[16] = {
  56         0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000,
  57         0xffff, 0xffe0, 0x07ff, 0x07e0, 0xf81f, 0xf800, 0x001f, 0x0000
  58 };
  59
  60 void 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
  80 static 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                 vblank.flags = FB_VBLANK_HAVE_COUNT | FB_VBLANK_HAVE_VCOUNT |
  89                         FB_VBLANK_HAVE_VSYNC;
  90                 vblank.count = 0;
  91                 vblank.vcount = 0;
  92                 vblank.hcount = 0;
  93                 if (copy_to_user((void __user *)arg, &vblank, sizeof(vblank)))
  94                         return -EFAULT;
  95                 return 0;
  96         }
  97
  98         default:
  99                 dprintk(dev, 1, "Unknown ioctl %08x\n", cmd);
 100                 return -EINVAL;
 101         }
 102         return 0;
 103 }
 104
 105 /* Framebuffer device handling */
 106
 107 static int vivid_fb_set_var(struct vivid_dev *dev, struct fb_var_screeninfo *var)
 108 {
 109         dprintk(dev, 1, "vivid_fb_set_var\n");
 110
 111         if (var->bits_per_pixel != 16) {
 112                 dprintk(dev, 1, "vivid_fb_set_var - Invalid bpp\n");
 113                 return -EINVAL;
 114         }
 115         dev->display_byte_stride = var->xres * dev->bytes_per_pixel;
 116
 117         return 0;
 118 }
 119
 120 static int vivid_fb_get_fix(struct vivid_dev *dev, struct fb_fix_screeninfo *fix)
 121 {
 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;
 129         fix->xpanstep = 1;
 130         fix->ypanstep = 1;
 131         fix->ywrapstep = 0;
 132         fix->line_length = dev->display_byte_stride;
 133         fix->accel = FB_ACCEL_NONE;
 134         return 0;
 135 }
 136
 137 /* Check the requested display mode, returning -EINVAL if we can't
 138    handle it. */
 139
 140 static int _vivid_fb_check_var(struct fb_var_screeninfo *var, struct vivid_dev *dev)
 141 {
 142         dprintk(dev, 1, "vivid_fb_check_var\n");
 143
 144         var->bits_per_pixel = 16;
 145         if (var->green.length == 5) {
 146                 var->red.offset = 10;
 147                 var->red.length = 5;
 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;
 154         } else {
 155                 var->red.offset = 11;
 156                 var->red.length = 5;
 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;
 163         }
 164         var->xoffset = var->yoffset = 0;
 165         var->left_margin = var->upper_margin = 0;
 166         var->nonstd = 0;
 167
 168         var->vmode &= ~FB_VMODE_MASK;
 169         var->vmode = FB_VMODE_NONINTERLACED;
 170
 171         /* Dummy values */
 172         var->hsync_len = 24;
 173         var->vsync_len = 2;
 174         var->pixclock = 84316;
 175         var->right_margin = 776;
 176         var->lower_margin = 591;
 177         return 0;
 178 }
 179
 180 static int vivid_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 181 {
 182         struct vivid_dev *dev = (struct vivid_dev *) info->par;
 183
 184         dprintk(dev, 1, "vivid_fb_check_var\n");
 185         return _vivid_fb_check_var(var, dev);
 186 }
 187
 188 static int vivid_fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 189 {
 190         return 0;
 191 }
 192
 193 static int vivid_fb_set_par(struct fb_info *info)
 194 {
 195         int rc = 0;
 196         struct vivid_dev *dev = (struct vivid_dev *) info->par;
 197
 198         dprintk(dev, 1, "vivid_fb_set_par\n");
 199
 200         rc = vivid_fb_set_var(dev, &info->var);
 201         vivid_fb_get_fix(dev, &info->fix);
 202         return rc;
 203 }
 204
 205 static int vivid_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
 206                                 unsigned blue, unsigned transp,
 207                                 struct fb_info *info)
 208 {
 209         u32 color, *palette;
 210
 211         if (regno >= info->cmap.len)
 212                 return -EINVAL;
 213
 214         color = ((transp & 0xFF00) << 16) | ((red & 0xFF00) << 8) |
 215                  (green & 0xFF00) | ((blue & 0xFF00) >> 8);
 216         if (regno >= 16)
 217                 return -EINVAL;
 218
 219         palette = info->pseudo_palette;
 220         if (info->var.bits_per_pixel == 16) {
 221                 switch (info->var.green.length) {
 222                 case 6:
 223                         color = (red & 0xf800) |
 224                                 ((green & 0xfc00) >> 5) |
 225                                 ((blue & 0xf800) >> 11);
 226                         break;
 227                 case 5:
 228                         color = ((red & 0xf800) >> 1) |
 229                                 ((green & 0xf800) >> 6) |
 230                                 ((blue & 0xf800) >> 11) |
 231                                 (transp ? 0x8000 : 0);
 232                         break;
 233                 }
 234         }
 235         palette[regno] = color;
 236         return 0;
 237 }
 238
 239 /* We don't really support blanking. All this does is enable or
 240    disable the OSD. */
 241 static int vivid_fb_blank(int blank_mode, struct fb_info *info)
 242 {
 243         struct vivid_dev *dev = (struct vivid_dev *)info->par;
 244
 245         dprintk(dev, 1, "Set blanking mode : %d\n", blank_mode);
 246         switch (blank_mode) {
 247         case FB_BLANK_UNBLANK:
 248                 break;
 249         case FB_BLANK_NORMAL:
 250         case FB_BLANK_HSYNC_SUSPEND:
 251         case FB_BLANK_VSYNC_SUSPEND:
 252         case FB_BLANK_POWERDOWN:
 253                 break;
 254         }
 255         return 0;
 256 }
 257
 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,
 266         .fb_cursor      = NULL,
 267         .fb_ioctl       = vivid_fb_ioctl,
 268         .fb_pan_display = vivid_fb_pan_display,
 269         .fb_blank       = vivid_fb_blank,
 270 };
 271
 272 /* Initialization */
 273
 274
 275 /* Setup our initial video mode */
 276 static int vivid_fb_init_vidmode(struct vivid_dev *dev)
 277 {
 278         struct v4l2_rect start_window;
 279
 280         /* Color mode */
 281
 282         dev->bits_per_pixel = 16;
 283         dev->bytes_per_pixel = dev->bits_per_pixel / 8;
 284
 285         start_window.width = MAX_OSD_WIDTH;
 286         start_window.left = 0;
 287
 288         dev->display_byte_stride = start_window.width * dev->bytes_per_pixel;
 289
 290         /* Vertical size & position */
 291
 292         start_window.height = MAX_OSD_HEIGHT;
 293         start_window.top = 0;
 294
 295         dev->display_width = start_window.width;
 296         dev->display_height = start_window.height;
 297
 298         /* Generate a valid fb_var_screeninfo */
 299
 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;
 312
 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);
 316
 317         /* Generate valid fb_fix_screeninfo */
 318
 319         vivid_fb_get_fix(dev, &dev->fb_fix);
 320
 321         /* Generate valid fb_info */
 322
 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;
 331
 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;
 337
 338         /* Allocate color map */
 339         if (fb_alloc_cmap(&dev->fb_info.cmap, 256, 1)) {
 340                 pr_err("abort, unable to alloc cmap\n");
 341                 return -ENOMEM;
 342         }
 343
 344         /* Allocate the pseudo palette */
 345         dev->fb_info.pseudo_palette = kmalloc_array(16, sizeof(u32), GFP_KERNEL);
 346
 347         return dev->fb_info.pseudo_palette ? 0 : -ENOMEM;
 348 }
 349
 350 /* Release any memory we've grabbed */
 351 void vivid_fb_release_buffers(struct vivid_dev *dev)
 352 {
 353         if (dev->video_vbase == NULL)
 354                 return;
 355
 356         /* Release cmap */
 357         if (dev->fb_info.cmap.len)
 358                 fb_dealloc_cmap(&dev->fb_info.cmap);
 359
 360         /* Release pseudo palette */
 361         kfree(dev->fb_info.pseudo_palette);
 362         kfree((void *)dev->video_vbase);
 363 }
 364
 365 /* Initialize the specified card */
 366
 367 int vivid_fb_init(struct vivid_dev *dev)
 368 {
 369         int ret;
 370
 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)
 374                 return -ENOMEM;
 375         dev->video_pbase = virt_to_phys(dev->video_vbase);
 376
 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);
 380
 381         /* Set the startup video mode information */
 382         ret = vivid_fb_init_vidmode(dev);
 383         if (ret) {
 384                 vivid_fb_release_buffers(dev);
 385                 return ret;
 386         }
 387
 388         vivid_clear_fb(dev);
 389
 390         /* Register the framebuffer */
 391         if (register_framebuffer(&dev->fb_info) < 0) {
 392                 vivid_fb_release_buffers(dev);
 393                 return -EINVAL;
 394         }
 395
 396         /* Set the card to the requested mode */
 397         vivid_fb_set_par(&dev->fb_info);
 398         return 0;
 399
 400 }