Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull media updates from Mauro Carvalho Chehab:
 "The first part of the media updates for Kernel 3.7.

  This series contain:

   - A major tree renaming patch series: now, drivers are organized
     internally by their used bus, instead of by V4L2 and/or DVB API,
     providing a cleaner driver location for hybrid drivers that
     implement both APIs, and allowing to cleanup the Kconfig items and
     make them more intuitive for the end user;

   - Media Kernel developers are typically very lazy with their duties
     of keeping the MAINTAINERS entries for their drivers updated.  As
     now the tree is more organized, we're doing an effort to add/update
     those entries for the drivers that aren't currently orphan;

   - Several DVB USB drivers got moved to a new DVB USB v2 core; the new
     core fixes several bugs (as the existing one that got bitroted).
     Now, suspend/resume finally started to work fine (at least with
     some devices - we should expect more work with regards to it);

   - added multistream support for DVB-T2, and unified the API for
     DVB-S2 and ISDB-S.  Backward binary support is preserved;

   - as usual, a few new drivers, some V4L2 core improvements and lots
     of drivers improvements and fixes.

  There are some points to notice on this series:

   1) you should expect a trivial merge conflict on your tree, with the
      removal of Documentation/feature-removal-schedule.txt: this series
      would be adding two additional entries there.  I opted to not
      rebase it due to this recent change;

   2) With regards to the PCTV 520e udev-related breakage, I opted to
      fix it in a way that the patches can be backported to 3.5 even
      without your firmware fix patch.  This way, Greg doesn't need to
      rush backporting your patch (as there are still the firmware cache
      and firmware path customization issues to be addressed there).

      I'll send later a patch (likely after the end of the merge window)
      reverting the rest of the DRX-K async firmware request, fully
      restoring its original behaviour to allow media drivers to
      initialize everything serialized as before for 3.7 and upper.

   3) I'm planning to work on this weekend to test the DMABUF patches
      for V4L2.  The patches are on my queue for several Kernel cycles,
      but, up to now, there is/was no way to test the series locally.

      I have some concerns about this particular changeset with regards
      to security issues, and with regards to the replacement of the old
      VIDIOC_OVERLAY ioctl's that is broken on modern systems, due to
      GPU drivers change.  The Overlay API allows direct PCI2PCI
      transfers from a media capture card into the GPU framebuffer, but
      its API is crappy.  Also, the only existing X11 driver that
      implements it requires a XV extension that is not available
      anymore on modern drivers.  The DMABUF can do the same thing, but
      with it is promising to be a properly-designed API.  If I can
      successfully test this series and be happy with it, I should be
      asking you to pull them next week."

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (717 commits)
  em28xx: regression fix: use DRX-K sync firmware requests on em28xx
  drxk: allow loading firmware synchrousnously
  em28xx: Make all em28xx extensions to be initialized asynchronously
  [media] tda18271: properly report read errors in tda18271_get_id
  [media] tda18271: delay IR & RF calibration until init() if delay_cal is set
  [media] MAINTAINERS: add Michael Krufky as tda827x maintainer
  [media] MAINTAINERS: add Michael Krufky as tda8290 maintainer
  [media] MAINTAINERS: add Michael Krufky as cxusb maintainer
  [media] MAINTAINERS: add Michael Krufky as lg2160 maintainer
  [media] MAINTAINERS: add Michael Krufky as lgdt3305 maintainer
  [media] MAINTAINERS: add Michael Krufky as mxl111sf maintainer
  [media] MAINTAINERS: add Michael Krufky as mxl5007t maintainer
  [media] MAINTAINERS: add Michael Krufky as tda18271 maintainer
  [media] s5p-tv: Report only multi-plane capabilities in vidioc_querycap
  [media] s5p-mfc: Fix misplaced return statement in s5p_mfc_suspend()
  [media] exynos-gsc: Add missing static storage class specifiers
  [media] exynos-gsc: Remove <linux/version.h> header file inclusion
  [media] s5p-fimc: Fix incorrect condition in fimc_lite_reqbufs()
  [media] s5p-tv: Fix potential NULL pointer dereference error
  [media] s5k6aa: Fix possible NULL pointer dereference
  ...

1 files changed, 339 insertions, 0 deletions

diff --git a/drivers/media/platform/omap/omap_voutlib.c b/drivers/media/platform/omap/omap_voutlib.c
new file mode 100644
index 000000000000..115408b9274f
--- /dev/null
+++ b/drivers/media/platform/omap/omap_voutlib.c
@@ -0,0 +1,339 @@
+/*
+ * omap_voutlib.c
+ *
+ * Copyright (C) 2005-2010 Texas Instruments.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ * Based on the OMAP2 camera driver
+ * Video-for-Linux (Version 2) camera capture driver for
+ * the OMAP24xx camera controller.
+ *
+ * Author: Andy Lowe (source@mvista.com)
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2010 Texas Instruments.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/videodev2.h>
+
+#include <linux/dma-mapping.h>
+
+#include <plat/cpu.h>
+
+#include "omap_voutlib.h"
+
+MODULE_AUTHOR("Texas Instruments");
+MODULE_DESCRIPTION("OMAP Video library");
+MODULE_LICENSE("GPL");
+
+/* Return the default overlay cropping rectangle in crop given the image
+ * size in pix and the video display size in fbuf.  The default
+ * cropping rectangle is the largest rectangle no larger than the capture size
+ * that will fit on the display.  The default cropping rectangle is centered in
+ * the image.  All dimensions and offsets are rounded down to even numbers.
+ */
+void omap_vout_default_crop(struct v4l2_pix_format *pix,
+                  struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop)
+{
+        crop->width = (pix->width < fbuf->fmt.width) ?
+                pix->width : fbuf->fmt.width;
+        crop->height = (pix->height < fbuf->fmt.height) ?
+                pix->height : fbuf->fmt.height;
+        crop->width &= ~1;
+        crop->height &= ~1;
+        crop->left = ((pix->width - crop->width) >> 1) & ~1;
+        crop->top = ((pix->height - crop->height) >> 1) & ~1;
+}
+EXPORT_SYMBOL_GPL(omap_vout_default_crop);
+
+/* Given a new render window in new_win, adjust the window to the
+ * nearest supported configuration.  The adjusted window parameters are
+ * returned in new_win.
+ * Returns zero if successful, or -EINVAL if the requested window is
+ * impossible and cannot reasonably be adjusted.
+ */
+int omap_vout_try_window(struct v4l2_framebuffer *fbuf,
+                        struct v4l2_window *new_win)
+{
+        struct v4l2_rect try_win;
+
+        /* make a working copy of the new_win rectangle */
+        try_win = new_win->w;
+
+        /* adjust the preview window so it fits on the display by clipping any
+         * offscreen areas
+         */
+        if (try_win.left < 0) {
+                try_win.width += try_win.left;
+                try_win.left = 0;
+        }
+        if (try_win.top < 0) {
+                try_win.height += try_win.top;
+                try_win.top = 0;
+        }
+        try_win.width = (try_win.width < fbuf->fmt.width) ?
+                try_win.width : fbuf->fmt.width;
+        try_win.height = (try_win.height < fbuf->fmt.height) ?
+                try_win.height : fbuf->fmt.height;
+        if (try_win.left + try_win.width > fbuf->fmt.width)
+                try_win.width = fbuf->fmt.width - try_win.left;
+        if (try_win.top + try_win.height > fbuf->fmt.height)
+                try_win.height = fbuf->fmt.height - try_win.top;
+        try_win.width &= ~1;
+        try_win.height &= ~1;
+
+        if (try_win.width <= 0 || try_win.height <= 0)
+                return -EINVAL;
+
+        /* We now have a valid preview window, so go with it */
+        new_win->w = try_win;
+        new_win->field = V4L2_FIELD_ANY;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_vout_try_window);
+
+/* Given a new render window in new_win, adjust the window to the
+ * nearest supported configuration.  The image cropping window in crop
+ * will also be adjusted if necessary.  Preference is given to keeping the
+ * the window as close to the requested configuration as possible.  If
+ * successful, new_win, vout->win, and crop are updated.
+ * Returns zero if successful, or -EINVAL if the requested preview window is
+ * impossible and cannot reasonably be adjusted.
+ */
+int omap_vout_new_window(struct v4l2_rect *crop,
+                struct v4l2_window *win, struct v4l2_framebuffer *fbuf,
+                struct v4l2_window *new_win)
+{
+        int err;
+
+        err = omap_vout_try_window(fbuf, new_win);
+        if (err)
+                return err;
+
+        /* update our preview window */
+        win->w = new_win->w;
+        win->field = new_win->field;
+        win->chromakey = new_win->chromakey;
+
+        /* Adjust the cropping window to allow for resizing limitation */
+        if (cpu_is_omap24xx()) {
+                /* For 24xx limit is 8x to 1/2x scaling. */
+                if ((crop->height/win->w.height) >= 2)
+                        crop->height = win->w.height * 2;
+
+                if ((crop->width/win->w.width) >= 2)
+                        crop->width = win->w.width * 2;
+
+                if (crop->width > 768) {
+                        /* The OMAP2420 vertical resizing line buffer is 768
+                         * pixels wide. If the cropped image is wider than
+                         * 768 pixels then it cannot be vertically resized.
+                         */
+                        if (crop->height != win->w.height)
+                                crop->width = 768;
+                }
+        } else if (cpu_is_omap34xx()) {
+                /* For 34xx limit is 8x to 1/4x scaling. */
+                if ((crop->height/win->w.height) >= 4)
+                        crop->height = win->w.height * 4;
+
+                if ((crop->width/win->w.width) >= 4)
+                        crop->width = win->w.width * 4;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_vout_new_window);
+
+/* Given a new cropping rectangle in new_crop, adjust the cropping rectangle to
+ * the nearest supported configuration.  The image render window in win will
+ * also be adjusted if necessary.  The preview window is adjusted such that the
+ * horizontal and vertical rescaling ratios stay constant.  If the render
+ * window would fall outside the display boundaries, the cropping rectangle
+ * will also be adjusted to maintain the rescaling ratios.  If successful, crop
+ * and win are updated.
+ * Returns zero if successful, or -EINVAL if the requested cropping rectangle is
+ * impossible and cannot reasonably be adjusted.
+ */
+int omap_vout_new_crop(struct v4l2_pix_format *pix,
+              struct v4l2_rect *crop, struct v4l2_window *win,
+              struct v4l2_framebuffer *fbuf, const struct v4l2_rect *new_crop)
+{
+        struct v4l2_rect try_crop;
+        unsigned long vresize, hresize;
+
+        /* make a working copy of the new_crop rectangle */
+        try_crop = *new_crop;
+
+        /* adjust the cropping rectangle so it fits in the image */
+        if (try_crop.left < 0) {
+                try_crop.width += try_crop.left;
+                try_crop.left = 0;
+        }
+        if (try_crop.top < 0) {
+                try_crop.height += try_crop.top;
+                try_crop.top = 0;
+        }
+        try_crop.width = (try_crop.width < pix->width) ?
+                try_crop.width : pix->width;
+        try_crop.height = (try_crop.height < pix->height) ?
+                try_crop.height : pix->height;
+        if (try_crop.left + try_crop.width > pix->width)
+                try_crop.width = pix->width - try_crop.left;
+        if (try_crop.top + try_crop.height > pix->height)
+                try_crop.height = pix->height - try_crop.top;
+
+        try_crop.width &= ~1;
+        try_crop.height &= ~1;
+
+        if (try_crop.width <= 0 || try_crop.height <= 0)
+                return -EINVAL;
+
+        if (cpu_is_omap24xx()) {
+                if (try_crop.height != win->w.height) {
+                        /* If we're resizing vertically, we can't support a
+                         * crop width wider than 768 pixels.
+                         */
+                        if (try_crop.width > 768)
+                                try_crop.width = 768;
+                }
+        }
+        /* vertical resizing */
+        vresize = (1024 * try_crop.height) / win->w.height;
+        if (cpu_is_omap24xx() && (vresize > 2048))
+                vresize = 2048;
+        else if (cpu_is_omap34xx() && (vresize > 4096))
+                vresize = 4096;
+
+        win->w.height = ((1024 * try_crop.height) / vresize) & ~1;
+        if (win->w.height == 0)
+                win->w.height = 2;
+        if (win->w.height + win->w.top > fbuf->fmt.height) {
+                /* We made the preview window extend below the bottom of the
+                 * display, so clip it to the display boundary and resize the
+                 * cropping height to maintain the vertical resizing ratio.
+                 */
+                win->w.height = (fbuf->fmt.height - win->w.top) & ~1;
+                if (try_crop.height == 0)
+                        try_crop.height = 2;
+        }
+        /* horizontal resizing */
+        hresize = (1024 * try_crop.width) / win->w.width;
+        if (cpu_is_omap24xx() && (hresize > 2048))
+                hresize = 2048;
+        else if (cpu_is_omap34xx() && (hresize > 4096))
+                hresize = 4096;
+
+        win->w.width = ((1024 * try_crop.width) / hresize) & ~1;
+        if (win->w.width == 0)
+                win->w.width = 2;
+        if (win->w.width + win->w.left > fbuf->fmt.width) {
+                /* We made the preview window extend past the right side of the
+                 * display, so clip it to the display boundary and resize the
+                 * cropping width to maintain the horizontal resizing ratio.
+                 */
+                win->w.width = (fbuf->fmt.width - win->w.left) & ~1;
+                if (try_crop.width == 0)
+                        try_crop.width = 2;
+        }
+        if (cpu_is_omap24xx()) {
+                if ((try_crop.height/win->w.height) >= 2)
+                        try_crop.height = win->w.height * 2;
+
+                if ((try_crop.width/win->w.width) >= 2)
+                        try_crop.width = win->w.width * 2;
+
+                if (try_crop.width > 768) {
+                        /* The OMAP2420 vertical resizing line buffer is
+                         * 768 pixels wide.  If the cropped image is wider
+                         * than 768 pixels then it cannot be vertically resized.
+                         */
+                        if (try_crop.height != win->w.height)
+                                try_crop.width = 768;
+                }
+        } else if (cpu_is_omap34xx()) {
+                if ((try_crop.height/win->w.height) >= 4)
+                        try_crop.height = win->w.height * 4;
+
+                if ((try_crop.width/win->w.width) >= 4)
+                        try_crop.width = win->w.width * 4;
+        }
+        /* update our cropping rectangle and we're done */
+        *crop = try_crop;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_vout_new_crop);
+
+/* Given a new format in pix and fbuf,  crop and win
+ * structures are initialized to default values. crop
+ * is initialized to the largest window size that will fit on the display.  The
+ * crop window is centered in the image. win is initialized to
+ * the same size as crop and is centered on the display.
+ * All sizes and offsets are constrained to be even numbers.
+ */
+void omap_vout_new_format(struct v4l2_pix_format *pix,
+                struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop,
+                struct v4l2_window *win)
+{
+        /* crop defines the preview source window in the image capture
+         * buffer
+         */
+        omap_vout_default_crop(pix, fbuf, crop);
+
+        /* win defines the preview target window on the display */
+        win->w.width = crop->width;
+        win->w.height = crop->height;
+        win->w.left = ((fbuf->fmt.width - win->w.width) >> 1) & ~1;
+        win->w.top = ((fbuf->fmt.height - win->w.height) >> 1) & ~1;
+}
+EXPORT_SYMBOL_GPL(omap_vout_new_format);
+
+/*
+ * Allocate buffers
+ */
+unsigned long omap_vout_alloc_buffer(u32 buf_size, u32 *phys_addr)
+{
+        u32 order, size;
+        unsigned long virt_addr, addr;
+
+        size = PAGE_ALIGN(buf_size);
+        order = get_order(size);
+        virt_addr = __get_free_pages(GFP_KERNEL, order);
+        addr = virt_addr;
+
+        if (virt_addr) {
+                while (size > 0) {
+                        SetPageReserved(virt_to_page(addr));
+                        addr += PAGE_SIZE;
+                        size -= PAGE_SIZE;
+                }
+        }
+        *phys_addr = (u32) virt_to_phys((void *) virt_addr);
+        return virt_addr;
+}
+
+/*
+ * Free buffers
+ */
+void omap_vout_free_buffer(unsigned long virtaddr, u32 buf_size)
+{
+        u32 order, size;
+        unsigned long addr = virtaddr;
+
+        size = PAGE_ALIGN(buf_size);
+        order = get_order(size);
+
+        while (size > 0) {
+                ClearPageReserved(virt_to_page(addr));
+                addr += PAGE_SIZE;
+                size -= PAGE_SIZE;
+        }
+        free_pages((unsigned long) virtaddr, order);
+}