root/drivers/media/platform/omap/omap_voutlib.c

DEFINITIONS

1. omap_vout_default_crop
2. omap_vout_try_window
3. omap_vout_new_window
4. omap_vout_new_crop
5. omap_vout_new_format
6. omap_vout_alloc_buffer
7. omap_vout_free_buffer
8. omap_vout_dss_omap24xx
9. omap_vout_dss_omap34xx

   1 /*
   2  * omap_voutlib.c
   3  *
   4  * Copyright (C) 2005-2010 Texas Instruments.
   5  *
   6  * This file is licensed under the terms of the GNU General Public License
   7  * version 2. This program is licensed "as is" without any warranty of any
   8  * kind, whether express or implied.
   9  *
  10  * Based on the OMAP2 camera driver
  11  * Video-for-Linux (Version 2) camera capture driver for
  12  * the OMAP24xx camera controller.
  13  *
  14  * Author: Andy Lowe (source@mvista.com)
  15  *
  16  * Copyright (C) 2004 MontaVista Software, Inc.
  17  * Copyright (C) 2010 Texas Instruments.
  18  *
  19  */
  20 
  21 #include <linux/module.h>
  22 #include <linux/errno.h>
  23 #include <linux/kernel.h>
  24 #include <linux/types.h>
  25 #include <linux/videodev2.h>
  26 
  27 #include <linux/dma-mapping.h>
  28 
  29 #include <video/omapfb_dss.h>
  30 
  31 #include "omap_voutlib.h"
  32 
  33 MODULE_AUTHOR("Texas Instruments");
  34 MODULE_DESCRIPTION("OMAP Video library");
  35 MODULE_LICENSE("GPL");
  36 
  37 /* Return the default overlay cropping rectangle in crop given the image
  38  * size in pix and the video display size in fbuf.  The default
  39  * cropping rectangle is the largest rectangle no larger than the capture size
  40  * that will fit on the display.  The default cropping rectangle is centered in
  41  * the image.  All dimensions and offsets are rounded down to even numbers.
  42  */
  43 void omap_vout_default_crop(struct v4l2_pix_format *pix,
  44                   struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop)
  45 {
  46         crop->width = (pix->width < fbuf->fmt.width) ?
  47                 pix->width : fbuf->fmt.width;
  48         crop->height = (pix->height < fbuf->fmt.height) ?
  49                 pix->height : fbuf->fmt.height;
  50         crop->width &= ~1;
  51         crop->height &= ~1;
  52         crop->left = ((pix->width - crop->width) >> 1) & ~1;
  53         crop->top = ((pix->height - crop->height) >> 1) & ~1;
  54 }
  55 EXPORT_SYMBOL_GPL(omap_vout_default_crop);
  56 
  57 /* Given a new render window in new_win, adjust the window to the
  58  * nearest supported configuration.  The adjusted window parameters are
  59  * returned in new_win.
  60  * Returns zero if successful, or -EINVAL if the requested window is
  61  * impossible and cannot reasonably be adjusted.
  62  */
  63 int omap_vout_try_window(struct v4l2_framebuffer *fbuf,
  64                         struct v4l2_window *new_win)
  65 {
  66         struct v4l2_rect try_win;
  67 
  68         /* make a working copy of the new_win rectangle */
  69         try_win = new_win->w;
  70 
  71         /* adjust the preview window so it fits on the display by clipping any
  72          * offscreen areas
  73          */
  74         if (try_win.left < 0) {
  75                 try_win.width += try_win.left;
  76                 try_win.left = 0;
  77         }
  78         if (try_win.top < 0) {
  79                 try_win.height += try_win.top;
  80                 try_win.top = 0;
  81         }
  82         try_win.width = (try_win.width < fbuf->fmt.width) ?
  83                 try_win.width : fbuf->fmt.width;
  84         try_win.height = (try_win.height < fbuf->fmt.height) ?
  85                 try_win.height : fbuf->fmt.height;
  86         if (try_win.left + try_win.width > fbuf->fmt.width)
  87                 try_win.width = fbuf->fmt.width - try_win.left;
  88         if (try_win.top + try_win.height > fbuf->fmt.height)
  89                 try_win.height = fbuf->fmt.height - try_win.top;
  90         try_win.width &= ~1;
  91         try_win.height &= ~1;
  92 
  93         if (try_win.width <= 0 || try_win.height <= 0)
  94                 return -EINVAL;
  95 
  96         /* We now have a valid preview window, so go with it */
  97         new_win->w = try_win;
  98         new_win->field = V4L2_FIELD_NONE;
  99         new_win->clips = NULL;
 100         new_win->clipcount = 0;
 101         new_win->bitmap = NULL;
 102 
 103         return 0;
 104 }
 105 EXPORT_SYMBOL_GPL(omap_vout_try_window);
 106 
 107 /* Given a new render window in new_win, adjust the window to the
 108  * nearest supported configuration.  The image cropping window in crop
 109  * will also be adjusted if necessary.  Preference is given to keeping the
 110  * the window as close to the requested configuration as possible.  If
 111  * successful, new_win, vout->win, and crop are updated.
 112  * Returns zero if successful, or -EINVAL if the requested preview window is
 113  * impossible and cannot reasonably be adjusted.
 114  */
 115 int omap_vout_new_window(struct v4l2_rect *crop,
 116                 struct v4l2_window *win, struct v4l2_framebuffer *fbuf,
 117                 struct v4l2_window *new_win)
 118 {
 119         int err;
 120 
 121         err = omap_vout_try_window(fbuf, new_win);
 122         if (err)
 123                 return err;
 124 
 125         /* update our preview window */
 126         win->w = new_win->w;
 127         win->field = new_win->field;
 128         win->chromakey = new_win->chromakey;
 129 
 130         /* Adjust the cropping window to allow for resizing limitation */
 131         if (omap_vout_dss_omap24xx()) {
 132                 /* For 24xx limit is 8x to 1/2x scaling. */
 133                 if ((crop->height/win->w.height) >= 2)
 134                         crop->height = win->w.height * 2;
 135 
 136                 if ((crop->width/win->w.width) >= 2)
 137                         crop->width = win->w.width * 2;
 138 
 139                 if (crop->width > 768) {
 140                         /* The OMAP2420 vertical resizing line buffer is 768
 141                          * pixels wide. If the cropped image is wider than
 142                          * 768 pixels then it cannot be vertically resized.
 143                          */
 144                         if (crop->height != win->w.height)
 145                                 crop->width = 768;
 146                 }
 147         } else if (omap_vout_dss_omap34xx()) {
 148                 /* For 34xx limit is 8x to 1/4x scaling. */
 149                 if ((crop->height/win->w.height) >= 4)
 150                         crop->height = win->w.height * 4;
 151 
 152                 if ((crop->width/win->w.width) >= 4)
 153                         crop->width = win->w.width * 4;
 154         }
 155         return 0;
 156 }
 157 EXPORT_SYMBOL_GPL(omap_vout_new_window);
 158 
 159 /* Given a new cropping rectangle in new_crop, adjust the cropping rectangle to
 160  * the nearest supported configuration.  The image render window in win will
 161  * also be adjusted if necessary.  The preview window is adjusted such that the
 162  * horizontal and vertical rescaling ratios stay constant.  If the render
 163  * window would fall outside the display boundaries, the cropping rectangle
 164  * will also be adjusted to maintain the rescaling ratios.  If successful, crop
 165  * and win are updated.
 166  * Returns zero if successful, or -EINVAL if the requested cropping rectangle is
 167  * impossible and cannot reasonably be adjusted.
 168  */
 169 int omap_vout_new_crop(struct v4l2_pix_format *pix,
 170               struct v4l2_rect *crop, struct v4l2_window *win,
 171               struct v4l2_framebuffer *fbuf, const struct v4l2_rect *new_crop)
 172 {
 173         struct v4l2_rect try_crop;
 174         unsigned long vresize, hresize;
 175 
 176         /* make a working copy of the new_crop rectangle */
 177         try_crop = *new_crop;
 178 
 179         /* adjust the cropping rectangle so it fits in the image */
 180         if (try_crop.left < 0) {
 181                 try_crop.width += try_crop.left;
 182                 try_crop.left = 0;
 183         }
 184         if (try_crop.top < 0) {
 185                 try_crop.height += try_crop.top;
 186                 try_crop.top = 0;
 187         }
 188         try_crop.width = (try_crop.width < pix->width) ?
 189                 try_crop.width : pix->width;
 190         try_crop.height = (try_crop.height < pix->height) ?
 191                 try_crop.height : pix->height;
 192         if (try_crop.left + try_crop.width > pix->width)
 193                 try_crop.width = pix->width - try_crop.left;
 194         if (try_crop.top + try_crop.height > pix->height)
 195                 try_crop.height = pix->height - try_crop.top;
 196 
 197         try_crop.width &= ~1;
 198         try_crop.height &= ~1;
 199 
 200         if (try_crop.width <= 0 || try_crop.height <= 0)
 201                 return -EINVAL;
 202 
 203         if (omap_vout_dss_omap24xx()) {
 204                 if (try_crop.height != win->w.height) {
 205                         /* If we're resizing vertically, we can't support a
 206                          * crop width wider than 768 pixels.
 207                          */
 208                         if (try_crop.width > 768)
 209                                 try_crop.width = 768;
 210                 }
 211         }
 212         /* vertical resizing */
 213         vresize = (1024 * try_crop.height) / win->w.height;
 214         if (omap_vout_dss_omap24xx() && (vresize > 2048))
 215                 vresize = 2048;
 216         else if (omap_vout_dss_omap34xx() && (vresize > 4096))
 217                 vresize = 4096;
 218 
 219         win->w.height = ((1024 * try_crop.height) / vresize) & ~1;
 220         if (win->w.height == 0)
 221                 win->w.height = 2;
 222         if (win->w.height + win->w.top > fbuf->fmt.height) {
 223                 /* We made the preview window extend below the bottom of the
 224                  * display, so clip it to the display boundary and resize the
 225                  * cropping height to maintain the vertical resizing ratio.
 226                  */
 227                 win->w.height = (fbuf->fmt.height - win->w.top) & ~1;
 228                 if (try_crop.height == 0)
 229                         try_crop.height = 2;
 230         }
 231         /* horizontal resizing */
 232         hresize = (1024 * try_crop.width) / win->w.width;
 233         if (omap_vout_dss_omap24xx() && (hresize > 2048))
 234                 hresize = 2048;
 235         else if (omap_vout_dss_omap34xx() && (hresize > 4096))
 236                 hresize = 4096;
 237 
 238         win->w.width = ((1024 * try_crop.width) / hresize) & ~1;
 239         if (win->w.width == 0)
 240                 win->w.width = 2;
 241         if (win->w.width + win->w.left > fbuf->fmt.width) {
 242                 /* We made the preview window extend past the right side of the
 243                  * display, so clip it to the display boundary and resize the
 244                  * cropping width to maintain the horizontal resizing ratio.
 245                  */
 246                 win->w.width = (fbuf->fmt.width - win->w.left) & ~1;
 247                 if (try_crop.width == 0)
 248                         try_crop.width = 2;
 249         }
 250         if (omap_vout_dss_omap24xx()) {
 251                 if ((try_crop.height/win->w.height) >= 2)
 252                         try_crop.height = win->w.height * 2;
 253 
 254                 if ((try_crop.width/win->w.width) >= 2)
 255                         try_crop.width = win->w.width * 2;
 256 
 257                 if (try_crop.width > 768) {
 258                         /* The OMAP2420 vertical resizing line buffer is
 259                          * 768 pixels wide.  If the cropped image is wider
 260                          * than 768 pixels then it cannot be vertically resized.
 261                          */
 262                         if (try_crop.height != win->w.height)
 263                                 try_crop.width = 768;
 264                 }
 265         } else if (omap_vout_dss_omap34xx()) {
 266                 if ((try_crop.height/win->w.height) >= 4)
 267                         try_crop.height = win->w.height * 4;
 268 
 269                 if ((try_crop.width/win->w.width) >= 4)
 270                         try_crop.width = win->w.width * 4;
 271         }
 272         /* update our cropping rectangle and we're done */
 273         *crop = try_crop;
 274         return 0;
 275 }
 276 EXPORT_SYMBOL_GPL(omap_vout_new_crop);
 277 
 278 /* Given a new format in pix and fbuf,  crop and win
 279  * structures are initialized to default values. crop
 280  * is initialized to the largest window size that will fit on the display.  The
 281  * crop window is centered in the image. win is initialized to
 282  * the same size as crop and is centered on the display.
 283  * All sizes and offsets are constrained to be even numbers.
 284  */
 285 void omap_vout_new_format(struct v4l2_pix_format *pix,
 286                 struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop,
 287                 struct v4l2_window *win)
 288 {
 289         /* crop defines the preview source window in the image capture
 290          * buffer
 291          */
 292         omap_vout_default_crop(pix, fbuf, crop);
 293 
 294         /* win defines the preview target window on the display */
 295         win->w.width = crop->width;
 296         win->w.height = crop->height;
 297         win->w.left = ((fbuf->fmt.width - win->w.width) >> 1) & ~1;
 298         win->w.top = ((fbuf->fmt.height - win->w.height) >> 1) & ~1;
 299 }
 300 EXPORT_SYMBOL_GPL(omap_vout_new_format);
 301 
 302 /*
 303  * Allocate buffers
 304  */
 305 unsigned long omap_vout_alloc_buffer(u32 buf_size, u32 *phys_addr)
 306 {
 307         u32 order, size;
 308         unsigned long virt_addr, addr;
 309 
 310         size = PAGE_ALIGN(buf_size);
 311         order = get_order(size);
 312         virt_addr = __get_free_pages(GFP_KERNEL, order);
 313         addr = virt_addr;
 314 
 315         if (virt_addr) {
 316                 while (size > 0) {
 317                         SetPageReserved(virt_to_page(addr));
 318                         addr += PAGE_SIZE;
 319                         size -= PAGE_SIZE;
 320                 }
 321         }
 322         *phys_addr = (u32) virt_to_phys((void *) virt_addr);
 323         return virt_addr;
 324 }
 325 
 326 /*
 327  * Free buffers
 328  */
 329 void omap_vout_free_buffer(unsigned long virtaddr, u32 buf_size)
 330 {
 331         u32 order, size;
 332         unsigned long addr = virtaddr;
 333 
 334         size = PAGE_ALIGN(buf_size);
 335         order = get_order(size);
 336 
 337         while (size > 0) {
 338                 ClearPageReserved(virt_to_page(addr));
 339                 addr += PAGE_SIZE;
 340                 size -= PAGE_SIZE;
 341         }
 342         free_pages((unsigned long) virtaddr, order);
 343 }
 344 
 345 bool omap_vout_dss_omap24xx(void)
 346 {
 347         return omapdss_get_version() == OMAPDSS_VER_OMAP24xx;
 348 }
 349 
 350 bool omap_vout_dss_omap34xx(void)
 351 {
 352         switch (omapdss_get_version()) {
 353         case OMAPDSS_VER_OMAP34xx_ES1:
 354         case OMAPDSS_VER_OMAP34xx_ES3:
 355         case OMAPDSS_VER_OMAP3630:
 356         case OMAPDSS_VER_AM35xx:
 357                 return true;
 358         default:
 359                 return false;
 360         }
 361 }