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:
 - a new jpeg codec driver for Samsung Exynos (jpeg-hw-exynos4)
 - a new dvb frontend for ds2103 chipset (m88ds2103)
 - a new sensor driver for Samsung S5K5BAF UXGA (s5k5baf)
 - new drivers for R-Car VSP1
 - a new radio driver: radio-raremono
 - a new tuner driver for ts2022 chipset (m88ts2022)
 - the analog part of em28xx is now a separate module that only
   load/runs if the device is not a pure digital TV device
 - added a staging driver for bcm2048 radio devices
 - the omap 2 video driver (omap24xx) was moved to staging.  This driver
   is for an old hardware and uses a deprecated Kernel internal API.  If
   nobody cares enough to fix it, it would be removed on a couple Kernel
   releases
 - the sn9c102 driver was moved to staging.  This driver was replaced by
   gspca, and disabled on some distros, as almost all devices are known
   to work properly with gspca.  It should be removed from kernel on a
   couple Kernel releases
 - lots of driver fixes, improvements and cleanups

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (421 commits)
  [media] media: v4l2-dev: fix video device index assignment
  [media] rc-core: reuse device numbers
  [media] em28xx-cards: properly initialize the device bitmap
  [media] Staging: media: Fix line length exceeding 80 characters in as102_drv.c
  [media] Staging: media: Fix line length exceeding 80 characters in as102_fe.c
  [media] Staging: media: Fix quoted string split across line in as102_fe.c
  [media] media: st-rc: Add reset support
  [media] m2m-deinterlace: fix allocated struct type
  [media] radio-usb-si4713: fix sparse non static symbol warnings
  [media] em28xx-audio: remove needless check before usb_free_coherent()
  [media] au0828: Fix sparse non static symbol warning
  Revert "[media] go7007-usb: only use go->dev after allocated"
  [media] em28xx-audio: provide an error code when URB submit fails
  [media] em28xx: fix check for audio only usb interfaces when changing the usb alternate setting
  [media] em28xx: fix usb alternate setting for analog and digital video endpoints > 0
  [media] em28xx: make 'em28xx_ctrl_ops' static
  em28xx-alsa: Fix error patch for init/fini
  [media] em28xx-audio: flush work at .fini
  [media] drxk: remove the option to load firmware asynchronously
  [media] em28xx: adjust period size at runtime
  ...

1 files changed, 196 insertions, 0 deletions

diff --git a/drivers/media/platform/ti-vpe/csc.c b/drivers/media/platform/ti-vpe/csc.c
new file mode 100644
index 000000000000..acfea500710e
--- /dev/null
+++ b/drivers/media/platform/ti-vpe/csc.c
@@ -0,0 +1,196 @@
+/*
+ * Color space converter library
+ *
+ * Copyright (c) 2013 Texas Instruments Inc.
+ *
+ * David Griego, <dagriego@biglakesoftware.com>
+ * Dale Farnsworth, <dale@farnsworth.org>
+ * Archit Taneja, <archit@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/videodev2.h>
+
+#include "csc.h"
+
+/*
+ * 16 coefficients in the order:
+ * a0, b0, c0, a1, b1, c1, a2, b2, c2, d0, d1, d2
+ * (we may need to pass non-default values from user space later on, we might
+ * need to make the coefficient struct more easy to populate)
+ */
+struct colorspace_coeffs {
+        u16     sd[12];
+        u16     hd[12];
+};
+
+/* VIDEO_RANGE: limited range, GRAPHICS_RANGE: full range */
+#define CSC_COEFFS_VIDEO_RANGE_Y2R      0
+#define CSC_COEFFS_GRAPHICS_RANGE_Y2R   1
+#define CSC_COEFFS_VIDEO_RANGE_R2Y      2
+#define CSC_COEFFS_GRAPHICS_RANGE_R2Y   3
+
+/* default colorspace coefficients */
+static struct colorspace_coeffs colorspace_coeffs[4] = {
+        [CSC_COEFFS_VIDEO_RANGE_Y2R] = {
+                {
+                        /* SDTV */
+                        0x0400, 0x0000, 0x057D, 0x0400, 0x1EA7, 0x1D35,
+                        0x0400, 0x06EF, 0x1FFE, 0x0D40, 0x0210, 0x0C88,
+                },
+                {
+                        /* HDTV */
+                        0x0400, 0x0000, 0x0629, 0x0400, 0x1F45, 0x1E2B,
+                        0x0400, 0x0742, 0x0000, 0x0CEC, 0x0148, 0x0C60,
+                },
+        },
+        [CSC_COEFFS_GRAPHICS_RANGE_Y2R] = {
+                {
+                        /* SDTV */
+                        0x04A8, 0x1FFE, 0x0662, 0x04A8, 0x1E6F, 0x1CBF,
+                        0x04A8, 0x0812, 0x1FFF, 0x0C84, 0x0220, 0x0BAC,
+                },
+                {
+                        /* HDTV */
+                        0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
+                        0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
+                },
+        },
+        [CSC_COEFFS_VIDEO_RANGE_R2Y] = {
+                {
+                        /* SDTV */
+                        0x0132, 0x0259, 0x0075, 0x1F50, 0x1EA5, 0x020B,
+                        0x020B, 0x1E4A, 0x1FAB, 0x0000, 0x0200, 0x0200,
+                },
+                {
+                        /* HDTV */
+                        0x00DA, 0x02DC, 0x004A, 0x1F88, 0x1E6C, 0x020C,
+                        0x020C, 0x1E24, 0x1FD0, 0x0000, 0x0200, 0x0200,
+                },
+        },
+        [CSC_COEFFS_GRAPHICS_RANGE_R2Y] = {
+                {
+                        /* SDTV */
+                        0x0107, 0x0204, 0x0064, 0x1F68, 0x1ED6, 0x01C2,
+                        0x01C2, 0x1E87, 0x1FB7, 0x0040, 0x0200, 0x0200,
+                },
+                {
+                        /* HDTV */
+                        0x04A8, 0x0000, 0x072C, 0x04A8, 0x1F26, 0x1DDE,
+                        0x04A8, 0x0873, 0x0000, 0x0C20, 0x0134, 0x0B7C,
+                },
+        },
+};
+
+void csc_dump_regs(struct csc_data *csc)
+{
+        struct device *dev = &csc->pdev->dev;
+
+        u32 read_reg(struct csc_data *csc, int offset)
+        {
+                return ioread32(csc->base + offset);
+        }
+
+#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, read_reg(csc, CSC_##r))
+
+        DUMPREG(CSC00);
+        DUMPREG(CSC01);
+        DUMPREG(CSC02);
+        DUMPREG(CSC03);
+        DUMPREG(CSC04);
+        DUMPREG(CSC05);
+
+#undef DUMPREG
+}
+
+void csc_set_coeff_bypass(struct csc_data *csc, u32 *csc_reg5)
+{
+        *csc_reg5 |= CSC_BYPASS;
+}
+
+/*
+ * set the color space converter coefficient shadow register values
+ */
+void csc_set_coeff(struct csc_data *csc, u32 *csc_reg0,
+                enum v4l2_colorspace src_colorspace,
+                enum v4l2_colorspace dst_colorspace)
+{
+        u32 *csc_reg5 = csc_reg0 + 5;
+        u32 *shadow_csc = csc_reg0;
+        struct colorspace_coeffs *sd_hd_coeffs;
+        u16 *coeff, *end_coeff;
+        enum v4l2_colorspace yuv_colorspace;
+        int sel = 0;
+
+        /*
+         * support only graphics data range(full range) for now, a control ioctl
+         * would be nice here
+         */
+        /* Y2R */
+        if (dst_colorspace == V4L2_COLORSPACE_SRGB &&
+                        (src_colorspace == V4L2_COLORSPACE_SMPTE170M ||
+                        src_colorspace == V4L2_COLORSPACE_REC709)) {
+                /* Y2R */
+                sel = 1;
+                yuv_colorspace = src_colorspace;
+        } else if ((dst_colorspace == V4L2_COLORSPACE_SMPTE170M ||
+                        dst_colorspace == V4L2_COLORSPACE_REC709) &&
+                        src_colorspace == V4L2_COLORSPACE_SRGB) {
+                /* R2Y */
+                sel = 3;
+                yuv_colorspace = dst_colorspace;
+        } else {
+                *csc_reg5 |= CSC_BYPASS;
+                return;
+        }
+
+        sd_hd_coeffs = &colorspace_coeffs[sel];
+
+        /* select between SD or HD coefficients */
+        if (yuv_colorspace == V4L2_COLORSPACE_SMPTE170M)
+                coeff = sd_hd_coeffs->sd;
+        else
+                coeff = sd_hd_coeffs->hd;
+
+        end_coeff = coeff + 12;
+
+        for (; coeff < end_coeff; coeff += 2)
+                *shadow_csc++ = (*(coeff + 1) << 16) | *coeff;
+}
+
+struct csc_data *csc_create(struct platform_device *pdev)
+{
+        struct csc_data *csc;
+
+        dev_dbg(&pdev->dev, "csc_create\n");
+
+        csc = devm_kzalloc(&pdev->dev, sizeof(*csc), GFP_KERNEL);
+        if (!csc) {
+                dev_err(&pdev->dev, "couldn't alloc csc_data\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        csc->pdev = pdev;
+
+        csc->res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
+                        "vpe_csc");
+        if (csc->res == NULL) {
+                dev_err(&pdev->dev, "missing platform resources data\n");
+                return ERR_PTR(-ENODEV);
+        }
+
+        csc->base = devm_ioremap_resource(&pdev->dev, csc->res);
+        if (!csc->base) {
+                dev_err(&pdev->dev, "failed to ioremap\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        return csc;
+}