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

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6: (442 commits)
  [media] videobuf2-dma-contig: make cookie() return a pointer to dma_addr_t
  [media] sh_mobile_ceu_camera: Do not call vb2's mem_ops directly
  [media] V4L: soc-camera: explicitly require V4L2_BUF_TYPE_VIDEO_CAPTURE
  [media] v4l: soc-camera: Store negotiated buffer settings
  [media] rc: interim support for 32-bit NEC-ish scancodes
  [media] mceusb: topseed 0x0011 needs gen3 init for tx to work
  [media] lirc_zilog: error out if buffer read bytes != chunk size
  [media] lirc: silence some compile warnings
  [media] hdpvr: use same polling interval as other OS
  [media] ir-kbd-i2c: pass device code w/key in hauppauge case
  [media] rc/keymaps: Remove the obsolete rc-rc5-tv keymap
  [media] remove the old RC_MAP_HAUPPAUGE_NEW RC map
  [media] rc/keymaps: Rename Hauppauge table as rc-hauppauge
  [media] rc-rc5-hauppauge-new: Fix Hauppauge Grey mapping
  [media] rc-rc5-hauppauge-new: Add support for the old Black RC
  [media] rc-rc5-hauppauge-new: Add the old control to the table
  [media] rc-winfast: Fix the keycode tables
  [media] a800: Fix a few wrong IR key assignments
  [media] opera1: Use multimedia keys instead of an app-specific mapping
  [media] dw2102: Use multimedia keys instead of an app-specific mapping
  ...

Fix up trivial conflicts (remove/modify and some real conflicts) in:
	arch/arm/mach-omap2/devices.c
	drivers/staging/Kconfig
	drivers/staging/Makefile
	drivers/staging/dabusb/dabusb.c
	drivers/staging/dabusb/dabusb.h
	drivers/staging/easycap/easycap_ioctl.c
	drivers/staging/usbvideo/usbvideo.c
	drivers/staging/usbvideo/vicam.c

32 files changed, 2402 insertions, 160 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index b0ada6f37dd6..75cf611641e6 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -233,6 +233,7 @@ header-y += magic.h
 header-y += major.h
 header-y += map_to_7segment.h
 header-y += matroxfb.h
+header-y += media.h
 header-y += mempolicy.h
 header-y += meye.h
 header-y += mii.h
@@ -276,6 +277,7 @@ header-y += nfsacl.h
 header-y += nl80211.h
 header-y += nubus.h
 header-y += nvram.h
+header-y += omap3isp.h
 header-y += omapfb.h
 header-y += oom.h
 header-y += param.h
@@ -370,6 +372,8 @@ header-y += unistd.h
 header-y += usbdevice_fs.h
 header-y += utime.h
 header-y += utsname.h
+header-y += v4l2-mediabus.h
+header-y += v4l2-subdev.h
 header-y += veth.h
 header-y += vhost.h
 header-y += videodev2.h
diff --git a/include/linux/media.h b/include/linux/media.h
new file mode 100644
index 000000000000..0ef883327de2
--- /dev/null
+++ b/include/linux/media.h
@@ -0,0 +1,132 @@
+/*
+ * Multimedia device API
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __LINUX_MEDIA_H
+#define __LINUX_MEDIA_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <linux/version.h>
+
+#define MEDIA_API_VERSION       KERNEL_VERSION(0, 1, 0)
+
+struct media_device_info {
+        char driver[16];
+        char model[32];
+        char serial[40];
+        char bus_info[32];
+        __u32 media_version;
+        __u32 hw_revision;
+        __u32 driver_version;
+        __u32 reserved[31];
+};
+
+#define MEDIA_ENT_ID_FLAG_NEXT          (1 << 31)
+
+#define MEDIA_ENT_TYPE_SHIFT            16
+#define MEDIA_ENT_TYPE_MASK             0x00ff0000
+#define MEDIA_ENT_SUBTYPE_MASK          0x0000ffff
+
+#define MEDIA_ENT_T_DEVNODE             (1 << MEDIA_ENT_TYPE_SHIFT)
+#define MEDIA_ENT_T_DEVNODE_V4L         (MEDIA_ENT_T_DEVNODE + 1)
+#define MEDIA_ENT_T_DEVNODE_FB          (MEDIA_ENT_T_DEVNODE + 2)
+#define MEDIA_ENT_T_DEVNODE_ALSA        (MEDIA_ENT_T_DEVNODE + 3)
+#define MEDIA_ENT_T_DEVNODE_DVB         (MEDIA_ENT_T_DEVNODE + 4)
+
+#define MEDIA_ENT_T_V4L2_SUBDEV         (2 << MEDIA_ENT_TYPE_SHIFT)
+#define MEDIA_ENT_T_V4L2_SUBDEV_SENSOR  (MEDIA_ENT_T_V4L2_SUBDEV + 1)
+#define MEDIA_ENT_T_V4L2_SUBDEV_FLASH   (MEDIA_ENT_T_V4L2_SUBDEV + 2)
+#define MEDIA_ENT_T_V4L2_SUBDEV_LENS    (MEDIA_ENT_T_V4L2_SUBDEV + 3)
+
+#define MEDIA_ENT_FL_DEFAULT            (1 << 0)
+
+struct media_entity_desc {
+        __u32 id;
+        char name[32];
+        __u32 type;
+        __u32 revision;
+        __u32 flags;
+        __u32 group_id;
+        __u16 pads;
+        __u16 links;
+
+        __u32 reserved[4];
+
+        union {
+                /* Node specifications */
+                struct {
+                        __u32 major;
+                        __u32 minor;
+                } v4l;
+                struct {
+                        __u32 major;
+                        __u32 minor;
+                } fb;
+                struct {
+                        __u32 card;
+                        __u32 device;
+                        __u32 subdevice;
+                } alsa;
+                int dvb;
+
+                /* Sub-device specifications */
+                /* Nothing needed yet */
+                __u8 raw[184];
+        };
+};
+
+#define MEDIA_PAD_FL_SINK               (1 << 0)
+#define MEDIA_PAD_FL_SOURCE             (1 << 1)
+
+struct media_pad_desc {
+        __u32 entity;           /* entity ID */
+        __u16 index;            /* pad index */
+        __u32 flags;            /* pad flags */
+        __u32 reserved[2];
+};
+
+#define MEDIA_LNK_FL_ENABLED            (1 << 0)
+#define MEDIA_LNK_FL_IMMUTABLE          (1 << 1)
+#define MEDIA_LNK_FL_DYNAMIC            (1 << 2)
+
+struct media_link_desc {
+        struct media_pad_desc source;
+        struct media_pad_desc sink;
+        __u32 flags;
+        __u32 reserved[2];
+};
+
+struct media_links_enum {
+        __u32 entity;
+        /* Should have enough room for pads elements */
+        struct media_pad_desc __user *pads;
+        /* Should have enough room for links elements */
+        struct media_link_desc __user *links;
+        __u32 reserved[4];
+};
+
+#define MEDIA_IOC_DEVICE_INFO           _IOWR('|', 0x00, struct media_device_info)
+#define MEDIA_IOC_ENUM_ENTITIES         _IOWR('|', 0x01, struct media_entity_desc)
+#define MEDIA_IOC_ENUM_LINKS            _IOWR('|', 0x02, struct media_links_enum)
+#define MEDIA_IOC_SETUP_LINK            _IOWR('|', 0x03, struct media_link_desc)
+
+#endif /* __LINUX_MEDIA_H */
diff --git a/include/linux/mfd/wl1273-core.h b/include/linux/mfd/wl1273-core.h
index 9787293eae5f..db2f3f454a1b 100644
--- a/include/linux/mfd/wl1273-core.h
+++ b/include/linux/mfd/wl1273-core.h
@@ -280,7 +280,9 @@ struct wl1273_core {
 
         struct i2c_client *client;
 
+        int (*read)(struct wl1273_core *core, u8, u16 *);
         int (*write)(struct wl1273_core *core, u8, u16);
+        int (*write_data)(struct wl1273_core *core, u8 *, u16);
         int (*set_audio)(struct wl1273_core *core, unsigned int);
         int (*set_volume)(struct wl1273_core *core, unsigned int);
 };
diff --git a/include/linux/omap3isp.h b/include/linux/omap3isp.h
new file mode 100644
index 000000000000..150822b4dbff
--- /dev/null
+++ b/include/linux/omap3isp.h
@@ -0,0 +1,646 @@
+/*
+ * omap3isp.h
+ *
+ * TI OMAP3 ISP - User-space API
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Copyright (C) 2009 Texas Instruments, Inc.
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef OMAP3_ISP_USER_H
+#define OMAP3_ISP_USER_H
+
+#include <linux/types.h>
+
+/*
+ * Private IOCTLs
+ *
+ * VIDIOC_OMAP3ISP_CCDC_CFG: Set CCDC configuration
+ * VIDIOC_OMAP3ISP_PRV_CFG: Set preview engine configuration
+ * VIDIOC_OMAP3ISP_AEWB_CFG: Set AEWB module configuration
+ * VIDIOC_OMAP3ISP_HIST_CFG: Set histogram module configuration
+ * VIDIOC_OMAP3ISP_AF_CFG: Set auto-focus module configuration
+ * VIDIOC_OMAP3ISP_STAT_REQ: Read statistics (AEWB/AF/histogram) data
+ * VIDIOC_OMAP3ISP_STAT_EN: Enable/disable a statistics module
+ */
+
+#define VIDIOC_OMAP3ISP_CCDC_CFG \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 1, struct omap3isp_ccdc_update_config)
+#define VIDIOC_OMAP3ISP_PRV_CFG \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 2, struct omap3isp_prev_update_config)
+#define VIDIOC_OMAP3ISP_AEWB_CFG \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 3, struct omap3isp_h3a_aewb_config)
+#define VIDIOC_OMAP3ISP_HIST_CFG \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 4, struct omap3isp_hist_config)
+#define VIDIOC_OMAP3ISP_AF_CFG \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 5, struct omap3isp_h3a_af_config)
+#define VIDIOC_OMAP3ISP_STAT_REQ \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 6, struct omap3isp_stat_data)
+#define VIDIOC_OMAP3ISP_STAT_EN \
+        _IOWR('V', BASE_VIDIOC_PRIVATE + 7, unsigned long)
+
+/*
+ * Events
+ *
+ * V4L2_EVENT_OMAP3ISP_AEWB: AEWB statistics data ready
+ * V4L2_EVENT_OMAP3ISP_AF: AF statistics data ready
+ * V4L2_EVENT_OMAP3ISP_HIST: Histogram statistics data ready
+ * V4L2_EVENT_OMAP3ISP_HS_VS: Horizontal/vertical synchronization detected
+ */
+
+#define V4L2_EVENT_OMAP3ISP_CLASS       (V4L2_EVENT_PRIVATE_START | 0x100)
+#define V4L2_EVENT_OMAP3ISP_AEWB        (V4L2_EVENT_OMAP3ISP_CLASS | 0x1)
+#define V4L2_EVENT_OMAP3ISP_AF          (V4L2_EVENT_OMAP3ISP_CLASS | 0x2)
+#define V4L2_EVENT_OMAP3ISP_HIST        (V4L2_EVENT_OMAP3ISP_CLASS | 0x3)
+#define V4L2_EVENT_OMAP3ISP_HS_VS       (V4L2_EVENT_OMAP3ISP_CLASS | 0x4)
+
+struct omap3isp_stat_event_status {
+        __u32 frame_number;
+        __u16 config_counter;
+        __u8 buf_err;
+};
+
+/* AE/AWB related structures and flags*/
+
+/* H3A Range Constants */
+#define OMAP3ISP_AEWB_MAX_SATURATION_LIM        1023
+#define OMAP3ISP_AEWB_MIN_WIN_H                 2
+#define OMAP3ISP_AEWB_MAX_WIN_H                 256
+#define OMAP3ISP_AEWB_MIN_WIN_W                 6
+#define OMAP3ISP_AEWB_MAX_WIN_W                 256
+#define OMAP3ISP_AEWB_MIN_WINVC                 1
+#define OMAP3ISP_AEWB_MIN_WINHC                 1
+#define OMAP3ISP_AEWB_MAX_WINVC                 128
+#define OMAP3ISP_AEWB_MAX_WINHC                 36
+#define OMAP3ISP_AEWB_MAX_WINSTART              4095
+#define OMAP3ISP_AEWB_MIN_SUB_INC               2
+#define OMAP3ISP_AEWB_MAX_SUB_INC               32
+#define OMAP3ISP_AEWB_MAX_BUF_SIZE              83600
+
+#define OMAP3ISP_AF_IIRSH_MIN                   0
+#define OMAP3ISP_AF_IIRSH_MAX                   4095
+#define OMAP3ISP_AF_PAXEL_HORIZONTAL_COUNT_MIN  1
+#define OMAP3ISP_AF_PAXEL_HORIZONTAL_COUNT_MAX  36
+#define OMAP3ISP_AF_PAXEL_VERTICAL_COUNT_MIN    1
+#define OMAP3ISP_AF_PAXEL_VERTICAL_COUNT_MAX    128
+#define OMAP3ISP_AF_PAXEL_INCREMENT_MIN         2
+#define OMAP3ISP_AF_PAXEL_INCREMENT_MAX         32
+#define OMAP3ISP_AF_PAXEL_HEIGHT_MIN            2
+#define OMAP3ISP_AF_PAXEL_HEIGHT_MAX            256
+#define OMAP3ISP_AF_PAXEL_WIDTH_MIN             16
+#define OMAP3ISP_AF_PAXEL_WIDTH_MAX             256
+#define OMAP3ISP_AF_PAXEL_HZSTART_MIN           1
+#define OMAP3ISP_AF_PAXEL_HZSTART_MAX           4095
+#define OMAP3ISP_AF_PAXEL_VTSTART_MIN           0
+#define OMAP3ISP_AF_PAXEL_VTSTART_MAX           4095
+#define OMAP3ISP_AF_THRESHOLD_MAX               255
+#define OMAP3ISP_AF_COEF_MAX                    4095
+#define OMAP3ISP_AF_PAXEL_SIZE                  48
+#define OMAP3ISP_AF_MAX_BUF_SIZE                221184
+
+/**
+ * struct omap3isp_h3a_aewb_config - AE AWB configuration reset values
+ * saturation_limit: Saturation limit.
+ * @win_height: Window Height. Range 2 - 256, even values only.
+ * @win_width: Window Width. Range 6 - 256, even values only.
+ * @ver_win_count: Vertical Window Count. Range 1 - 128.
+ * @hor_win_count: Horizontal Window Count. Range 1 - 36.
+ * @ver_win_start: Vertical Window Start. Range 0 - 4095.
+ * @hor_win_start: Horizontal Window Start. Range 0 - 4095.
+ * @blk_ver_win_start: Black Vertical Windows Start. Range 0 - 4095.
+ * @blk_win_height: Black Window Height. Range 2 - 256, even values only.
+ * @subsample_ver_inc: Subsample Vertical points increment Range 2 - 32, even
+ *                     values only.
+ * @subsample_hor_inc: Subsample Horizontal points increment Range 2 - 32, even
+ *                     values only.
+ * @alaw_enable: AEW ALAW EN flag.
+ */
+struct omap3isp_h3a_aewb_config {
+        /*
+         * Common fields.
+         * They should be the first ones and must be in the same order as in
+         * ispstat_generic_config struct.
+         */
+        __u32 buf_size;
+        __u16 config_counter;
+
+        /* Private fields */
+        __u16 saturation_limit;
+        __u16 win_height;
+        __u16 win_width;
+        __u16 ver_win_count;
+        __u16 hor_win_count;
+        __u16 ver_win_start;
+        __u16 hor_win_start;
+        __u16 blk_ver_win_start;
+        __u16 blk_win_height;
+        __u16 subsample_ver_inc;
+        __u16 subsample_hor_inc;
+        __u8 alaw_enable;
+};
+
+/**
+ * struct omap3isp_stat_data - Statistic data sent to or received from user
+ * @ts: Timestamp of returned framestats.
+ * @buf: Pointer to pass to user.
+ * @frame_number: Frame number of requested stats.
+ * @cur_frame: Current frame number being processed.
+ * @config_counter: Number of the configuration associated with the data.
+ */
+struct omap3isp_stat_data {
+        struct timeval ts;
+        void __user *buf;
+        __u32 buf_size;
+        __u16 frame_number;
+        __u16 cur_frame;
+        __u16 config_counter;
+};
+
+
+/* Histogram related structs */
+
+/* Flags for number of bins */
+#define OMAP3ISP_HIST_BINS_32           0
+#define OMAP3ISP_HIST_BINS_64           1
+#define OMAP3ISP_HIST_BINS_128          2
+#define OMAP3ISP_HIST_BINS_256          3
+
+/* Number of bins * 4 colors * 4-bytes word */
+#define OMAP3ISP_HIST_MEM_SIZE_BINS(n)  ((1 << ((n)+5))*4*4)
+
+#define OMAP3ISP_HIST_MEM_SIZE          1024
+#define OMAP3ISP_HIST_MIN_REGIONS       1
+#define OMAP3ISP_HIST_MAX_REGIONS       4
+#define OMAP3ISP_HIST_MAX_WB_GAIN       255
+#define OMAP3ISP_HIST_MIN_WB_GAIN       0
+#define OMAP3ISP_HIST_MAX_BIT_WIDTH     14
+#define OMAP3ISP_HIST_MIN_BIT_WIDTH     8
+#define OMAP3ISP_HIST_MAX_WG            4
+#define OMAP3ISP_HIST_MAX_BUF_SIZE      4096
+
+/* Source */
+#define OMAP3ISP_HIST_SOURCE_CCDC       0
+#define OMAP3ISP_HIST_SOURCE_MEM        1
+
+/* CFA pattern */
+#define OMAP3ISP_HIST_CFA_BAYER         0
+#define OMAP3ISP_HIST_CFA_FOVEONX3      1
+
+struct omap3isp_hist_region {
+        __u16 h_start;
+        __u16 h_end;
+        __u16 v_start;
+        __u16 v_end;
+};
+
+struct omap3isp_hist_config {
+        /*
+         * Common fields.
+         * They should be the first ones and must be in the same order as in
+         * ispstat_generic_config struct.
+         */
+        __u32 buf_size;
+        __u16 config_counter;
+
+        __u8 num_acc_frames;    /* Num of image frames to be processed and
+                                   accumulated for each histogram frame */
+        __u16 hist_bins;        /* number of bins: 32, 64, 128, or 256 */
+        __u8 cfa;               /* BAYER or FOVEON X3 */
+        __u8 wg[OMAP3ISP_HIST_MAX_WG];  /* White Balance Gain */
+        __u8 num_regions;       /* number of regions to be configured */
+        struct omap3isp_hist_region region[OMAP3ISP_HIST_MAX_REGIONS];
+};
+
+/* Auto Focus related structs */
+
+#define OMAP3ISP_AF_NUM_COEF            11
+
+enum omap3isp_h3a_af_fvmode {
+        OMAP3ISP_AF_MODE_SUMMED = 0,
+        OMAP3ISP_AF_MODE_PEAK = 1
+};
+
+/* Red, Green, and blue pixel location in the AF windows */
+enum omap3isp_h3a_af_rgbpos {
+        OMAP3ISP_AF_GR_GB_BAYER = 0,    /* GR and GB as Bayer pattern */
+        OMAP3ISP_AF_RG_GB_BAYER = 1,    /* RG and GB as Bayer pattern */
+        OMAP3ISP_AF_GR_BG_BAYER = 2,    /* GR and BG as Bayer pattern */
+        OMAP3ISP_AF_RG_BG_BAYER = 3,    /* RG and BG as Bayer pattern */
+        OMAP3ISP_AF_GG_RB_CUSTOM = 4,   /* GG and RB as custom pattern */
+        OMAP3ISP_AF_RB_GG_CUSTOM = 5    /* RB and GG as custom pattern */
+};
+
+/* Contains the information regarding the Horizontal Median Filter */
+struct omap3isp_h3a_af_hmf {
+        __u8 enable;    /* Status of Horizontal Median Filter */
+        __u8 threshold; /* Threshhold Value for Horizontal Median Filter */
+};
+
+/* Contains the information regarding the IIR Filters */
+struct omap3isp_h3a_af_iir {
+        __u16 h_start;                  /* IIR horizontal start */
+        __u16 coeff_set0[OMAP3ISP_AF_NUM_COEF]; /* Filter coefficient, set 0 */
+        __u16 coeff_set1[OMAP3ISP_AF_NUM_COEF]; /* Filter coefficient, set 1 */
+};
+
+/* Contains the information regarding the Paxels Structure in AF Engine */
+struct omap3isp_h3a_af_paxel {
+        __u16 h_start;  /* Horizontal Start Position */
+        __u16 v_start;  /* Vertical Start Position */
+        __u8 width;     /* Width of the Paxel */
+        __u8 height;    /* Height of the Paxel */
+        __u8 h_cnt;     /* Horizontal Count */
+        __u8 v_cnt;     /* vertical Count */
+        __u8 line_inc;  /* Line Increment */
+};
+
+/* Contains the parameters required for hardware set up of AF Engine */
+struct omap3isp_h3a_af_config {
+        /*
+         * Common fields.
+         * They should be the first ones and must be in the same order as in
+         * ispstat_generic_config struct.
+         */
+        __u32 buf_size;
+        __u16 config_counter;
+
+        struct omap3isp_h3a_af_hmf hmf;         /* HMF configurations */
+        struct omap3isp_h3a_af_iir iir;         /* IIR filter configurations */
+        struct omap3isp_h3a_af_paxel paxel;     /* Paxel parameters */
+        enum omap3isp_h3a_af_rgbpos rgb_pos;    /* RGB Positions */
+        enum omap3isp_h3a_af_fvmode fvmode;     /* Accumulator mode */
+        __u8 alaw_enable;                       /* AF ALAW status */
+};
+
+/* ISP CCDC structs */
+
+/* Abstraction layer CCDC configurations */
+#define OMAP3ISP_CCDC_ALAW              (1 << 0)
+#define OMAP3ISP_CCDC_LPF               (1 << 1)
+#define OMAP3ISP_CCDC_BLCLAMP           (1 << 2)
+#define OMAP3ISP_CCDC_BCOMP             (1 << 3)
+#define OMAP3ISP_CCDC_FPC               (1 << 4)
+#define OMAP3ISP_CCDC_CULL              (1 << 5)
+#define OMAP3ISP_CCDC_CONFIG_LSC        (1 << 7)
+#define OMAP3ISP_CCDC_TBL_LSC           (1 << 8)
+
+#define OMAP3ISP_RGB_MAX                3
+
+/* Enumeration constants for Alaw input width */
+enum omap3isp_alaw_ipwidth {
+        OMAP3ISP_ALAW_BIT12_3 = 0x3,
+        OMAP3ISP_ALAW_BIT11_2 = 0x4,
+        OMAP3ISP_ALAW_BIT10_1 = 0x5,
+        OMAP3ISP_ALAW_BIT9_0 = 0x6
+};
+
+/**
+ * struct omap3isp_ccdc_lsc_config - LSC configuration
+ * @offset: Table Offset of the gain table.
+ * @gain_mode_n: Vertical dimension of a paxel in LSC configuration.
+ * @gain_mode_m: Horizontal dimension of a paxel in LSC configuration.
+ * @gain_format: Gain table format.
+ * @fmtsph: Start pixel horizontal from start of the HS sync pulse.
+ * @fmtlnh: Number of pixels in horizontal direction to use for the data
+ *          reformatter.
+ * @fmtslv: Start line from start of VS sync pulse for the data reformatter.
+ * @fmtlnv: Number of lines in vertical direction for the data reformatter.
+ * @initial_x: X position, in pixels, of the first active pixel in reference
+ *             to the first active paxel. Must be an even number.
+ * @initial_y: Y position, in pixels, of the first active pixel in reference
+ *             to the first active paxel. Must be an even number.
+ * @size: Size of LSC gain table. Filled when loaded from userspace.
+ */
+struct omap3isp_ccdc_lsc_config {
+        __u16 offset;
+        __u8 gain_mode_n;
+        __u8 gain_mode_m;
+        __u8 gain_format;
+        __u16 fmtsph;
+        __u16 fmtlnh;
+        __u16 fmtslv;
+        __u16 fmtlnv;
+        __u8 initial_x;
+        __u8 initial_y;
+        __u32 size;
+};
+
+/**
+ * struct omap3isp_ccdc_bclamp - Optical & Digital black clamp subtract
+ * @obgain: Optical black average gain.
+ * @obstpixel: Start Pixel w.r.t. HS pulse in Optical black sample.
+ * @oblines: Optical Black Sample lines.
+ * @oblen: Optical Black Sample Length.
+ * @dcsubval: Digital Black Clamp subtract value.
+ */
+struct omap3isp_ccdc_bclamp {
+        __u8 obgain;
+        __u8 obstpixel;
+        __u8 oblines;
+        __u8 oblen;
+        __u16 dcsubval;
+};
+
+/**
+ * struct omap3isp_ccdc_fpc - Faulty Pixels Correction
+ * @fpnum: Number of faulty pixels to be corrected in the frame.
+ * @fpcaddr: Memory address of the FPC Table
+ */
+struct omap3isp_ccdc_fpc {
+        __u16 fpnum;
+        __u32 fpcaddr;
+};
+
+/**
+ * struct omap3isp_ccdc_blcomp - Black Level Compensation parameters
+ * @b_mg: B/Mg pixels. 2's complement. -128 to +127.
+ * @gb_g: Gb/G pixels. 2's complement. -128 to +127.
+ * @gr_cy: Gr/Cy pixels. 2's complement. -128 to +127.
+ * @r_ye: R/Ye pixels. 2's complement. -128 to +127.
+ */
+struct omap3isp_ccdc_blcomp {
+        __u8 b_mg;
+        __u8 gb_g;
+        __u8 gr_cy;
+        __u8 r_ye;
+};
+
+/**
+ * omap3isp_ccdc_culling - Culling parameters
+ * @v_pattern: Vertical culling pattern.
+ * @h_odd: Horizontal Culling pattern for odd lines.
+ * @h_even: Horizontal Culling pattern for even lines.
+ */
+struct omap3isp_ccdc_culling {
+        __u8 v_pattern;
+        __u16 h_odd;
+        __u16 h_even;
+};
+
+/**
+ * omap3isp_ccdc_update_config - CCDC configuration
+ * @update: Specifies which CCDC registers should be updated.
+ * @flag: Specifies which CCDC functions should be enabled.
+ * @alawip: Enable/Disable A-Law compression.
+ * @bclamp: Black clamp control register.
+ * @blcomp: Black level compensation value for RGrGbB Pixels. 2's complement.
+ * @fpc: Number of faulty pixels corrected in the frame, address of FPC table.
+ * @cull: Cull control register.
+ * @lsc: Pointer to LSC gain table.
+ */
+struct omap3isp_ccdc_update_config {
+        __u16 update;
+        __u16 flag;
+        enum omap3isp_alaw_ipwidth alawip;
+        struct omap3isp_ccdc_bclamp __user *bclamp;
+        struct omap3isp_ccdc_blcomp __user *blcomp;
+        struct omap3isp_ccdc_fpc __user *fpc;
+        struct omap3isp_ccdc_lsc_config __user *lsc_cfg;
+        struct omap3isp_ccdc_culling __user *cull;
+        __u8 __user *lsc;
+};
+
+/* Preview configurations */
+#define OMAP3ISP_PREV_LUMAENH           (1 << 0)
+#define OMAP3ISP_PREV_INVALAW           (1 << 1)
+#define OMAP3ISP_PREV_HRZ_MED           (1 << 2)
+#define OMAP3ISP_PREV_CFA               (1 << 3)
+#define OMAP3ISP_PREV_CHROMA_SUPP       (1 << 4)
+#define OMAP3ISP_PREV_WB                (1 << 5)
+#define OMAP3ISP_PREV_BLKADJ            (1 << 6)
+#define OMAP3ISP_PREV_RGB2RGB           (1 << 7)
+#define OMAP3ISP_PREV_COLOR_CONV        (1 << 8)
+#define OMAP3ISP_PREV_YC_LIMIT          (1 << 9)
+#define OMAP3ISP_PREV_DEFECT_COR        (1 << 10)
+#define OMAP3ISP_PREV_GAMMABYPASS       (1 << 11)
+#define OMAP3ISP_PREV_DRK_FRM_CAPTURE   (1 << 12)
+#define OMAP3ISP_PREV_DRK_FRM_SUBTRACT  (1 << 13)
+#define OMAP3ISP_PREV_LENS_SHADING      (1 << 14)
+#define OMAP3ISP_PREV_NF                (1 << 15)
+#define OMAP3ISP_PREV_GAMMA             (1 << 16)
+
+#define OMAP3ISP_PREV_NF_TBL_SIZE       64
+#define OMAP3ISP_PREV_CFA_TBL_SIZE      576
+#define OMAP3ISP_PREV_GAMMA_TBL_SIZE    1024
+#define OMAP3ISP_PREV_YENH_TBL_SIZE     128
+
+#define OMAP3ISP_PREV_DETECT_CORRECT_CHANNELS   4
+
+/**
+ * struct omap3isp_prev_hmed - Horizontal Median Filter
+ * @odddist: Distance between consecutive pixels of same color in the odd line.
+ * @evendist: Distance between consecutive pixels of same color in the even
+ *            line.
+ * @thres: Horizontal median filter threshold.
+ */
+struct omap3isp_prev_hmed {
+        __u8 odddist;
+        __u8 evendist;
+        __u8 thres;
+};
+
+/*
+ * Enumeration for CFA Formats supported by preview
+ */
+enum omap3isp_cfa_fmt {
+        OMAP3ISP_CFAFMT_BAYER,
+        OMAP3ISP_CFAFMT_SONYVGA,
+        OMAP3ISP_CFAFMT_RGBFOVEON,
+        OMAP3ISP_CFAFMT_DNSPL,
+        OMAP3ISP_CFAFMT_HONEYCOMB,
+        OMAP3ISP_CFAFMT_RRGGBBFOVEON
+};
+
+/**
+ * struct omap3isp_prev_cfa - CFA Interpolation
+ * @format: CFA Format Enum value supported by preview.
+ * @gradthrs_vert: CFA Gradient Threshold - Vertical.
+ * @gradthrs_horz: CFA Gradient Threshold - Horizontal.
+ * @table: Pointer to the CFA table.
+ */
+struct omap3isp_prev_cfa {
+        enum omap3isp_cfa_fmt format;
+        __u8 gradthrs_vert;
+        __u8 gradthrs_horz;
+        __u32 table[OMAP3ISP_PREV_CFA_TBL_SIZE];
+};
+
+/**
+ * struct omap3isp_prev_csup - Chrominance Suppression
+ * @gain: Gain.
+ * @thres: Threshold.
+ * @hypf_en: Flag to enable/disable the High Pass Filter.
+ */
+struct omap3isp_prev_csup {
+        __u8 gain;
+        __u8 thres;
+        __u8 hypf_en;
+};
+
+/**
+ * struct omap3isp_prev_wbal - White Balance
+ * @dgain: Digital gain (U10Q8).
+ * @coef3: White balance gain - COEF 3 (U8Q5).
+ * @coef2: White balance gain - COEF 2 (U8Q5).
+ * @coef1: White balance gain - COEF 1 (U8Q5).
+ * @coef0: White balance gain - COEF 0 (U8Q5).
+ */
+struct omap3isp_prev_wbal {
+        __u16 dgain;
+        __u8 coef3;
+        __u8 coef2;
+        __u8 coef1;
+        __u8 coef0;
+};
+
+/**
+ * struct omap3isp_prev_blkadj - Black Level Adjustment
+ * @red: Black level offset adjustment for Red in 2's complement format
+ * @green: Black level offset adjustment for Green in 2's complement format
+ * @blue: Black level offset adjustment for Blue in 2's complement format
+ */
+struct omap3isp_prev_blkadj {
+        /*Black level offset adjustment for Red in 2's complement format */
+        __u8 red;
+        /*Black level offset adjustment for Green in 2's complement format */
+        __u8 green;
+        /* Black level offset adjustment for Blue in 2's complement format */
+        __u8 blue;
+};
+
+/**
+ * struct omap3isp_prev_rgbtorgb - RGB to RGB Blending
+ * @matrix: Blending values(S12Q8 format)
+ *              [RR] [GR] [BR]
+ *              [RG] [GG] [BG]
+ *              [RB] [GB] [BB]
+ * @offset: Blending offset value for R,G,B in 2's complement integer format.
+ */
+struct omap3isp_prev_rgbtorgb {
+        __u16 matrix[OMAP3ISP_RGB_MAX][OMAP3ISP_RGB_MAX];
+        __u16 offset[OMAP3ISP_RGB_MAX];
+};
+
+/**
+ * struct omap3isp_prev_csc - Color Space Conversion from RGB-YCbYCr
+ * @matrix: Color space conversion coefficients(S10Q8)
+ *              [CSCRY]  [CSCGY]  [CSCBY]
+ *              [CSCRCB] [CSCGCB] [CSCBCB]
+ *              [CSCRCR] [CSCGCR] [CSCBCR]
+ * @offset: CSC offset values for Y offset, CB offset and CR offset respectively
+ */
+struct omap3isp_prev_csc {
+        __u16 matrix[OMAP3ISP_RGB_MAX][OMAP3ISP_RGB_MAX];
+        __s16 offset[OMAP3ISP_RGB_MAX];
+};
+
+/**
+ * struct omap3isp_prev_yclimit - Y, C Value Limit
+ * @minC: Minimum C value
+ * @maxC: Maximum C value
+ * @minY: Minimum Y value
+ * @maxY: Maximum Y value
+ */
+struct omap3isp_prev_yclimit {
+        __u8 minC;
+        __u8 maxC;
+        __u8 minY;
+        __u8 maxY;
+};
+
+/**
+ * struct omap3isp_prev_dcor - Defect correction
+ * @couplet_mode_en: Flag to enable or disable the couplet dc Correction in NF
+ * @detect_correct: Thresholds for correction bit 0:10 detect 16:25 correct
+ */
+struct omap3isp_prev_dcor {
+        __u8 couplet_mode_en;
+        __u32 detect_correct[OMAP3ISP_PREV_DETECT_CORRECT_CHANNELS];
+};
+
+/**
+ * struct omap3isp_prev_nf - Noise Filter
+ * @spread: Spread value to be used in Noise Filter
+ * @table: Pointer to the Noise Filter table
+ */
+struct omap3isp_prev_nf {
+        __u8 spread;
+        __u32 table[OMAP3ISP_PREV_NF_TBL_SIZE];
+};
+
+/**
+ * struct omap3isp_prev_gtables - Gamma correction tables
+ * @red: Array for red gamma table.
+ * @green: Array for green gamma table.
+ * @blue: Array for blue gamma table.
+ */
+struct omap3isp_prev_gtables {
+        __u32 red[OMAP3ISP_PREV_GAMMA_TBL_SIZE];
+        __u32 green[OMAP3ISP_PREV_GAMMA_TBL_SIZE];
+        __u32 blue[OMAP3ISP_PREV_GAMMA_TBL_SIZE];
+};
+
+/**
+ * struct omap3isp_prev_luma - Luma enhancement
+ * @table: Array for luma enhancement table.
+ */
+struct omap3isp_prev_luma {
+        __u32 table[OMAP3ISP_PREV_YENH_TBL_SIZE];
+};
+
+/**
+ * struct omap3isp_prev_update_config - Preview engine configuration (user)
+ * @update: Specifies which ISP Preview registers should be updated.
+ * @flag: Specifies which ISP Preview functions should be enabled.
+ * @shading_shift: 3bit value of shift used in shading compensation.
+ * @luma: Pointer to luma enhancement structure.
+ * @hmed: Pointer to structure containing the odd and even distance.
+ *        between the pixels in the image along with the filter threshold.
+ * @cfa: Pointer to structure containing the CFA interpolation table, CFA.
+ *       format in the image, vertical and horizontal gradient threshold.
+ * @csup: Pointer to Structure for Chrominance Suppression coefficients.
+ * @wbal: Pointer to structure for White Balance.
+ * @blkadj: Pointer to structure for Black Adjustment.
+ * @rgb2rgb: Pointer to structure for RGB to RGB Blending.
+ * @csc: Pointer to structure for Color Space Conversion from RGB-YCbYCr.
+ * @yclimit: Pointer to structure for Y, C Value Limit.
+ * @dcor: Pointer to structure for defect correction.
+ * @nf: Pointer to structure for Noise Filter
+ * @gamma: Pointer to gamma structure.
+ */
+struct omap3isp_prev_update_config {
+        __u32 update;
+        __u32 flag;
+        __u32 shading_shift;
+        struct omap3isp_prev_luma __user *luma;
+        struct omap3isp_prev_hmed __user *hmed;
+        struct omap3isp_prev_cfa __user *cfa;
+        struct omap3isp_prev_csup __user *csup;
+        struct omap3isp_prev_wbal __user *wbal;
+        struct omap3isp_prev_blkadj __user *blkadj;
+        struct omap3isp_prev_rgbtorgb __user *rgb2rgb;
+        struct omap3isp_prev_csc __user *csc;
+        struct omap3isp_prev_yclimit __user *yclimit;
+        struct omap3isp_prev_dcor __user *dcor;
+        struct omap3isp_prev_nf __user *nf;
+        struct omap3isp_prev_gtables __user *gamma;
+};
+
+#endif  /* OMAP3_ISP_USER_H */
diff --git a/include/linux/v4l2-mediabus.h b/include/linux/v4l2-mediabus.h
new file mode 100644
index 000000000000..7054a7a8065e
--- /dev/null
+++ b/include/linux/v4l2-mediabus.h
@@ -0,0 +1,108 @@
+/*
+ * Media Bus API header
+ *
+ * Copyright (C) 2009, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * 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.
+ */
+
+#ifndef __LINUX_V4L2_MEDIABUS_H
+#define __LINUX_V4L2_MEDIABUS_H
+
+#include <linux/types.h>
+#include <linux/videodev2.h>
+
+/*
+ * These pixel codes uniquely identify data formats on the media bus. Mostly
+ * they correspond to similarly named V4L2_PIX_FMT_* formats, format 0 is
+ * reserved, V4L2_MBUS_FMT_FIXED shall be used by host-client pairs, where the
+ * data format is fixed. Additionally, "2X8" means that one pixel is transferred
+ * in two 8-bit samples, "BE" or "LE" specify in which order those samples are
+ * transferred over the bus: "LE" means that the least significant bits are
+ * transferred first, "BE" means that the most significant bits are transferred
+ * first, and "PADHI" and "PADLO" define which bits - low or high, in the
+ * incomplete high byte, are filled with padding bits.
+ *
+ * The pixel codes are grouped by type, bus_width, bits per component, samples
+ * per pixel and order of subsamples. Numerical values are sorted using generic
+ * numerical sort order (8 thus comes before 10).
+ *
+ * As their value can't change when a new pixel code is inserted in the
+ * enumeration, the pixel codes are explicitly given a numerical value. The next
+ * free values for each category are listed below, update them when inserting
+ * new pixel codes.
+ */
+enum v4l2_mbus_pixelcode {
+        V4L2_MBUS_FMT_FIXED = 0x0001,
+
+        /* RGB - next is 0x1009 */
+        V4L2_MBUS_FMT_RGB444_2X8_PADHI_BE = 0x1001,
+        V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE = 0x1002,
+        V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE = 0x1003,
+        V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE = 0x1004,
+        V4L2_MBUS_FMT_BGR565_2X8_BE = 0x1005,
+        V4L2_MBUS_FMT_BGR565_2X8_LE = 0x1006,
+        V4L2_MBUS_FMT_RGB565_2X8_BE = 0x1007,
+        V4L2_MBUS_FMT_RGB565_2X8_LE = 0x1008,
+
+        /* YUV (including grey) - next is 0x2013 */
+        V4L2_MBUS_FMT_Y8_1X8 = 0x2001,
+        V4L2_MBUS_FMT_UYVY8_1_5X8 = 0x2002,
+        V4L2_MBUS_FMT_VYUY8_1_5X8 = 0x2003,
+        V4L2_MBUS_FMT_YUYV8_1_5X8 = 0x2004,
+        V4L2_MBUS_FMT_YVYU8_1_5X8 = 0x2005,
+        V4L2_MBUS_FMT_UYVY8_2X8 = 0x2006,
+        V4L2_MBUS_FMT_VYUY8_2X8 = 0x2007,
+        V4L2_MBUS_FMT_YUYV8_2X8 = 0x2008,
+        V4L2_MBUS_FMT_YVYU8_2X8 = 0x2009,
+        V4L2_MBUS_FMT_Y10_1X10 = 0x200a,
+        V4L2_MBUS_FMT_YUYV10_2X10 = 0x200b,
+        V4L2_MBUS_FMT_YVYU10_2X10 = 0x200c,
+        V4L2_MBUS_FMT_UYVY8_1X16 = 0x200f,
+        V4L2_MBUS_FMT_VYUY8_1X16 = 0x2010,
+        V4L2_MBUS_FMT_YUYV8_1X16 = 0x2011,
+        V4L2_MBUS_FMT_YVYU8_1X16 = 0x2012,
+        V4L2_MBUS_FMT_YUYV10_1X20 = 0x200d,
+        V4L2_MBUS_FMT_YVYU10_1X20 = 0x200e,
+
+        /* Bayer - next is 0x3013 */
+        V4L2_MBUS_FMT_SBGGR8_1X8 = 0x3001,
+        V4L2_MBUS_FMT_SGRBG8_1X8 = 0x3002,
+        V4L2_MBUS_FMT_SBGGR10_DPCM8_1X8 = 0x300b,
+        V4L2_MBUS_FMT_SGBRG10_DPCM8_1X8 = 0x300c,
+        V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8 = 0x3009,
+        V4L2_MBUS_FMT_SRGGB10_DPCM8_1X8 = 0x300d,
+        V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE = 0x3003,
+        V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE = 0x3004,
+        V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE = 0x3005,
+        V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE = 0x3006,
+        V4L2_MBUS_FMT_SBGGR10_1X10 = 0x3007,
+        V4L2_MBUS_FMT_SGBRG10_1X10 = 0x300e,
+        V4L2_MBUS_FMT_SGRBG10_1X10 = 0x300a,
+        V4L2_MBUS_FMT_SRGGB10_1X10 = 0x300f,
+        V4L2_MBUS_FMT_SBGGR12_1X12 = 0x3008,
+        V4L2_MBUS_FMT_SGBRG12_1X12 = 0x3010,
+        V4L2_MBUS_FMT_SGRBG12_1X12 = 0x3011,
+        V4L2_MBUS_FMT_SRGGB12_1X12 = 0x3012,
+};
+
+/**
+ * struct v4l2_mbus_framefmt - frame format on the media bus
+ * @width:      frame width
+ * @height:     frame height
+ * @code:       data format code (from enum v4l2_mbus_pixelcode)
+ * @field:      used interlacing type (from enum v4l2_field)
+ * @colorspace: colorspace of the data (from enum v4l2_colorspace)
+ */
+struct v4l2_mbus_framefmt {
+        __u32                   width;
+        __u32                   height;
+        __u32                   code;
+        __u32                   field;
+        __u32                   colorspace;
+        __u32                   reserved[7];
+};
+
+#endif
diff --git a/include/linux/v4l2-subdev.h b/include/linux/v4l2-subdev.h
new file mode 100644
index 000000000000..ed29cbbebfef
--- /dev/null
+++ b/include/linux/v4l2-subdev.h
@@ -0,0 +1,141 @@
+/*
+ * V4L2 subdev userspace API
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __LINUX_V4L2_SUBDEV_H
+#define __LINUX_V4L2_SUBDEV_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <linux/v4l2-mediabus.h>
+
+/**
+ * enum v4l2_subdev_format_whence - Media bus format type
+ * @V4L2_SUBDEV_FORMAT_TRY: try format, for negotiation only
+ * @V4L2_SUBDEV_FORMAT_ACTIVE: active format, applied to the device
+ */
+enum v4l2_subdev_format_whence {
+        V4L2_SUBDEV_FORMAT_TRY = 0,
+        V4L2_SUBDEV_FORMAT_ACTIVE = 1,
+};
+
+/**
+ * struct v4l2_subdev_format - Pad-level media bus format
+ * @which: format type (from enum v4l2_subdev_format_whence)
+ * @pad: pad number, as reported by the media API
+ * @format: media bus format (format code and frame size)
+ */
+struct v4l2_subdev_format {
+        __u32 which;
+        __u32 pad;
+        struct v4l2_mbus_framefmt format;
+        __u32 reserved[8];
+};
+
+/**
+ * struct v4l2_subdev_crop - Pad-level crop settings
+ * @which: format type (from enum v4l2_subdev_format_whence)
+ * @pad: pad number, as reported by the media API
+ * @rect: pad crop rectangle boundaries
+ */
+struct v4l2_subdev_crop {
+        __u32 which;
+        __u32 pad;
+        struct v4l2_rect rect;
+        __u32 reserved[8];
+};
+
+/**
+ * struct v4l2_subdev_mbus_code_enum - Media bus format enumeration
+ * @pad: pad number, as reported by the media API
+ * @index: format index during enumeration
+ * @code: format code (from enum v4l2_mbus_pixelcode)
+ */
+struct v4l2_subdev_mbus_code_enum {
+        __u32 pad;
+        __u32 index;
+        __u32 code;
+        __u32 reserved[9];
+};
+
+/**
+ * struct v4l2_subdev_frame_size_enum - Media bus format enumeration
+ * @pad: pad number, as reported by the media API
+ * @index: format index during enumeration
+ * @code: format code (from enum v4l2_mbus_pixelcode)
+ */
+struct v4l2_subdev_frame_size_enum {
+        __u32 index;
+        __u32 pad;
+        __u32 code;
+        __u32 min_width;
+        __u32 max_width;
+        __u32 min_height;
+        __u32 max_height;
+        __u32 reserved[9];
+};
+
+/**
+ * struct v4l2_subdev_frame_interval - Pad-level frame rate
+ * @pad: pad number, as reported by the media API
+ * @interval: frame interval in seconds
+ */
+struct v4l2_subdev_frame_interval {
+        __u32 pad;
+        struct v4l2_fract interval;
+        __u32 reserved[9];
+};
+
+/**
+ * struct v4l2_subdev_frame_interval_enum - Frame interval enumeration
+ * @pad: pad number, as reported by the media API
+ * @index: frame interval index during enumeration
+ * @code: format code (from enum v4l2_mbus_pixelcode)
+ * @width: frame width in pixels
+ * @height: frame height in pixels
+ * @interval: frame interval in seconds
+ */
+struct v4l2_subdev_frame_interval_enum {
+        __u32 index;
+        __u32 pad;
+        __u32 code;
+        __u32 width;
+        __u32 height;
+        struct v4l2_fract interval;
+        __u32 reserved[9];
+};
+
+#define VIDIOC_SUBDEV_G_FMT     _IOWR('V',  4, struct v4l2_subdev_format)
+#define VIDIOC_SUBDEV_S_FMT     _IOWR('V',  5, struct v4l2_subdev_format)
+#define VIDIOC_SUBDEV_G_FRAME_INTERVAL \
+                        _IOWR('V', 21, struct v4l2_subdev_frame_interval)
+#define VIDIOC_SUBDEV_S_FRAME_INTERVAL \
+                        _IOWR('V', 22, struct v4l2_subdev_frame_interval)
+#define VIDIOC_SUBDEV_ENUM_MBUS_CODE \
+                        _IOWR('V',  2, struct v4l2_subdev_mbus_code_enum)
+#define VIDIOC_SUBDEV_ENUM_FRAME_SIZE \
+                        _IOWR('V', 74, struct v4l2_subdev_frame_size_enum)
+#define VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL \
+                        _IOWR('V', 75, struct v4l2_subdev_frame_interval_enum)
+#define VIDIOC_SUBDEV_G_CROP    _IOWR('V', 59, struct v4l2_subdev_crop)
+#define VIDIOC_SUBDEV_S_CROP    _IOWR('V', 60, struct v4l2_subdev_crop)
+
+#endif
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 5f6f47044abf..aa6c393b7ae9 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -70,6 +70,7 @@
  * Moved from videodev.h
  */
 #define VIDEO_MAX_FRAME               32
+#define VIDEO_MAX_PLANES               8
 
 #ifndef __KERNEL__
 
@@ -157,9 +158,23 @@ enum v4l2_buf_type {
         /* Experimental */
         V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
 #endif
+        V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
+        V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
         V4L2_BUF_TYPE_PRIVATE              = 0x80,
 };
 
+#define V4L2_TYPE_IS_MULTIPLANAR(type)                  \
+        ((type) == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE   \
+         || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+
+#define V4L2_TYPE_IS_OUTPUT(type)                               \
+        ((type) == V4L2_BUF_TYPE_VIDEO_OUTPUT                   \
+         || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE         \
+         || (type) == V4L2_BUF_TYPE_VIDEO_OVERLAY               \
+         || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY        \
+         || (type) == V4L2_BUF_TYPE_VBI_OUTPUT                  \
+         || (type) == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
+
 enum v4l2_tuner_type {
         V4L2_TUNER_RADIO             = 1,
         V4L2_TUNER_ANALOG_TV         = 2,
@@ -245,6 +260,11 @@ struct v4l2_capability {
 #define V4L2_CAP_HW_FREQ_SEEK           0x00000400  /* Can do hardware frequency seek  */
 #define V4L2_CAP_RDS_OUTPUT             0x00000800  /* Is an RDS encoder */
 
+/* Is a video capture device that supports multiplanar formats */
+#define V4L2_CAP_VIDEO_CAPTURE_MPLANE   0x00001000
+/* Is a video output device that supports multiplanar formats */
+#define V4L2_CAP_VIDEO_OUTPUT_MPLANE    0x00002000
+
 #define V4L2_CAP_TUNER                  0x00010000  /* has a tuner */
 #define V4L2_CAP_AUDIO                  0x00020000  /* has audio support */
 #define V4L2_CAP_RADIO                  0x00040000  /* is a radio device */
@@ -319,6 +339,13 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_NV16    v4l2_fourcc('N', 'V', '1', '6') /* 16  Y/CbCr 4:2:2  */
 #define V4L2_PIX_FMT_NV61    v4l2_fourcc('N', 'V', '6', '1') /* 16  Y/CrCb 4:2:2  */
 
+/* two non contiguous planes - one Y, one Cr + Cb interleaved  */
+#define V4L2_PIX_FMT_NV12M   v4l2_fourcc('N', 'M', '1', '2') /* 12  Y/CbCr 4:2:0  */
+#define V4L2_PIX_FMT_NV12MT  v4l2_fourcc('T', 'M', '1', '2') /* 12  Y/CbCr 4:2:0 64x32 macroblocks */
+
+/* three non contiguous planes - Y, Cb, Cr */
+#define V4L2_PIX_FMT_YUV420M v4l2_fourcc('Y', 'M', '1', '2') /* 12  YUV420 planar */
+
 /* Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm */
 #define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B', 'A', '8', '1') /*  8  BGBG.. GRGR.. */
 #define V4L2_PIX_FMT_SGBRG8  v4l2_fourcc('G', 'B', 'R', 'G') /*  8  GBGB.. RGRG.. */
@@ -328,6 +355,10 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_SGBRG10 v4l2_fourcc('G', 'B', '1', '0') /* 10  GBGB.. RGRG.. */
 #define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0') /* 10  GRGR.. BGBG.. */
 #define V4L2_PIX_FMT_SRGGB10 v4l2_fourcc('R', 'G', '1', '0') /* 10  RGRG.. GBGB.. */
+#define V4L2_PIX_FMT_SBGGR12 v4l2_fourcc('B', 'G', '1', '2') /* 12  BGBG.. GRGR.. */
+#define V4L2_PIX_FMT_SGBRG12 v4l2_fourcc('G', 'B', '1', '2') /* 12  GBGB.. RGRG.. */
+#define V4L2_PIX_FMT_SGRBG12 v4l2_fourcc('B', 'A', '1', '2') /* 12  GRGR.. BGBG.. */
+#define V4L2_PIX_FMT_SRGGB12 v4l2_fourcc('R', 'G', '1', '2') /* 12  RGRG.. GBGB.. */
         /* 10bit raw bayer DPCM compressed to 8 bits */
 #define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0')
         /*
@@ -365,6 +396,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_TM6000   v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */
 #define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
 #define V4L2_PIX_FMT_KONICA420  v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
+#define V4L2_PIX_FMT_JPGL       v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -517,6 +549,62 @@ struct v4l2_requestbuffers {
         __u32                   reserved[2];
 };
 
+/**
+ * struct v4l2_plane - plane info for multi-planar buffers
+ * @bytesused:          number of bytes occupied by data in the plane (payload)
+ * @length:             size of this plane (NOT the payload) in bytes
+ * @mem_offset:         when memory in the associated struct v4l2_buffer is
+ *                      V4L2_MEMORY_MMAP, equals the offset from the start of
+ *                      the device memory for this plane (or is a "cookie" that
+ *                      should be passed to mmap() called on the video node)
+ * @userptr:            when memory is V4L2_MEMORY_USERPTR, a userspace pointer
+ *                      pointing to this plane
+ * @data_offset:        offset in the plane to the start of data; usually 0,
+ *                      unless there is a header in front of the data
+ *
+ * Multi-planar buffers consist of one or more planes, e.g. an YCbCr buffer
+ * with two planes can have one plane for Y, and another for interleaved CbCr
+ * components. Each plane can reside in a separate memory buffer, or even in
+ * a completely separate memory node (e.g. in embedded devices).
+ */
+struct v4l2_plane {
+        __u32                   bytesused;
+        __u32                   length;
+        union {
+                __u32           mem_offset;
+                unsigned long   userptr;
+        } m;
+        __u32                   data_offset;
+        __u32                   reserved[11];
+};
+
+/**
+ * struct v4l2_buffer - video buffer info
+ * @index:      id number of the buffer
+ * @type:       buffer type (type == *_MPLANE for multiplanar buffers)
+ * @bytesused:  number of bytes occupied by data in the buffer (payload);
+ *              unused (set to 0) for multiplanar buffers
+ * @flags:      buffer informational flags
+ * @field:      field order of the image in the buffer
+ * @timestamp:  frame timestamp
+ * @timecode:   frame timecode
+ * @sequence:   sequence count of this frame
+ * @memory:     the method, in which the actual video data is passed
+ * @offset:     for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP;
+ *              offset from the start of the device memory for this plane,
+ *              (or a "cookie" that should be passed to mmap() as offset)
+ * @userptr:    for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR;
+ *              a userspace pointer pointing to this buffer
+ * @planes:     for multiplanar buffers; userspace pointer to the array of plane
+ *              info structs for this buffer
+ * @length:     size in bytes of the buffer (NOT its payload) for single-plane
+ *              buffers (when type != *_MPLANE); number of elements in the
+ *              planes array for multi-plane buffers
+ * @input:      input number from which the video data has has been captured
+ *
+ * Contains data exchanged by application and driver using one of the Streaming
+ * I/O methods.
+ */
 struct v4l2_buffer {
         __u32                   index;
         enum v4l2_buf_type      type;
@@ -532,6 +620,7 @@ struct v4l2_buffer {
         union {
                 __u32           offset;
                 unsigned long   userptr;
+                struct v4l2_plane *planes;
         } m;
         __u32                   length;
         __u32                   input;
@@ -1622,12 +1711,56 @@ struct v4l2_mpeg_vbi_fmt_ivtv {
  *      A G G R E G A T E   S T R U C T U R E S
  */
 
-/*      Stream data format
+/**
+ * struct v4l2_plane_pix_format - additional, per-plane format definition
+ * @sizeimage:          maximum size in bytes required for data, for which
+ *                      this plane will be used
+ * @bytesperline:       distance in bytes between the leftmost pixels in two
+ *                      adjacent lines
+ */
+struct v4l2_plane_pix_format {
+        __u32           sizeimage;
+        __u16           bytesperline;
+        __u16           reserved[7];
+} __attribute__ ((packed));
+
+/**
+ * struct v4l2_pix_format_mplane - multiplanar format definition
+ * @width:              image width in pixels
+ * @height:             image height in pixels
+ * @pixelformat:        little endian four character code (fourcc)
+ * @field:              field order (for interlaced video)
+ * @colorspace:         supplemental to pixelformat
+ * @plane_fmt:          per-plane information
+ * @num_planes:         number of planes for this format
+ */
+struct v4l2_pix_format_mplane {
+        __u32                           width;
+        __u32                           height;
+        __u32                           pixelformat;
+        enum v4l2_field                 field;
+        enum v4l2_colorspace            colorspace;
+
+        struct v4l2_plane_pix_format    plane_fmt[VIDEO_MAX_PLANES];
+        __u8                            num_planes;
+        __u8                            reserved[11];
+} __attribute__ ((packed));
+
+/**
+ * struct v4l2_format - stream data format
+ * @type:       type of the data stream
+ * @pix:        definition of an image format
+ * @pix_mp:     definition of a multiplanar image format
+ * @win:        definition of an overlaid image
+ * @vbi:        raw VBI capture or output parameters
+ * @sliced:     sliced VBI capture or output parameters
+ * @raw_data:   placeholder for future extensions and custom formats
  */
 struct v4l2_format {
         enum v4l2_buf_type type;
         union {
                 struct v4l2_pix_format          pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
+                struct v4l2_pix_format_mplane   pix_mp;  /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
                 struct v4l2_window              win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
                 struct v4l2_vbi_format          vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
                 struct v4l2_sliced_vbi_format   sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
@@ -1635,7 +1768,6 @@ struct v4l2_format {
         } fmt;
 };
 
-
 /*      Stream type-dependent parameters
  */
 struct v4l2_streamparm {
@@ -1808,16 +1940,6 @@ struct v4l2_dbg_chip_ident {
 /* Reminder: when adding new ioctls please add support for them to
    drivers/media/video/v4l2-compat-ioctl32.c as well! */
 
-#ifdef __OLD_VIDIOC_
-/* for compatibility, will go away some day */
-#define VIDIOC_OVERLAY_OLD      _IOWR('V', 14, int)
-#define VIDIOC_S_PARM_OLD        _IOW('V', 22, struct v4l2_streamparm)
-#define VIDIOC_S_CTRL_OLD        _IOW('V', 28, struct v4l2_control)
-#define VIDIOC_G_AUDIO_OLD      _IOWR('V', 33, struct v4l2_audio)
-#define VIDIOC_G_AUDOUT_OLD     _IOWR('V', 49, struct v4l2_audioout)
-#define VIDIOC_CROPCAP_OLD       _IOR('V', 58, struct v4l2_cropcap)
-#endif
-
 #define BASE_VIDIOC_PRIVATE     192             /* 192-255 are private */
 
 #endif /* __LINUX_VIDEODEV2_H */
diff --git a/include/media/media-device.h b/include/media/media-device.h
new file mode 100644
index 000000000000..6a27d916c250
--- /dev/null
+++ b/include/media/media-device.h
@@ -0,0 +1,95 @@
+/*
+ * Media device
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MEDIA_DEVICE_H
+#define _MEDIA_DEVICE_H
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+
+#include <media/media-devnode.h>
+#include <media/media-entity.h>
+
+/**
+ * struct media_device - Media device
+ * @dev:        Parent device
+ * @devnode:    Media device node
+ * @model:      Device model name
+ * @serial:     Device serial number (optional)
+ * @bus_info:   Unique and stable device location identifier
+ * @hw_revision: Hardware device revision
+ * @driver_version: Device driver version
+ * @entity_id:  ID of the next entity to be registered
+ * @entities:   List of registered entities
+ * @lock:       Entities list lock
+ * @graph_mutex: Entities graph operation lock
+ *
+ * This structure represents an abstract high-level media device. It allows easy
+ * access to entities and provides basic media device-level support. The
+ * structure can be allocated directly or embedded in a larger structure.
+ *
+ * The parent @dev is a physical device. It must be set before registering the
+ * media device.
+ *
+ * @model is a descriptive model name exported through sysfs. It doesn't have to
+ * be unique.
+ */
+struct media_device {
+        /* dev->driver_data points to this struct. */
+        struct device *dev;
+        struct media_devnode devnode;
+
+        char model[32];
+        char serial[40];
+        char bus_info[32];
+        u32 hw_revision;
+        u32 driver_version;
+
+        u32 entity_id;
+        struct list_head entities;
+
+        /* Protects the entities list */
+        spinlock_t lock;
+        /* Serializes graph operations. */
+        struct mutex graph_mutex;
+
+        int (*link_notify)(struct media_pad *source,
+                           struct media_pad *sink, u32 flags);
+};
+
+/* media_devnode to media_device */
+#define to_media_device(node) container_of(node, struct media_device, devnode)
+
+int __must_check media_device_register(struct media_device *mdev);
+void media_device_unregister(struct media_device *mdev);
+
+int __must_check media_device_register_entity(struct media_device *mdev,
+                                              struct media_entity *entity);
+void media_device_unregister_entity(struct media_entity *entity);
+
+/* Iterate over all entities. */
+#define media_device_for_each_entity(entity, mdev)                      \
+        list_for_each_entry(entity, &(mdev)->entities, list)
+
+#endif
diff --git a/include/media/media-devnode.h b/include/media/media-devnode.h
new file mode 100644
index 000000000000..f6caafc874cb
--- /dev/null
+++ b/include/media/media-devnode.h
@@ -0,0 +1,97 @@
+/*
+ * Media device node
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * --
+ *
+ * Common functions for media-related drivers to register and unregister media
+ * device nodes.
+ */
+
+#ifndef _MEDIA_DEVNODE_H
+#define _MEDIA_DEVNODE_H
+
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/cdev.h>
+
+/*
+ * Flag to mark the media_devnode struct as registered. Drivers must not touch
+ * this flag directly, it will be set and cleared by media_devnode_register and
+ * media_devnode_unregister.
+ */
+#define MEDIA_FLAG_REGISTERED   0
+
+struct media_file_operations {
+        struct module *owner;
+        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
+        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
+        unsigned int (*poll) (struct file *, struct poll_table_struct *);
+        long (*ioctl) (struct file *, unsigned int, unsigned long);
+        int (*open) (struct file *);
+        int (*release) (struct file *);
+};
+
+/**
+ * struct media_devnode - Media device node
+ * @parent:     parent device
+ * @minor:      device node minor number
+ * @flags:      flags, combination of the MEDIA_FLAG_* constants
+ *
+ * This structure represents a media-related device node.
+ *
+ * The @parent is a physical device. It must be set by core or device drivers
+ * before registering the node.
+ */
+struct media_devnode {
+        /* device ops */
+        const struct media_file_operations *fops;
+
+        /* sysfs */
+        struct device dev;              /* media device */
+        struct cdev cdev;               /* character device */
+        struct device *parent;          /* device parent */
+
+        /* device info */
+        int minor;
+        unsigned long flags;            /* Use bitops to access flags */
+
+        /* callbacks */
+        void (*release)(struct media_devnode *mdev);
+};
+
+/* dev to media_devnode */
+#define to_media_devnode(cd) container_of(cd, struct media_devnode, dev)
+
+int __must_check media_devnode_register(struct media_devnode *mdev);
+void media_devnode_unregister(struct media_devnode *mdev);
+
+static inline struct media_devnode *media_devnode_data(struct file *filp)
+{
+        return filp->private_data;
+}
+
+static inline int media_devnode_is_registered(struct media_devnode *mdev)
+{
+        return test_bit(MEDIA_FLAG_REGISTERED, &mdev->flags);
+}
+
+#endif /* _MEDIA_DEVNODE_H */
diff --git a/include/media/media-entity.h b/include/media/media-entity.h
new file mode 100644
index 000000000000..cd8bca63a502
--- /dev/null
+++ b/include/media/media-entity.h
@@ -0,0 +1,151 @@
+/*
+ * Media entity
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ *
+ * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *           Sakari Ailus <sakari.ailus@iki.fi>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MEDIA_ENTITY_H
+#define _MEDIA_ENTITY_H
+
+#include <linux/list.h>
+#include <linux/media.h>
+
+struct media_pipeline {
+};
+
+struct media_link {
+        struct media_pad *source;       /* Source pad */
+        struct media_pad *sink;         /* Sink pad  */
+        struct media_link *reverse;     /* Link in the reverse direction */
+        unsigned long flags;            /* Link flags (MEDIA_LNK_FL_*) */
+};
+
+struct media_pad {
+        struct media_entity *entity;    /* Entity this pad belongs to */
+        u16 index;                      /* Pad index in the entity pads array */
+        unsigned long flags;            /* Pad flags (MEDIA_PAD_FL_*) */
+};
+
+struct media_entity_operations {
+        int (*link_setup)(struct media_entity *entity,
+                          const struct media_pad *local,
+                          const struct media_pad *remote, u32 flags);
+};
+
+struct media_entity {
+        struct list_head list;
+        struct media_device *parent;    /* Media device this entity belongs to*/
+        u32 id;                         /* Entity ID, unique in the parent media
+                                         * device context */
+        const char *name;               /* Entity name */
+        u32 type;                       /* Entity type (MEDIA_ENT_T_*) */
+        u32 revision;                   /* Entity revision, driver specific */
+        unsigned long flags;            /* Entity flags (MEDIA_ENT_FL_*) */
+        u32 group_id;                   /* Entity group ID */
+
+        u16 num_pads;                   /* Number of sink and source pads */
+        u16 num_links;                  /* Number of existing links, both
+                                         * enabled and disabled */
+        u16 num_backlinks;              /* Number of backlinks */
+        u16 max_links;                  /* Maximum number of links */
+
+        struct media_pad *pads;         /* Pads array (num_pads elements) */
+        struct media_link *links;       /* Links array (max_links elements)*/
+
+        const struct media_entity_operations *ops;      /* Entity operations */
+
+        /* Reference counts must never be negative, but are signed integers on
+         * purpose: a simple WARN_ON(<0) check can be used to detect reference
+         * count bugs that would make them negative.
+         */
+        int stream_count;               /* Stream count for the entity. */
+        int use_count;                  /* Use count for the entity. */
+
+        struct media_pipeline *pipe;    /* Pipeline this entity belongs to. */
+
+        union {
+                /* Node specifications */
+                struct {
+                        u32 major;
+                        u32 minor;
+                } v4l;
+                struct {
+                        u32 major;
+                        u32 minor;
+                } fb;
+                struct {
+                        u32 card;
+                        u32 device;
+                        u32 subdevice;
+                } alsa;
+                int dvb;
+
+                /* Sub-device specifications */
+                /* Nothing needed yet */
+        };
+};
+
+static inline u32 media_entity_type(struct media_entity *entity)
+{
+        return entity->type & MEDIA_ENT_TYPE_MASK;
+}
+
+static inline u32 media_entity_subtype(struct media_entity *entity)
+{
+        return entity->type & MEDIA_ENT_SUBTYPE_MASK;
+}
+
+#define MEDIA_ENTITY_ENUM_MAX_DEPTH     16
+
+struct media_entity_graph {
+        struct {
+                struct media_entity *entity;
+                int link;
+        } stack[MEDIA_ENTITY_ENUM_MAX_DEPTH];
+        int top;
+};
+
+int media_entity_init(struct media_entity *entity, u16 num_pads,
+                struct media_pad *pads, u16 extra_links);
+void media_entity_cleanup(struct media_entity *entity);
+
+int media_entity_create_link(struct media_entity *source, u16 source_pad,
+                struct media_entity *sink, u16 sink_pad, u32 flags);
+int __media_entity_setup_link(struct media_link *link, u32 flags);
+int media_entity_setup_link(struct media_link *link, u32 flags);
+struct media_link *media_entity_find_link(struct media_pad *source,
+                struct media_pad *sink);
+struct media_pad *media_entity_remote_source(struct media_pad *pad);
+
+struct media_entity *media_entity_get(struct media_entity *entity);
+void media_entity_put(struct media_entity *entity);
+
+void media_entity_graph_walk_start(struct media_entity_graph *graph,
+                struct media_entity *entity);
+struct media_entity *
+media_entity_graph_walk_next(struct media_entity_graph *graph);
+void media_entity_pipeline_start(struct media_entity *entity,
+                struct media_pipeline *pipe);
+void media_entity_pipeline_stop(struct media_entity *entity);
+
+#define media_entity_call(entity, operation, args...)                   \
+        (((entity)->ops && (entity)->ops->operation) ?                  \
+         (entity)->ops->operation((entity) , ##args) : -ENOIOCTLCMD)
+
+#endif
diff --git a/include/media/noon010pc30.h b/include/media/noon010pc30.h
new file mode 100644
index 000000000000..58eafee36b30
--- /dev/null
+++ b/include/media/noon010pc30.h
@@ -0,0 +1,28 @@
+/*
+ * Driver header for NOON010PC30L camera sensor chip.
+ *
+ * Copyright (c) 2010 Samsung Electronics, Co. Ltd
+ * Contact: Sylwester Nawrocki <s.nawrocki@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef NOON010PC30_H
+#define NOON010PC30_H
+
+/**
+ * @clk_rate: the clock frequency in Hz
+ * @gpio_nreset: GPIO driving nRESET pin
+ * @gpio_nstby: GPIO driving nSTBY pin
+ */
+
+struct noon010pc30_platform_data {
+        unsigned long clk_rate;
+        int gpio_nreset;
+        int gpio_nstby;
+};
+
+#endif /* NOON010PC30_H */
diff --git a/include/media/rc-map.h b/include/media/rc-map.h
index ee9e2f747c76..9184751f19c0 100644
--- a/include/media/rc-map.h
+++ b/include/media/rc-map.h
@@ -94,7 +94,7 @@ void rc_map_init(void);
 #define RC_MAP_GADMEI_RM008Z             "rc-gadmei-rm008z"
 #define RC_MAP_GENIUS_TVGO_A11MCE        "rc-genius-tvgo-a11mce"
 #define RC_MAP_GOTVIEW7135               "rc-gotview7135"
-#define RC_MAP_HAUPPAUGE_NEW             "rc-hauppauge-new"
+#define RC_MAP_HAUPPAUGE_NEW             "rc-hauppauge"
 #define RC_MAP_IMON_MCE                  "rc-imon-mce"
 #define RC_MAP_IMON_PAD                  "rc-imon-pad"
 #define RC_MAP_IODATA_BCTV7E             "rc-iodata-bctv7e"
@@ -125,14 +125,16 @@ void rc_map_init(void);
 #define RC_MAP_PROTEUS_2309              "rc-proteus-2309"
 #define RC_MAP_PURPLETV                  "rc-purpletv"
 #define RC_MAP_PV951                     "rc-pv951"
-#define RC_MAP_RC5_HAUPPAUGE_NEW         "rc-rc5-hauppauge-new"
+#define RC_MAP_HAUPPAUGE                 "rc-hauppauge"
 #define RC_MAP_RC5_TV                    "rc-rc5-tv"
 #define RC_MAP_RC6_MCE                   "rc-rc6-mce"
 #define RC_MAP_REAL_AUDIO_220_32_KEYS    "rc-real-audio-220-32-keys"
 #define RC_MAP_STREAMZAP                 "rc-streamzap"
 #define RC_MAP_TBS_NEC                   "rc-tbs-nec"
+#define RC_MAP_TECHNISAT_USB2            "rc-technisat-usb2"
 #define RC_MAP_TERRATEC_CINERGY_XS       "rc-terratec-cinergy-xs"
 #define RC_MAP_TERRATEC_SLIM             "rc-terratec-slim"
+#define RC_MAP_TERRATEC_SLIM_2           "rc-terratec-slim-2"
 #define RC_MAP_TEVII_NEC                 "rc-tevii-nec"
 #define RC_MAP_TOTAL_MEDIA_IN_HAND       "rc-total-media-in-hand"
 #define RC_MAP_TREKSTOR                  "rc-trekstor"
diff --git a/include/media/s3c_fimc.h b/include/media/s5p_fimc.h
index ca1b6738e4a4..9fdff8a4ed26 100644
--- a/include/media/s3c_fimc.h
+++ b/include/media/s5p_fimc.h
@@ -9,8 +9,8 @@
  * published by the Free Software Foundation.
  */
 
-#ifndef S3C_FIMC_H_
-#define S3C_FIMC_H_
+#ifndef S5P_FIMC_H_
+#define S5P_FIMC_H_
 
 enum cam_bus_type {
         FIMC_ITU_601 = 1,
@@ -27,34 +27,35 @@ enum cam_bus_type {
 struct i2c_board_info;
 
 /**
- * struct s3c_fimc_isp_info - image sensor information required for host
+ * struct s5p_fimc_isp_info - image sensor information required for host
  *                            interace configuration.
  *
  * @board_info: pointer to I2C subdevice's board info
+ * @clk_frequency: frequency of the clock the host interface provides to sensor
  * @bus_type: determines bus type, MIPI, ITU-R BT.601 etc.
+ * @csi_data_align: MIPI-CSI interface data alignment in bits
  * @i2c_bus_num: i2c control bus id the sensor is attached to
  * @mux_id: FIMC camera interface multiplexer index (separate for MIPI and ITU)
- * @bus_width: camera data bus width in bits
  * @flags: flags defining bus signals polarity inversion (High by default)
  */
-struct s3c_fimc_isp_info {
+struct s5p_fimc_isp_info {
         struct i2c_board_info *board_info;
+        unsigned long clk_frequency;
         enum cam_bus_type bus_type;
+        u16 csi_data_align;
         u16 i2c_bus_num;
         u16 mux_id;
-        u16 bus_width;
         u16 flags;
 };
 
-
-#define FIMC_MAX_CAMIF_CLIENTS  2
-
 /**
- * struct s3c_platform_fimc - camera host interface platform data
+ * struct s5p_platform_fimc - camera host interface platform data
  *
  * @isp_info: properties of camera sensor required for host interface setup
+ * @num_clients: the number of attached image sensors
  */
-struct s3c_platform_fimc {
-        struct s3c_fimc_isp_info *isp_info[FIMC_MAX_CAMIF_CLIENTS];
+struct s5p_platform_fimc {
+        struct s5p_fimc_isp_info *isp_info;
+        int num_clients;
 };
-#endif /* S3C_FIMC_H_ */
+#endif /* S5P_FIMC_H_ */
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index 9386db829fb7..f80b5372baf3 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -17,6 +17,7 @@
 #include <linux/pm.h>
 #include <linux/videodev2.h>
 #include <media/videobuf-core.h>
+#include <media/videobuf2-core.h>
 #include <media/v4l2-device.h>
 
 extern struct bus_type soc_camera_bus_type;
@@ -29,6 +30,8 @@ struct soc_camera_device {
         struct device *pdev;            /* Platform device */
         s32 user_width;
         s32 user_height;
+        u32 bytesperline;               /* for padding, zero if unused */
+        u32 sizeimage;
         enum v4l2_colorspace colorspace;
         unsigned char iface;            /* Host number */
         unsigned char devnum;           /* Device number per host */
@@ -44,7 +47,10 @@ struct soc_camera_device {
         int use_count;
         struct mutex video_lock;        /* Protects device data */
         struct file *streamer;          /* stream owner */
-        struct videobuf_queue vb_vidq;
+        union {
+                struct videobuf_queue vb_vidq;
+                struct vb2_queue vb2_vidq;
+        };
 };
 
 struct soc_camera_host {
@@ -78,6 +84,8 @@ struct soc_camera_host_ops {
         int (*try_fmt)(struct soc_camera_device *, struct v4l2_format *);
         void (*init_videobuf)(struct videobuf_queue *,
                               struct soc_camera_device *);
+        int (*init_videobuf2)(struct vb2_queue *,
+                              struct soc_camera_device *);
         int (*reqbufs)(struct soc_camera_device *, struct v4l2_requestbuffers *);
         int (*querycap)(struct soc_camera_host *, struct v4l2_capability *);
         int (*set_bus_param)(struct soc_camera_device *, __u32);
@@ -85,6 +93,7 @@ struct soc_camera_host_ops {
         int (*set_ctrl)(struct soc_camera_device *, struct v4l2_control *);
         int (*get_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
         int (*set_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
+        int (*enum_fsizes)(struct soc_camera_device *, struct v4l2_frmsizeenum *);
         unsigned int (*poll)(struct file *, poll_table *);
         const struct v4l2_queryctrl *controls;
         int num_controls;
@@ -299,4 +308,17 @@ static inline struct video_device *soc_camera_i2c_to_vdev(struct i2c_client *cli
         return icd->vdev;
 }
 
+static inline struct soc_camera_device *soc_camera_from_vb2q(struct vb2_queue *vq)
+{
+        return container_of(vq, struct soc_camera_device, vb2_vidq);
+}
+
+static inline struct soc_camera_device *soc_camera_from_vbq(struct videobuf_queue *vq)
+{
+        return container_of(vq, struct soc_camera_device, vb_vidq);
+}
+
+void soc_camera_lock(struct vb2_queue *vq);
+void soc_camera_unlock(struct vb2_queue *vq);
+
 #endif
diff --git a/include/media/soc_mediabus.h b/include/media/soc_mediabus.h
index 037cd7be001e..b338108ec305 100644
--- a/include/media/soc_mediabus.h
+++ b/include/media/soc_mediabus.h
@@ -12,8 +12,7 @@
 #define SOC_MEDIABUS_H
 
 #include <linux/videodev2.h>
-
-#include <media/v4l2-mediabus.h>
+#include <linux/v4l2-mediabus.h>
 
 /**
  * enum soc_mbus_packing - data packing types on the media-bus
@@ -61,5 +60,6 @@ struct soc_mbus_pixelfmt {
 const struct soc_mbus_pixelfmt *soc_mbus_get_fmtdesc(
         enum v4l2_mbus_pixelcode code);
 s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf);
+int soc_mbus_samples_per_pixel(const struct soc_mbus_pixelfmt *mf);
 
 #endif
diff --git a/include/media/tuner.h b/include/media/tuner.h
index 51811eac46f1..963e33471835 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -21,6 +21,7 @@
 
 #ifndef _TUNER_H
 #define _TUNER_H
+#ifdef __KERNEL__
 
 #include <linux/videodev2.h>
 
@@ -131,6 +132,7 @@
 #define TUNER_NXP_TDA18271              83
 #define TUNER_SONY_BTF_PXN01Z           84
 #define TUNER_PHILIPS_FQ1236_MK5        85      /* NTSC, TDA9885, no FM radio */
+#define TUNER_TENA_TNF_5337             86
 
 /* tv card specific */
 #define TDA9887_PRESENT                 (1<<0)
@@ -156,14 +158,10 @@
 #define TDA9887_GAIN_NORMAL             (1<<20)
 #define TDA9887_RIF_41_3                (1<<21)  /* radio IF1 41.3 vs 33.3 */
 
-#ifdef __KERNEL__
-
 enum tuner_mode {
-        T_UNINITIALIZED = 0,
         T_RADIO         = 1 << V4L2_TUNER_RADIO,
         T_ANALOG_TV     = 1 << V4L2_TUNER_ANALOG_TV,
-        T_DIGITAL_TV    = 1 << V4L2_TUNER_DIGITAL_TV,
-        T_STANDBY       = 1 << 31
+        /* Don't need to map V4L2_TUNER_DIGITAL_TV, as tuner-core won't use it */
 };
 
 /* Older boards only had a single tuner device. Nowadays multiple tuner
@@ -193,11 +191,3 @@ struct tuner_setup {
 #endif /* __KERNEL__ */
 
 #endif /* _TUNER_H */
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h
index 44fe44ec9ea7..b3edb67a8311 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -75,6 +75,7 @@ enum {
         V4L2_IDENT_OV9640 = 257,
         V4L2_IDENT_OV6650 = 258,
         V4L2_IDENT_OV2640 = 259,
+        V4L2_IDENT_OV9740 = 260,
 
         /* module saa7146: reserved range 300-309 */
         V4L2_IDENT_SAA7146 = 300,
@@ -209,6 +210,9 @@ enum {
         /* module sn9c20x: just ident 10000 */
         V4L2_IDENT_SN9C20X = 10000,
 
+        /* Siliconfile sensors: reserved range 10100 - 10199 */
+        V4L2_IDENT_NOON010PC30  = 10100,
+
         /* module cx231xx and cx25840 */
         V4L2_IDENT_CX2310X_AV = 23099, /* Integrated A/V decoder; not in '100 */
         V4L2_IDENT_CX23100    = 23100,
diff --git a/include/media/v4l2-common.h b/include/media/v4l2-common.h
index a659319e8582..a298ec49ddc4 100644
--- a/include/media/v4l2-common.h
+++ b/include/media/v4l2-common.h
@@ -80,21 +80,6 @@
 
 /* ------------------------------------------------------------------------- */
 
-/* Priority helper functions */
-
-struct v4l2_prio_state {
-        atomic_t prios[4];
-};
-void v4l2_prio_init(struct v4l2_prio_state *global);
-int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
-                     enum v4l2_priority new);
-void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
-void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local);
-enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
-int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local);
-
-/* ------------------------------------------------------------------------- */
-
 /* Control helper functions */
 
 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
index 15802a067a12..8266d5ade2ff 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -16,12 +16,15 @@
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
 
+#include <media/media-entity.h>
+
 #define VIDEO_MAJOR     81
 
 #define VFL_TYPE_GRABBER        0
 #define VFL_TYPE_VBI            1
 #define VFL_TYPE_RADIO          2
-#define VFL_TYPE_MAX            3
+#define VFL_TYPE_SUBDEV         3
+#define VFL_TYPE_MAX            4
 
 struct v4l2_ioctl_callbacks;
 struct video_device;
@@ -32,7 +35,25 @@ struct v4l2_ctrl_handler;
    Drivers can clear this flag if they want to block all future
    device access. It is cleared by video_unregister_device. */
 #define V4L2_FL_REGISTERED      (0)
+/* file->private_data points to struct v4l2_fh */
 #define V4L2_FL_USES_V4L2_FH    (1)
+/* Use the prio field of v4l2_fh for core priority checking */
+#define V4L2_FL_USE_FH_PRIO     (2)
+
+/* Priority helper functions */
+
+struct v4l2_prio_state {
+        atomic_t prios[4];
+};
+
+void v4l2_prio_init(struct v4l2_prio_state *global);
+int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
+                     enum v4l2_priority new);
+void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
+void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local);
+enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
+int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local);
+
 
 struct v4l2_file_operations {
         struct module *owner;
@@ -54,6 +75,9 @@ struct v4l2_file_operations {
 
 struct video_device
 {
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        struct media_entity entity;
+#endif
         /* device ops */
         const struct v4l2_file_operations *fops;
 
@@ -68,6 +92,9 @@ struct video_device
         /* Control handler associated with this device node. May be NULL. */
         struct v4l2_ctrl_handler *ctrl_handler;
 
+        /* Priority state. If NULL, then v4l2_dev->prio will be used. */
+        struct v4l2_prio_state *prio;
+
         /* device info */
         char name[32];
         int vfl_type;
@@ -99,18 +126,31 @@ struct video_device
         struct mutex *lock;
 };
 
+#define media_entity_to_video_device(entity) \
+        container_of(entity, struct video_device, entity)
 /* dev to video-device */
 #define to_video_device(cd) container_of(cd, struct video_device, dev)
 
+int __must_check __video_register_device(struct video_device *vdev, int type,
+                int nr, int warn_if_nr_in_use, struct module *owner);
+
 /* Register video devices. Note that if video_register_device fails,
    the release() callback of the video_device structure is *not* called, so
    the caller is responsible for freeing any data. Usually that means that
    you call video_device_release() on failure. */
-int __must_check video_register_device(struct video_device *vdev, int type, int nr);
+static inline int __must_check video_register_device(struct video_device *vdev,
+                int type, int nr)
+{
+        return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
+}
 
 /* Same as video_register_device, but no warning is issued if the desired
    device node number was already in use. */
-int __must_check video_register_device_no_warn(struct video_device *vdev, int type, int nr);
+static inline int __must_check video_register_device_no_warn(
+                struct video_device *vdev, int type, int nr)
+{
+        return __video_register_device(vdev, type, nr, 0, vdev->fops->owner);
+}
 
 /* Unregister video devices. Will do nothing if vdev == NULL or
    video_is_registered() returns false. */
diff --git a/include/media/v4l2-device.h b/include/media/v4l2-device.h
index b16f307d471a..bd102cf509ac 100644
--- a/include/media/v4l2-device.h
+++ b/include/media/v4l2-device.h
@@ -21,7 +21,9 @@
 #ifndef _V4L2_DEVICE_H
 #define _V4L2_DEVICE_H
 
+#include <media/media-device.h>
 #include <media/v4l2-subdev.h>
+#include <media/v4l2-dev.h>
 
 /* Each instance of a V4L2 device should create the v4l2_device struct,
    either stand-alone or embedded in a larger struct.
@@ -39,6 +41,9 @@ struct v4l2_device {
            Note: dev might be NULL if there is no parent device
            as is the case with e.g. ISA devices. */
         struct device *dev;
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        struct media_device *mdev;
+#endif
         /* used to keep track of the registered subdevs */
         struct list_head subdevs;
         /* lock this struct; can be used by the driver as well if this
@@ -51,10 +56,23 @@ struct v4l2_device {
                         unsigned int notification, void *arg);
         /* The control handler. May be NULL. */
         struct v4l2_ctrl_handler *ctrl_handler;
+        /* Device's priority state */
+        struct v4l2_prio_state prio;
         /* BKL replacement mutex. Temporary solution only. */
         struct mutex ioctl_lock;
+        /* Keep track of the references to this struct. */
+        struct kref ref;
+        /* Release function that is called when the ref count goes to 0. */
+        void (*release)(struct v4l2_device *v4l2_dev);
 };
 
+static inline void v4l2_device_get(struct v4l2_device *v4l2_dev)
+{
+        kref_get(&v4l2_dev->ref);
+}
+
+int v4l2_device_put(struct v4l2_device *v4l2_dev);
+
 /* Initialize v4l2_dev and make dev->driver_data point to v4l2_dev.
    dev may be NULL in rare cases (ISA devices). In that case you
    must fill in the v4l2_dev->name field before calling this function. */
@@ -96,6 +114,12 @@ int __must_check v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
    wasn't registered. In that case it will do nothing. */
 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd);
 
+/* Register device nodes for all subdev of the v4l2 device that are marked with
+ * the V4L2_SUBDEV_FL_HAS_DEVNODE flag.
+ */
+int __must_check
+v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev);
+
 /* Iterate over all subdevs. */
 #define v4l2_device_for_each_subdev(sd, v4l2_dev)                       \
         list_for_each_entry(sd, &(v4l2_dev)->subdevs, list)
diff --git a/include/media/v4l2-fh.h b/include/media/v4l2-fh.h
index 1d72dde320bf..0206aa55be24 100644
--- a/include/media/v4l2-fh.h
+++ b/include/media/v4l2-fh.h
@@ -35,6 +35,7 @@ struct v4l2_fh {
         struct list_head        list;
         struct video_device     *vdev;
         struct v4l2_events      *events; /* events, pending and subscribed */
+        enum v4l2_priority      prio;
 };
 
 /*
@@ -50,8 +51,16 @@ int v4l2_fh_init(struct v4l2_fh *fh, struct video_device *vdev);
  */
 void v4l2_fh_add(struct v4l2_fh *fh);
 /*
+ * Can be used as the open() op of v4l2_file_operations.
+ * It allocates a v4l2_fh and inits and adds it to the video_device associated
+ * with the file pointer.
+ */
+int v4l2_fh_open(struct file *filp);
+/*
  * Remove file handle from the list of file handles. Must be called in
  * v4l2_file_operations->release() handler if the driver uses v4l2_fh.
+ * On error filp->private_data will be NULL, otherwise it will point to
+ * the v4l2_fh struct.
  */
 void v4l2_fh_del(struct v4l2_fh *fh);
 /*
@@ -61,5 +70,25 @@ void v4l2_fh_del(struct v4l2_fh *fh);
  * driver uses v4l2_fh.
  */
 void v4l2_fh_exit(struct v4l2_fh *fh);
+/*
+ * Can be used as the release() op of v4l2_file_operations.
+ * It deletes and exits the v4l2_fh associated with the file pointer and
+ * frees it. It will do nothing if filp->private_data (the pointer to the
+ * v4l2_fh struct) is NULL. This function always returns 0.
+ */
+int v4l2_fh_release(struct file *filp);
+/*
+ * Returns 1 if this filehandle is the only filehandle opened for the
+ * associated video_device. If fh is NULL, then it returns 0.
+ */
+int v4l2_fh_is_singular(struct v4l2_fh *fh);
+/*
+ * Helper function with struct file as argument. If filp->private_data is
+ * NULL, then it will return 0.
+ */
+static inline int v4l2_fh_is_singular_file(struct file *filp)
+{
+        return v4l2_fh_is_singular(filp->private_data);
+}
 
 #endif /* V4L2_EVENT_H */
diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
index 67df37542c68..dd9f1e7b8ff7 100644
--- a/include/media/v4l2-ioctl.h
+++ b/include/media/v4l2-ioctl.h
@@ -37,6 +37,10 @@ struct v4l2_ioctl_ops {
                                             struct v4l2_fmtdesc *f);
         int (*vidioc_enum_fmt_vid_out)     (struct file *file, void *fh,
                                             struct v4l2_fmtdesc *f);
+        int (*vidioc_enum_fmt_vid_cap_mplane)(struct file *file, void *fh,
+                                              struct v4l2_fmtdesc *f);
+        int (*vidioc_enum_fmt_vid_out_mplane)(struct file *file, void *fh,
+                                              struct v4l2_fmtdesc *f);
         int (*vidioc_enum_fmt_type_private)(struct file *file, void *fh,
                                             struct v4l2_fmtdesc *f);
 
@@ -57,6 +61,10 @@ struct v4l2_ioctl_ops {
                                         struct v4l2_format *f);
         int (*vidioc_g_fmt_sliced_vbi_out)(struct file *file, void *fh,
                                         struct v4l2_format *f);
+        int (*vidioc_g_fmt_vid_cap_mplane)(struct file *file, void *fh,
+                                           struct v4l2_format *f);
+        int (*vidioc_g_fmt_vid_out_mplane)(struct file *file, void *fh,
+                                           struct v4l2_format *f);
         int (*vidioc_g_fmt_type_private)(struct file *file, void *fh,
                                         struct v4l2_format *f);
 
@@ -77,6 +85,10 @@ struct v4l2_ioctl_ops {
                                         struct v4l2_format *f);
         int (*vidioc_s_fmt_sliced_vbi_out)(struct file *file, void *fh,
                                         struct v4l2_format *f);
+        int (*vidioc_s_fmt_vid_cap_mplane)(struct file *file, void *fh,
+                                           struct v4l2_format *f);
+        int (*vidioc_s_fmt_vid_out_mplane)(struct file *file, void *fh,
+                                           struct v4l2_format *f);
         int (*vidioc_s_fmt_type_private)(struct file *file, void *fh,
                                         struct v4l2_format *f);
 
@@ -97,6 +109,10 @@ struct v4l2_ioctl_ops {
                                           struct v4l2_format *f);
         int (*vidioc_try_fmt_sliced_vbi_out)(struct file *file, void *fh,
                                           struct v4l2_format *f);
+        int (*vidioc_try_fmt_vid_cap_mplane)(struct file *file, void *fh,
+                                             struct v4l2_format *f);
+        int (*vidioc_try_fmt_vid_out_mplane)(struct file *file, void *fh,
+                                             struct v4l2_format *f);
         int (*vidioc_try_fmt_type_private)(struct file *file, void *fh,
                                           struct v4l2_format *f);
 
@@ -254,7 +270,7 @@ struct v4l2_ioctl_ops {
 
         /* For other private ioctls */
         long (*vidioc_default)         (struct file *file, void *fh,
-                                        int cmd, void *arg);
+                                        bool valid_prio, int cmd, void *arg);
 };
 
 
diff --git a/include/media/v4l2-mediabus.h b/include/media/v4l2-mediabus.h
index 8e6559838ae3..971c7fa29614 100644
--- a/include/media/v4l2-mediabus.h
+++ b/include/media/v4l2-mediabus.h
@@ -11,66 +11,7 @@
 #ifndef V4L2_MEDIABUS_H
 #define V4L2_MEDIABUS_H
 
-/*
- * These pixel codes uniquely identify data formats on the media bus. Mostly
- * they correspond to similarly named V4L2_PIX_FMT_* formats, format 0 is
- * reserved, V4L2_MBUS_FMT_FIXED shall be used by host-client pairs, where the
- * data format is fixed. Additionally, "2X8" means that one pixel is transferred
- * in two 8-bit samples, "BE" or "LE" specify in which order those samples are
- * transferred over the bus: "LE" means that the least significant bits are
- * transferred first, "BE" means that the most significant bits are transferred
- * first, and "PADHI" and "PADLO" define which bits - low or high, in the
- * incomplete high byte, are filled with padding bits.
- */
-enum v4l2_mbus_pixelcode {
-        V4L2_MBUS_FMT_FIXED = 1,
-        V4L2_MBUS_FMT_YUYV8_2X8,
-        V4L2_MBUS_FMT_YVYU8_2X8,
-        V4L2_MBUS_FMT_UYVY8_2X8,
-        V4L2_MBUS_FMT_VYUY8_2X8,
-        V4L2_MBUS_FMT_YVYU10_2X10,
-        V4L2_MBUS_FMT_YUYV10_2X10,
-        V4L2_MBUS_FMT_YVYU10_1X20,
-        V4L2_MBUS_FMT_YUYV10_1X20,
-        V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
-        V4L2_MBUS_FMT_RGB444_2X8_PADHI_BE,
-        V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE,
-        V4L2_MBUS_FMT_RGB555_2X8_PADHI_BE,
-        V4L2_MBUS_FMT_RGB565_2X8_LE,
-        V4L2_MBUS_FMT_RGB565_2X8_BE,
-        V4L2_MBUS_FMT_BGR565_2X8_LE,
-        V4L2_MBUS_FMT_BGR565_2X8_BE,
-        V4L2_MBUS_FMT_SBGGR8_1X8,
-        V4L2_MBUS_FMT_SBGGR10_1X10,
-        V4L2_MBUS_FMT_GREY8_1X8,
-        V4L2_MBUS_FMT_Y10_1X10,
-        V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE,
-        V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_LE,
-        V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_BE,
-        V4L2_MBUS_FMT_SBGGR10_2X8_PADLO_BE,
-        V4L2_MBUS_FMT_SGRBG8_1X8,
-        V4L2_MBUS_FMT_SBGGR12_1X12,
-        V4L2_MBUS_FMT_YUYV8_1_5X8,
-        V4L2_MBUS_FMT_YVYU8_1_5X8,
-        V4L2_MBUS_FMT_UYVY8_1_5X8,
-        V4L2_MBUS_FMT_VYUY8_1_5X8,
-};
-
-/**
- * struct v4l2_mbus_framefmt - frame format on the media bus
- * @width:      frame width
- * @height:     frame height
- * @code:       data format code
- * @field:      used interlacing type
- * @colorspace: colorspace of the data
- */
-struct v4l2_mbus_framefmt {
-        __u32                           width;
-        __u32                           height;
-        enum v4l2_mbus_pixelcode        code;
-        enum v4l2_field                 field;
-        enum v4l2_colorspace            colorspace;
-};
+#include <linux/v4l2-mediabus.h>
 
 static inline void v4l2_fill_pix_format(struct v4l2_pix_format *pix_fmt,
                                 const struct v4l2_mbus_framefmt *mbus_fmt)
diff --git a/include/media/v4l2-mem2mem.h b/include/media/v4l2-mem2mem.h
index 8d149f1c58d0..16ac4733e80d 100644
--- a/include/media/v4l2-mem2mem.h
+++ b/include/media/v4l2-mem2mem.h
@@ -5,7 +5,7 @@
  * and destination.
  *
  * Copyright (c) 2009 Samsung Electronics Co., Ltd.
- * Pawel Osciak, <p.osciak@samsung.com>
+ * Pawel Osciak, <pawel@osciak.com>
  * Marek Szyprowski, <m.szyprowski@samsung.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -17,7 +17,7 @@
 #ifndef _MEDIA_V4L2_MEM2MEM_H
 #define _MEDIA_V4L2_MEM2MEM_H
 
-#include <media/videobuf-core.h>
+#include <media/videobuf2-core.h>
 
 /**
  * struct v4l2_m2m_ops - mem-to-mem device driver callbacks
@@ -45,17 +45,20 @@ struct v4l2_m2m_ops {
         void (*device_run)(void *priv);
         int (*job_ready)(void *priv);
         void (*job_abort)(void *priv);
+        void (*lock)(void *priv);
+        void (*unlock)(void *priv);
 };
 
 struct v4l2_m2m_dev;
 
 struct v4l2_m2m_queue_ctx {
 /* private: internal use only */
-        struct videobuf_queue   q;
+        struct vb2_queue        q;
 
         /* Queue for buffers ready to be processed as soon as this
          * instance receives access to the device */
         struct list_head        rdy_queue;
+        spinlock_t              rdy_spinlock;
         u8                      num_rdy;
 };
 
@@ -72,19 +75,31 @@ struct v4l2_m2m_ctx {
         /* For device job queue */
         struct list_head                queue;
         unsigned long                   job_flags;
+        wait_queue_head_t               finished;
 
         /* Instance private data */
         void                            *priv;
 };
 
+struct v4l2_m2m_buffer {
+        struct vb2_buffer       vb;
+        struct list_head        list;
+};
+
 void *v4l2_m2m_get_curr_priv(struct v4l2_m2m_dev *m2m_dev);
 
-struct videobuf_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
+struct vb2_queue *v4l2_m2m_get_vq(struct v4l2_m2m_ctx *m2m_ctx,
                                        enum v4l2_buf_type type);
 
 void v4l2_m2m_job_finish(struct v4l2_m2m_dev *m2m_dev,
                          struct v4l2_m2m_ctx *m2m_ctx);
 
+static inline void
+v4l2_m2m_buf_done(struct vb2_buffer *buf, enum vb2_buffer_state state)
+{
+        vb2_buffer_done(buf, state);
+}
+
 int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                      struct v4l2_requestbuffers *reqbufs);
 
@@ -110,13 +125,13 @@ int v4l2_m2m_mmap(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
 struct v4l2_m2m_dev *v4l2_m2m_init(struct v4l2_m2m_ops *m2m_ops);
 void v4l2_m2m_release(struct v4l2_m2m_dev *m2m_dev);
 
-struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(void *priv, struct v4l2_m2m_dev *m2m_dev,
-                        void (*vq_init)(void *priv, struct videobuf_queue *,
-                                        enum v4l2_buf_type));
+struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
+                void *drv_priv,
+                int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq));
+
 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx);
 
-void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, struct videobuf_queue *vq,
-                        struct videobuf_buffer *vb);
+void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, struct vb2_buffer *vb);
 
 /**
  * v4l2_m2m_num_src_bufs_ready() - return the number of source buffers ready for
@@ -138,7 +153,7 @@ unsigned int v4l2_m2m_num_dst_bufs_ready(struct v4l2_m2m_ctx *m2m_ctx)
         return m2m_ctx->out_q_ctx.num_rdy;
 }
 
-void *v4l2_m2m_next_buf(struct v4l2_m2m_ctx *m2m_ctx, enum v4l2_buf_type type);
+void *v4l2_m2m_next_buf(struct v4l2_m2m_queue_ctx *q_ctx);
 
 /**
  * v4l2_m2m_next_src_buf() - return next source buffer from the list of ready
@@ -146,7 +161,7 @@ void *v4l2_m2m_next_buf(struct v4l2_m2m_ctx *m2m_ctx, enum v4l2_buf_type type);
  */
 static inline void *v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_next_buf(m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        return v4l2_m2m_next_buf(&m2m_ctx->out_q_ctx);
 }
 
 /**
@@ -155,29 +170,28 @@ static inline void *v4l2_m2m_next_src_buf(struct v4l2_m2m_ctx *m2m_ctx)
  */
 static inline void *v4l2_m2m_next_dst_buf(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_next_buf(m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+        return v4l2_m2m_next_buf(&m2m_ctx->cap_q_ctx);
 }
 
 /**
- * v4l2_m2m_get_src_vq() - return videobuf_queue for source buffers
+ * v4l2_m2m_get_src_vq() - return vb2_queue for source buffers
  */
 static inline
-struct videobuf_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
+struct vb2_queue *v4l2_m2m_get_src_vq(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        return &m2m_ctx->out_q_ctx.q;
 }
 
 /**
- * v4l2_m2m_get_dst_vq() - return videobuf_queue for destination buffers
+ * v4l2_m2m_get_dst_vq() - return vb2_queue for destination buffers
  */
 static inline
-struct videobuf_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
+struct vb2_queue *v4l2_m2m_get_dst_vq(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+        return &m2m_ctx->cap_q_ctx.q;
 }
 
-void *v4l2_m2m_buf_remove(struct v4l2_m2m_ctx *m2m_ctx,
-                          enum v4l2_buf_type type);
+void *v4l2_m2m_buf_remove(struct v4l2_m2m_queue_ctx *q_ctx);
 
 /**
  * v4l2_m2m_src_buf_remove() - take off a source buffer from the list of ready
@@ -185,7 +199,7 @@ void *v4l2_m2m_buf_remove(struct v4l2_m2m_ctx *m2m_ctx,
  */
 static inline void *v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_buf_remove(m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        return v4l2_m2m_buf_remove(&m2m_ctx->out_q_ctx);
 }
 
 /**
@@ -194,7 +208,7 @@ static inline void *v4l2_m2m_src_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
  */
 static inline void *v4l2_m2m_dst_buf_remove(struct v4l2_m2m_ctx *m2m_ctx)
 {
-        return v4l2_m2m_buf_remove(m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+        return v4l2_m2m_buf_remove(&m2m_ctx->cap_q_ctx);
 }
 
 #endif /* _MEDIA_V4L2_MEM2MEM_H */
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index daf1e57d9b26..1562c4ff3a65 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -21,7 +21,11 @@
 #ifndef _V4L2_SUBDEV_H
 #define _V4L2_SUBDEV_H
 
+#include <linux/v4l2-subdev.h>
+#include <media/media-entity.h>
 #include <media/v4l2-common.h>
+#include <media/v4l2-dev.h>
+#include <media/v4l2-fh.h>
 #include <media/v4l2-mediabus.h>
 
 /* generic v4l2_device notify callback notification values */
@@ -36,7 +40,10 @@
 
 struct v4l2_device;
 struct v4l2_ctrl_handler;
+struct v4l2_event_subscription;
+struct v4l2_fh;
 struct v4l2_subdev;
+struct v4l2_subdev_fh;
 struct tuner_setup;
 
 /* decode_vbi_line */
@@ -160,6 +167,10 @@ struct v4l2_subdev_core_ops {
         int (*s_power)(struct v4l2_subdev *sd, int on);
         int (*interrupt_service_routine)(struct v4l2_subdev *sd,
                                                 u32 status, bool *handled);
+        int (*subscribe_event)(struct v4l2_subdev *sd, struct v4l2_fh *fh,
+                               struct v4l2_event_subscription *sub);
+        int (*unsubscribe_event)(struct v4l2_subdev *sd, struct v4l2_fh *fh,
+                                 struct v4l2_event_subscription *sub);
 };
 
 /* s_mode: switch the tuner to a specific tuner mode. Replacement of s_radio.
@@ -257,6 +268,10 @@ struct v4l2_subdev_video_ops {
         int (*s_crop)(struct v4l2_subdev *sd, struct v4l2_crop *crop);
         int (*g_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
         int (*s_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
+        int (*g_frame_interval)(struct v4l2_subdev *sd,
+                                struct v4l2_subdev_frame_interval *interval);
+        int (*s_frame_interval)(struct v4l2_subdev *sd,
+                                struct v4l2_subdev_frame_interval *interval);
         int (*enum_framesizes)(struct v4l2_subdev *sd, struct v4l2_frmsizeenum *fsize);
         int (*enum_frameintervals)(struct v4l2_subdev *sd, struct v4l2_frmivalenum *fival);
         int (*enum_dv_presets) (struct v4l2_subdev *sd,
@@ -271,6 +286,8 @@ struct v4l2_subdev_video_ops {
                         struct v4l2_dv_timings *timings);
         int (*enum_mbus_fmt)(struct v4l2_subdev *sd, unsigned int index,
                              enum v4l2_mbus_pixelcode *code);
+        int (*enum_mbus_fsizes)(struct v4l2_subdev *sd,
+                             struct v4l2_frmsizeenum *fsize);
         int (*g_mbus_fmt)(struct v4l2_subdev *sd,
                           struct v4l2_mbus_framefmt *fmt);
         int (*try_mbus_fmt)(struct v4l2_subdev *sd,
@@ -324,9 +341,13 @@ struct v4l2_subdev_vbi_ops {
  *                    This is needed for some sensors, which always corrupt
  *                    several top lines of the output image, or which send their
  *                    metadata in them.
+ * @g_skip_frames: number of frames to skip at stream start. This is needed for
+ *                 buggy sensors that generate faulty frames when they are
+ *                 turned on.
  */
 struct v4l2_subdev_sensor_ops {
         int (*g_skip_top_lines)(struct v4l2_subdev *sd, u32 *lines);
+        int (*g_skip_frames)(struct v4l2_subdev *sd, u32 *frames);
 };
 
 /*
@@ -401,6 +422,25 @@ struct v4l2_subdev_ir_ops {
                                 struct v4l2_subdev_ir_parameters *params);
 };
 
+struct v4l2_subdev_pad_ops {
+        int (*enum_mbus_code)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                              struct v4l2_subdev_mbus_code_enum *code);
+        int (*enum_frame_size)(struct v4l2_subdev *sd,
+                               struct v4l2_subdev_fh *fh,
+                               struct v4l2_subdev_frame_size_enum *fse);
+        int (*enum_frame_interval)(struct v4l2_subdev *sd,
+                                   struct v4l2_subdev_fh *fh,
+                                   struct v4l2_subdev_frame_interval_enum *fie);
+        int (*get_fmt)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                       struct v4l2_subdev_format *format);
+        int (*set_fmt)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                       struct v4l2_subdev_format *format);
+        int (*set_crop)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                       struct v4l2_subdev_crop *crop);
+        int (*get_crop)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
+                       struct v4l2_subdev_crop *crop);
+};
+
 struct v4l2_subdev_ops {
         const struct v4l2_subdev_core_ops       *core;
         const struct v4l2_subdev_tuner_ops      *tuner;
@@ -409,6 +449,7 @@ struct v4l2_subdev_ops {
         const struct v4l2_subdev_vbi_ops        *vbi;
         const struct v4l2_subdev_ir_ops         *ir;
         const struct v4l2_subdev_sensor_ops     *sensor;
+        const struct v4l2_subdev_pad_ops        *pad;
 };
 
 /*
@@ -420,23 +461,36 @@ struct v4l2_subdev_ops {
  *
  * unregistered: called when this subdev is unregistered. When called the
  *      v4l2_dev field is still set to the correct v4l2_device.
+ *
+ * open: called when the subdev device node is opened by an application.
+ *
+ * close: called when the subdev device node is closed.
  */
 struct v4l2_subdev_internal_ops {
         int (*registered)(struct v4l2_subdev *sd);
         void (*unregistered)(struct v4l2_subdev *sd);
+        int (*open)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh);
+        int (*close)(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh);
 };
 
 #define V4L2_SUBDEV_NAME_SIZE 32
 
 /* Set this flag if this subdev is a i2c device. */
-#define V4L2_SUBDEV_FL_IS_I2C (1U << 0)
+#define V4L2_SUBDEV_FL_IS_I2C                   (1U << 0)
 /* Set this flag if this subdev is a spi device. */
-#define V4L2_SUBDEV_FL_IS_SPI (1U << 1)
+#define V4L2_SUBDEV_FL_IS_SPI                   (1U << 1)
+/* Set this flag if this subdev needs a device node. */
+#define V4L2_SUBDEV_FL_HAS_DEVNODE              (1U << 2)
+/* Set this flag if this subdev generates events. */
+#define V4L2_SUBDEV_FL_HAS_EVENTS               (1U << 3)
 
 /* Each instance of a subdev driver should create this struct, either
    stand-alone or embedded in a larger struct.
  */
 struct v4l2_subdev {
+#if defined(CONFIG_MEDIA_CONTROLLER)
+        struct media_entity entity;
+#endif
         struct list_head list;
         struct module *owner;
         u32 flags;
@@ -453,8 +507,47 @@ struct v4l2_subdev {
         /* pointer to private data */
         void *dev_priv;
         void *host_priv;
+        /* subdev device node */
+        struct video_device devnode;
+        /* number of events to be allocated on open */
+        unsigned int nevents;
+};
+
+#define media_entity_to_v4l2_subdev(ent) \
+        container_of(ent, struct v4l2_subdev, entity)
+#define vdev_to_v4l2_subdev(vdev) \
+        container_of(vdev, struct v4l2_subdev, devnode)
+
+/*
+ * Used for storing subdev information per file handle
+ */
+struct v4l2_subdev_fh {
+        struct v4l2_fh vfh;
+#if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
+        struct v4l2_mbus_framefmt *try_fmt;
+        struct v4l2_rect *try_crop;
+#endif
 };
 
+#define to_v4l2_subdev_fh(fh)   \
+        container_of(fh, struct v4l2_subdev_fh, vfh)
+
+#if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
+static inline struct v4l2_mbus_framefmt *
+v4l2_subdev_get_try_format(struct v4l2_subdev_fh *fh, unsigned int pad)
+{
+        return &fh->try_fmt[pad];
+}
+
+static inline struct v4l2_rect *
+v4l2_subdev_get_try_crop(struct v4l2_subdev_fh *fh, unsigned int pad)
+{
+        return &fh->try_crop[pad];
+}
+#endif
+
+extern const struct v4l2_file_operations v4l2_subdev_fops;
+
 static inline void v4l2_set_subdevdata(struct v4l2_subdev *sd, void *p)
 {
         sd->dev_priv = p;
@@ -475,20 +568,8 @@ static inline void *v4l2_get_subdev_hostdata(const struct v4l2_subdev *sd)
         return sd->host_priv;
 }
 
-static inline void v4l2_subdev_init(struct v4l2_subdev *sd,
-                                        const struct v4l2_subdev_ops *ops)
-{
-        INIT_LIST_HEAD(&sd->list);
-        /* ops->core MUST be set */
-        BUG_ON(!ops || !ops->core);
-        sd->ops = ops;
-        sd->v4l2_dev = NULL;
-        sd->flags = 0;
-        sd->name[0] = '\0';
-        sd->grp_id = 0;
-        sd->dev_priv = NULL;
-        sd->host_priv = NULL;
-}
+void v4l2_subdev_init(struct v4l2_subdev *sd,
+                      const struct v4l2_subdev_ops *ops);
 
 /* Call an ops of a v4l2_subdev, doing the right checks against
    NULL pointers.
diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
new file mode 100644
index 000000000000..f87472acbc51
--- /dev/null
+++ b/include/media/videobuf2-core.h
@@ -0,0 +1,380 @@
+/*
+ * videobuf2-core.h - V4L2 driver helper framework
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *
+ * Author: Pawel Osciak <pawel@osciak.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+#ifndef _MEDIA_VIDEOBUF2_CORE_H
+#define _MEDIA_VIDEOBUF2_CORE_H
+
+#include <linux/mm_types.h>
+#include <linux/mutex.h>
+#include <linux/poll.h>
+#include <linux/videodev2.h>
+
+struct vb2_alloc_ctx;
+struct vb2_fileio_data;
+
+/**
+ * struct vb2_mem_ops - memory handling/memory allocator operations
+ * @alloc:      allocate video memory and, optionally, allocator private data,
+ *              return NULL on failure or a pointer to allocator private,
+ *              per-buffer data on success; the returned private structure
+ *              will then be passed as buf_priv argument to other ops in this
+ *              structure
+ * @put:        inform the allocator that the buffer will no longer be used;
+ *              usually will result in the allocator freeing the buffer (if
+ *              no other users of this buffer are present); the buf_priv
+ *              argument is the allocator private per-buffer structure
+ *              previously returned from the alloc callback
+ * @get_userptr: acquire userspace memory for a hardware operation; used for
+ *               USERPTR memory types; vaddr is the address passed to the
+ *               videobuf layer when queuing a video buffer of USERPTR type;
+ *               should return an allocator private per-buffer structure
+ *               associated with the buffer on success, NULL on failure;
+ *               the returned private structure will then be passed as buf_priv
+ *               argument to other ops in this structure
+ * @put_userptr: inform the allocator that a USERPTR buffer will no longer
+ *               be used
+ * @vaddr:      return a kernel virtual address to a given memory buffer
+ *              associated with the passed private structure or NULL if no
+ *              such mapping exists
+ * @cookie:     return allocator specific cookie for a given memory buffer
+ *              associated with the passed private structure or NULL if not
+ *              available
+ * @num_users:  return the current number of users of a memory buffer;
+ *              return 1 if the videobuf layer (or actually the driver using
+ *              it) is the only user
+ * @mmap:       setup a userspace mapping for a given memory buffer under
+ *              the provided virtual memory region
+ *
+ * Required ops for USERPTR types: get_userptr, put_userptr.
+ * Required ops for MMAP types: alloc, put, num_users, mmap.
+ * Required ops for read/write access types: alloc, put, num_users, vaddr
+ */
+struct vb2_mem_ops {
+        void            *(*alloc)(void *alloc_ctx, unsigned long size);
+        void            (*put)(void *buf_priv);
+
+        void            *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,
+                                        unsigned long size, int write);
+        void            (*put_userptr)(void *buf_priv);
+
+        void            *(*vaddr)(void *buf_priv);
+        void            *(*cookie)(void *buf_priv);
+
+        unsigned int    (*num_users)(void *buf_priv);
+
+        int             (*mmap)(void *buf_priv, struct vm_area_struct *vma);
+};
+
+struct vb2_plane {
+        void                    *mem_priv;
+        int                     mapped:1;
+};
+
+/**
+ * enum vb2_io_modes - queue access methods
+ * @VB2_MMAP:           driver supports MMAP with streaming API
+ * @VB2_USERPTR:        driver supports USERPTR with streaming API
+ * @VB2_READ:           driver supports read() style access
+ * @VB2_WRITE:          driver supports write() style access
+ */
+enum vb2_io_modes {
+        VB2_MMAP        = (1 << 0),
+        VB2_USERPTR     = (1 << 1),
+        VB2_READ        = (1 << 2),
+        VB2_WRITE       = (1 << 3),
+};
+
+/**
+ * enum vb2_fileio_flags - flags for selecting a mode of the file io emulator,
+ * by default the 'streaming' style is used by the file io emulator
+ * @VB2_FILEIO_READ_ONCE:       report EOF after reading the first buffer
+ * @VB2_FILEIO_WRITE_IMMEDIATELY:       queue buffer after each write() call
+ */
+enum vb2_fileio_flags {
+        VB2_FILEIO_READ_ONCE            = (1 << 0),
+        VB2_FILEIO_WRITE_IMMEDIATELY    = (1 << 1),
+};
+
+/**
+ * enum vb2_buffer_state - current video buffer state
+ * @VB2_BUF_STATE_DEQUEUED:     buffer under userspace control
+ * @VB2_BUF_STATE_QUEUED:       buffer queued in videobuf, but not in driver
+ * @VB2_BUF_STATE_ACTIVE:       buffer queued in driver and possibly used
+ *                              in a hardware operation
+ * @VB2_BUF_STATE_DONE:         buffer returned from driver to videobuf, but
+ *                              not yet dequeued to userspace
+ * @VB2_BUF_STATE_ERROR:        same as above, but the operation on the buffer
+ *                              has ended with an error, which will be reported
+ *                              to the userspace when it is dequeued
+ */
+enum vb2_buffer_state {
+        VB2_BUF_STATE_DEQUEUED,
+        VB2_BUF_STATE_QUEUED,
+        VB2_BUF_STATE_ACTIVE,
+        VB2_BUF_STATE_DONE,
+        VB2_BUF_STATE_ERROR,
+};
+
+struct vb2_queue;
+
+/**
+ * struct vb2_buffer - represents a video buffer
+ * @v4l2_buf:           struct v4l2_buffer associated with this buffer; can
+ *                      be read by the driver and relevant entries can be
+ *                      changed by the driver in case of CAPTURE types
+ *                      (such as timestamp)
+ * @v4l2_planes:        struct v4l2_planes associated with this buffer; can
+ *                      be read by the driver and relevant entries can be
+ *                      changed by the driver in case of CAPTURE types
+ *                      (such as bytesused); NOTE that even for single-planar
+ *                      types, the v4l2_planes[0] struct should be used
+ *                      instead of v4l2_buf for filling bytesused - drivers
+ *                      should use the vb2_set_plane_payload() function for that
+ * @vb2_queue:          the queue to which this driver belongs
+ * @num_planes:         number of planes in the buffer
+ *                      on an internal driver queue
+ * @state:              current buffer state; do not change
+ * @queued_entry:       entry on the queued buffers list, which holds all
+ *                      buffers queued from userspace
+ * @done_entry:         entry on the list that stores all buffers ready to
+ *                      be dequeued to userspace
+ * @planes:             private per-plane information; do not change
+ * @num_planes_mapped:  number of mapped planes; do not change
+ */
+struct vb2_buffer {
+        struct v4l2_buffer      v4l2_buf;
+        struct v4l2_plane       v4l2_planes[VIDEO_MAX_PLANES];
+
+        struct vb2_queue        *vb2_queue;
+
+        unsigned int            num_planes;
+
+/* Private: internal use only */
+        enum vb2_buffer_state   state;
+
+        struct list_head        queued_entry;
+        struct list_head        done_entry;
+
+        struct vb2_plane        planes[VIDEO_MAX_PLANES];
+        unsigned int            num_planes_mapped;
+};
+
+/**
+ * struct vb2_ops - driver-specific callbacks
+ *
+ * @queue_setup:        called from a VIDIOC_REQBUFS handler, before
+ *                      memory allocation; driver should return the required
+ *                      number of buffers in num_buffers, the required number
+ *                      of planes per buffer in num_planes; the size of each
+ *                      plane should be set in the sizes[] array and optional
+ *                      per-plane allocator specific context in alloc_ctxs[]
+ *                      array
+ * @wait_prepare:       release any locks taken while calling vb2 functions;
+ *                      it is called before an ioctl needs to wait for a new
+ *                      buffer to arrive; required to avoid a deadlock in
+ *                      blocking access type
+ * @wait_finish:        reacquire all locks released in the previous callback;
+ *                      required to continue operation after sleeping while
+ *                      waiting for a new buffer to arrive
+ * @buf_init:           called once after allocating a buffer (in MMAP case)
+ *                      or after acquiring a new USERPTR buffer; drivers may
+ *                      perform additional buffer-related initialization;
+ *                      initialization failure (return != 0) will prevent
+ *                      queue setup from completing successfully; optional
+ * @buf_prepare:        called every time the buffer is queued from userspace;
+ *                      drivers may perform any initialization required before
+ *                      each hardware operation in this callback;
+ *                      if an error is returned, the buffer will not be queued
+ *                      in driver; optional
+ * @buf_finish:         called before every dequeue of the buffer back to
+ *                      userspace; drivers may perform any operations required
+ *                      before userspace accesses the buffer; optional
+ * @buf_cleanup:        called once before the buffer is freed; drivers may
+ *                      perform any additional cleanup; optional
+ * @start_streaming:    called once before entering 'streaming' state; enables
+ *                      driver to receive buffers over buf_queue() callback
+ * @stop_streaming:     called when 'streaming' state must be disabled; driver
+ *                      should stop any DMA transactions or wait until they
+ *                      finish and give back all buffers it got from buf_queue()
+ *                      callback; may use vb2_wait_for_all_buffers() function
+ * @buf_queue:          passes buffer vb to the driver; driver may start
+ *                      hardware operation on this buffer; driver should give
+ *                      the buffer back by calling vb2_buffer_done() function
+ */
+struct vb2_ops {
+        int (*queue_setup)(struct vb2_queue *q, unsigned int *num_buffers,
+                           unsigned int *num_planes, unsigned long sizes[],
+                           void *alloc_ctxs[]);
+
+        void (*wait_prepare)(struct vb2_queue *q);
+        void (*wait_finish)(struct vb2_queue *q);
+
+        int (*buf_init)(struct vb2_buffer *vb);
+        int (*buf_prepare)(struct vb2_buffer *vb);
+        int (*buf_finish)(struct vb2_buffer *vb);
+        void (*buf_cleanup)(struct vb2_buffer *vb);
+
+        int (*start_streaming)(struct vb2_queue *q);
+        int (*stop_streaming)(struct vb2_queue *q);
+
+        void (*buf_queue)(struct vb2_buffer *vb);
+};
+
+/**
+ * struct vb2_queue - a videobuf queue
+ *
+ * @type:       queue type (see V4L2_BUF_TYPE_* in linux/videodev2.h
+ * @io_modes:   supported io methods (see vb2_io_modes enum)
+ * @io_flags:   additional io flags (see vb2_fileio_flags enum)
+ * @ops:        driver-specific callbacks
+ * @mem_ops:    memory allocator specific callbacks
+ * @drv_priv:   driver private data
+ * @buf_struct_size: size of the driver-specific buffer structure;
+ *              "0" indicates the driver doesn't want to use a custom buffer
+ *              structure type, so sizeof(struct vb2_buffer) will is used
+ *
+ * @memory:     current memory type used
+ * @bufs:       videobuf buffer structures
+ * @num_buffers: number of allocated/used buffers
+ * @queued_list: list of buffers currently queued from userspace
+ * @queued_count: number of buffers owned by the driver
+ * @done_list:  list of buffers ready to be dequeued to userspace
+ * @done_lock:  lock to protect done_list list
+ * @done_wq:    waitqueue for processes waiting for buffers ready to be dequeued
+ * @alloc_ctx:  memory type/allocator-specific contexts for each plane
+ * @streaming:  current streaming state
+ * @fileio:     file io emulator internal data, used only if emulator is active
+ */
+struct vb2_queue {
+        enum v4l2_buf_type              type;
+        unsigned int                    io_modes;
+        unsigned int                    io_flags;
+
+        const struct vb2_ops            *ops;
+        const struct vb2_mem_ops        *mem_ops;
+        void                            *drv_priv;
+        unsigned int                    buf_struct_size;
+
+/* private: internal use only */
+        enum v4l2_memory                memory;
+        struct vb2_buffer               *bufs[VIDEO_MAX_FRAME];
+        unsigned int                    num_buffers;
+
+        struct list_head                queued_list;
+
+        atomic_t                        queued_count;
+        struct list_head                done_list;
+        spinlock_t                      done_lock;
+        wait_queue_head_t               done_wq;
+
+        void                            *alloc_ctx[VIDEO_MAX_PLANES];
+
+        unsigned int                    streaming:1;
+
+        struct vb2_fileio_data          *fileio;
+};
+
+void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no);
+void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no);
+
+void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state);
+int vb2_wait_for_all_buffers(struct vb2_queue *q);
+
+int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);
+int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req);
+
+int vb2_queue_init(struct vb2_queue *q);
+
+void vb2_queue_release(struct vb2_queue *q);
+
+int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b);
+int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking);
+
+int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);
+int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);
+
+int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);
+unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait);
+size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
+                loff_t *ppos, int nonblock);
+size_t vb2_write(struct vb2_queue *q, char __user *data, size_t count,
+                loff_t *ppos, int nonblock);
+
+/**
+ * vb2_is_streaming() - return streaming status of the queue
+ * @q:          videobuf queue
+ */
+static inline bool vb2_is_streaming(struct vb2_queue *q)
+{
+        return q->streaming;
+}
+
+/**
+ * vb2_is_busy() - return busy status of the queue
+ * @q:          videobuf queue
+ *
+ * This function checks if queue has any buffers allocated.
+ */
+static inline bool vb2_is_busy(struct vb2_queue *q)
+{
+        return (q->num_buffers > 0);
+}
+
+/**
+ * vb2_get_drv_priv() - return driver private data associated with the queue
+ * @q:          videobuf queue
+ */
+static inline void *vb2_get_drv_priv(struct vb2_queue *q)
+{
+        return q->drv_priv;
+}
+
+/**
+ * vb2_set_plane_payload() - set bytesused for the plane plane_no
+ * @vb:         buffer for which plane payload should be set
+ * @plane_no:   plane number for which payload should be set
+ * @size:       payload in bytes
+ */
+static inline void vb2_set_plane_payload(struct vb2_buffer *vb,
+                                 unsigned int plane_no, unsigned long size)
+{
+        if (plane_no < vb->num_planes)
+                vb->v4l2_planes[plane_no].bytesused = size;
+}
+
+/**
+ * vb2_get_plane_payload() - get bytesused for the plane plane_no
+ * @vb:         buffer for which plane payload should be set
+ * @plane_no:   plane number for which payload should be set
+ * @size:       payload in bytes
+ */
+static inline unsigned long vb2_get_plane_payload(struct vb2_buffer *vb,
+                                 unsigned int plane_no)
+{
+        if (plane_no < vb->num_planes)
+                return vb->v4l2_planes[plane_no].bytesused;
+        return 0;
+}
+
+/**
+ * vb2_plane_size() - return plane size in bytes
+ * @vb:         buffer for which plane size should be returned
+ * @plane_no:   plane number for which size should be returned
+ */
+static inline unsigned long
+vb2_plane_size(struct vb2_buffer *vb, unsigned int plane_no)
+{
+        if (plane_no < vb->num_planes)
+                return vb->v4l2_planes[plane_no].length;
+        return 0;
+}
+
+#endif /* _MEDIA_VIDEOBUF2_CORE_H */
diff --git a/include/media/videobuf2-dma-contig.h b/include/media/videobuf2-dma-contig.h
new file mode 100644
index 000000000000..7e6c68b23773
--- /dev/null
+++ b/include/media/videobuf2-dma-contig.h
@@ -0,0 +1,32 @@
+/*
+ * videobuf2-dma-coherent.h - DMA coherent memory allocator for videobuf2
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *
+ * Author: Pawel Osciak <pawel@osciak.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#ifndef _MEDIA_VIDEOBUF2_DMA_COHERENT_H
+#define _MEDIA_VIDEOBUF2_DMA_COHERENT_H
+
+#include <media/videobuf2-core.h>
+#include <linux/dma-mapping.h>
+
+static inline dma_addr_t
+vb2_dma_contig_plane_paddr(struct vb2_buffer *vb, unsigned int plane_no)
+{
+        dma_addr_t *paddr = vb2_plane_cookie(vb, plane_no);
+
+        return *paddr;
+}
+
+void *vb2_dma_contig_init_ctx(struct device *dev);
+void vb2_dma_contig_cleanup_ctx(void *alloc_ctx);
+
+extern const struct vb2_mem_ops vb2_dma_contig_memops;
+
+#endif
diff --git a/include/media/videobuf2-dma-sg.h b/include/media/videobuf2-dma-sg.h
new file mode 100644
index 000000000000..0038526b8ef7
--- /dev/null
+++ b/include/media/videobuf2-dma-sg.h
@@ -0,0 +1,32 @@
+/*
+ * videobuf2-dma-sg.h - DMA scatter/gather memory allocator for videobuf2
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#ifndef _MEDIA_VIDEOBUF2_DMA_SG_H
+#define _MEDIA_VIDEOBUF2_DMA_SG_H
+
+#include <media/videobuf2-core.h>
+
+struct vb2_dma_sg_desc {
+        unsigned long           size;
+        unsigned int            num_pages;
+        struct scatterlist      *sglist;
+};
+
+static inline struct vb2_dma_sg_desc *vb2_dma_sg_plane_desc(
+                struct vb2_buffer *vb, unsigned int plane_no)
+{
+        return (struct vb2_dma_sg_desc *)vb2_plane_cookie(vb, plane_no);
+}
+
+extern const struct vb2_mem_ops vb2_dma_sg_memops;
+
+#endif
diff --git a/include/media/videobuf2-memops.h b/include/media/videobuf2-memops.h
new file mode 100644
index 000000000000..84e1f6c031c5
--- /dev/null
+++ b/include/media/videobuf2-memops.h
@@ -0,0 +1,45 @@
+/*
+ * videobuf2-memops.h - generic memory handling routines for videobuf2
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *
+ * Author: Pawel Osciak <pawel@osciak.com>
+ *         Marek Szyprowski <m.szyprowski@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#ifndef _MEDIA_VIDEOBUF2_MEMOPS_H
+#define _MEDIA_VIDEOBUF2_MEMOPS_H
+
+#include <media/videobuf2-core.h>
+
+/**
+ * vb2_vmarea_handler - common vma refcount tracking handler
+ * @refcount:   pointer to refcount entry in the buffer
+ * @put:        callback to function that decreases buffer refcount
+ * @arg:        argument for @put callback
+ */
+struct vb2_vmarea_handler {
+        atomic_t                *refcount;
+        void                    (*put)(void *arg);
+        void                    *arg;
+};
+
+extern const struct vm_operations_struct vb2_common_vm_ops;
+
+int vb2_get_contig_userptr(unsigned long vaddr, unsigned long size,
+                           struct vm_area_struct **res_vma, dma_addr_t *res_pa);
+
+int vb2_mmap_pfn_range(struct vm_area_struct *vma, unsigned long paddr,
+                                unsigned long size,
+                                const struct vm_operations_struct *vm_ops,
+                                void *priv);
+
+struct vm_area_struct *vb2_get_vma(struct vm_area_struct *vma);
+void vb2_put_vma(struct vm_area_struct *vma);
+
+
+#endif
diff --git a/include/media/videobuf2-vmalloc.h b/include/media/videobuf2-vmalloc.h
new file mode 100644
index 000000000000..93a76b43038d
--- /dev/null
+++ b/include/media/videobuf2-vmalloc.h
@@ -0,0 +1,20 @@
+/*
+ * videobuf2-vmalloc.h - vmalloc memory allocator for videobuf2
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *
+ * Author: Pawel Osciak <pawel@osciak.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#ifndef _MEDIA_VIDEOBUF2_VMALLOC_H
+#define _MEDIA_VIDEOBUF2_VMALLOC_H
+
+#include <media/videobuf2-core.h>
+
+extern const struct vb2_mem_ops vb2_vmalloc_memops;
+
+#endif
diff --git a/include/media/wm8775.h b/include/media/wm8775.h
index 60739c5a23ae..d0e801a9935c 100644
--- a/include/media/wm8775.h
+++ b/include/media/wm8775.h
@@ -32,4 +32,13 @@
 #define WM8775_AIN3 4
 #define WM8775_AIN4 8
 
+
+struct wm8775_platform_data {
+        /*
+         * FIXME: Instead, we should parametrize the params
+         * that need different settings between ivtv, pvrusb2, and Nova-S
+         */
+        bool is_nova_s;
+};
+
 #endif
diff --git a/include/staging/altera.h b/include/staging/altera.h
new file mode 100644
index 000000000000..94c0c6181daf
--- /dev/null
+++ b/include/staging/altera.h
@@ -0,0 +1,49 @@
+/*
+ * altera.h
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@netup.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _ALTERA_H_
+#define _ALTERA_H_
+
+struct altera_config {
+        void *dev;
+        u8 *action;
+        int (*jtag_io) (void *dev, int tms, int tdi, int tdo);
+};
+
+#if defined(CONFIG_ALTERA_STAPL) || \
+                (defined(CONFIG_ALTERA_STAPL_MODULE) && defined(MODULE))
+
+extern int altera_init(struct altera_config *config, const struct firmware *fw);
+#else
+
+static inline int altera_init(struct altera_config *config,
+                                                const struct firmware *fw)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return 0;
+}
+#endif /* CONFIG_ALTERA_STAPL */
+
+#endif /* _ALTERA_H_ */