306 files changed, 5675 insertions, 2797 deletions

diff --git a/CREDITS b/CREDITS
index b50db1767554..abe05a0be4ed 100644
--- a/CREDITS
+++ b/CREDITS
@@ -369,10 +369,10 @@ P: 1024/8462A731 4C 55 86 34 44 59 A7 99  2B 97 88 4A 88 9A 0D 97
 D: sun4 port, Sparc hacker
 
 N: Hugh Blemings
-E: hugh@misc.nu
-W: http://misc.nu/hugh/
-D: Author and maintainer of the Keyspan USB to Serial drivers
-S: Po Box 234
+E: hugh@blemings.org
+W: http://blemings.org/hugh
+D: Original author of the Keyspan USB to serial drivers, random PowerPC hacker
+S: PO Box 234
 S: Belconnen ACT 2616
 S: Australia
 
diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt
index dd84ea3c10da..84da2a4ba25a 100644
--- a/Documentation/filesystems/ubifs.txt
+++ b/Documentation/filesystems/ubifs.txt
@@ -95,6 +95,9 @@ no_chk_data_crc		skip checking of CRCs on data nodes in order to
                         of this option is that corruption of the contents
                         of a file can go unnoticed.
 chk_data_crc (*)        do not skip checking CRCs on data nodes
+compr=none              override default compressor and set it to "none"
+compr=lzo               override default compressor and set it to "lzo"
+compr=zlib              override default compressor and set it to "zlib"
 
 
 Quick usage instructions
diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt
index b880ce5dbd33..824699174436 100644
--- a/Documentation/ioctl/ioctl-number.txt
+++ b/Documentation/ioctl/ioctl-number.txt
@@ -97,6 +97,7 @@ Code	Seq#	Include File		Comments
                                         <http://linux01.gwdg.de/~alatham/ppdd.html>
 'M'     all     linux/soundcard.h
 'N'     00-1F   drivers/usb/scanner.h
+'O'     00-02   include/mtd/ubi-user.h UBI
 'P'     all     linux/soundcard.h
 'Q'     all     linux/soundcard.h
 'R'     00-1F   linux/random.h
@@ -142,6 +143,9 @@ Code	Seq#	Include File		Comments
 'n'     00-7F   linux/ncp_fs.h
 'n'     E0-FF   video/matrox.h          matroxfb
 'o'     00-1F   fs/ocfs2/ocfs2_fs.h     OCFS2
+'o'     00-03   include/mtd/ubi-user.h  conflict! (OCFS2 and UBI overlaps)
+'o'     40-41   include/mtd/ubi-user.h  UBI
+'o'     01-A1   include/linux/dvb/*.h DVB
 'p'     00-0F   linux/phantom.h         conflict! (OpenHaptics needs this)
 'p'     00-3F   linux/mc146818rtc.h     conflict!
 'p'     40-7F   linux/nvram.h
diff --git a/Documentation/kbuild/00-INDEX b/Documentation/kbuild/00-INDEX
index 114644285454..e8d2b6d83a3d 100644
--- a/Documentation/kbuild/00-INDEX
+++ b/Documentation/kbuild/00-INDEX
@@ -1,5 +1,9 @@
 00-INDEX
-        - this file: info on the kernel build process
+        - this file: info on the kernel build process
+kbuild.txt
+        - developer information on kbuild
+kconfig.txt
+        - usage help for make *config
 kconfig-language.txt
         - specification of Config Language, the language in Kconfig files
 makefiles.txt
diff --git a/Documentation/kbuild/kbuild.txt b/Documentation/kbuild/kbuild.txt
new file mode 100644
index 000000000000..51771847e816
--- /dev/null
+++ b/Documentation/kbuild/kbuild.txt
@@ -0,0 +1,126 @@
+Environment variables
+
+KCPPFLAGS
+--------------------------------------------------
+Additional options to pass when preprocessing. The preprocessing options
+will be used in all cases where kbuild do preprocessing including
+building C files and assembler files.
+
+KAFLAGS
+--------------------------------------------------
+Additional options to the assembler.
+
+KCFLAGS
+--------------------------------------------------
+Additional options to the C compiler.
+
+KBUILD_VERBOSE
+--------------------------------------------------
+Set the kbuild verbosity. Can be assinged same values as "V=...".
+See make help for the full list.
+Setting "V=..." takes precedence over KBUILD_VERBOSE.
+
+KBUILD_EXTMOD
+--------------------------------------------------
+Set the directory to look for the kernel source when building external
+modules.
+The directory can be specified in several ways:
+1) Use "M=..." on the command line
+2) Environmnet variable KBUILD_EXTMOD
+3) Environmnet variable SUBDIRS
+The possibilities are listed in the order they take precedence.
+Using "M=..." will always override the others.
+
+KBUILD_OUTPUT
+--------------------------------------------------
+Specify the output directory when building the kernel.
+The output directory can also be specificed using "O=...".
+Setting "O=..." takes precedence over KBUILD_OUTPUT
+
+ARCH
+--------------------------------------------------
+Set ARCH to the architecture to be built.
+In most cases the name of the architecture is the same as the
+directory name found in the arch/ directory.
+But some architectures suach as x86 and sparc has aliases.
+x86: i386 for 32 bit, x86_64 for 64 bit
+sparc: sparc for 32 bit, sparc64 for 64 bit
+
+CROSS_COMPILE
+--------------------------------------------------
+Specify an optional fixed part of the binutils filename.
+CROSS_COMPILE can be a part of the filename or the full path.
+
+CROSS_COMPILE is also used for ccache is some setups.
+
+CF
+--------------------------------------------------
+Additional options for sparse.
+CF is often used on the command-line like this:
+
+    make CF=-Wbitwise C=2
+
+INSTALL_PATH
+--------------------------------------------------
+INSTALL_PATH specifies where to place the updated kernel and system map
+images. Default is /boot, but you can set it to other values
+
+
+MODLIB
+--------------------------------------------------
+Specify where to install modules.
+The default value is:
+
+     $(INSTALL_MOD_PATH)/lib/modules/$(KERNELRELEASE)
+
+The value can be overridden in which case the default value is ignored.
+
+INSTALL_MOD_PATH
+--------------------------------------------------
+INSTALL_MOD_PATH specifies a prefix to MODLIB for module directory
+relocations required by build roots.  This is not defined in the
+makefile but the argument can be passed to make if needed.
+
+INSTALL_MOD_STRIP
+--------------------------------------------------
+INSTALL_MOD_STRIP, if defined, will cause modules to be
+stripped after they are installed.  If INSTALL_MOD_STRIP is '1', then
+the default option --strip-debug will be used.  Otherwise,
+INSTALL_MOD_STRIP will used as the options to the strip command.
+
+INSTALL_FW_PATH
+--------------------------------------------------
+INSTALL_FW_PATH specify where to install the firmware blobs.
+The default value is:
+
+    $(INSTALL_MOD_PATH)/lib/firmware
+
+The value can be overridden in which case the default value is ignored.
+
+INSTALL_HDR_PATH
+--------------------------------------------------
+INSTALL_HDR_PATH specify where to install user space headers when
+executing "make headers_*".
+The default value is:
+
+    $(objtree)/usr
+
+$(objtree) is the directory where output files are saved.
+The output directory is often set using "O=..." on the commandline.
+
+The value can be overridden in which case the default value is ignored.
+
+KBUILD_MODPOST_WARN
+--------------------------------------------------
+KBUILD_MODPOST_WARN can be set to avoid error out in case of undefined
+symbols in the final module linking stage.
+
+KBUILD_MODPOST_FINAL
+--------------------------------------------------
+KBUILD_MODPOST_NOFINAL can be set to skip the final link of modules.
+This is solely usefull to speed up test compiles.
+
+KBUILD_EXTRA_SYMBOLS
+--------------------------------------------------
+For modules use symbols from another modules.
+See more details in modules.txt.
diff --git a/Documentation/kbuild/kconfig.txt b/Documentation/kbuild/kconfig.txt
new file mode 100644
index 000000000000..26a7c0a93193
--- /dev/null
+++ b/Documentation/kbuild/kconfig.txt
@@ -0,0 +1,188 @@
+This file contains some assistance for using "make *config".
+
+Use "make help" to list all of the possible configuration targets.
+
+The xconfig ('qconf') and menuconfig ('mconf') programs also
+have embedded help text.  Be sure to check it for navigation,
+search, and other general help text.
+
+======================================================================
+General
+--------------------------------------------------
+
+New kernel releases often introduce new config symbols.  Often more
+important, new kernel releases may rename config symbols.  When
+this happens, using a previously working .config file and running
+"make oldconfig" won't necessarily produce a working new kernel
+for you, so you may find that you need to see what NEW kernel
+symbols have been introduced.
+
+To see a list of new config symbols when using "make oldconfig", use
+
+        cp user/some/old.config .config
+        yes "" | make oldconfig >conf.new
+
+and the config program will list as (NEW) any new symbols that have
+unknown values.  Of course, the .config file is also updated with
+new (default) values, so you can use:
+
+        grep "(NEW)" conf.new
+
+to see the new config symbols or you can 'diff' the previous and
+new .config files to see the differences:
+
+        diff .config.old .config | less
+
+(Yes, we need something better here.)
+
+
+======================================================================
+menuconfig
+--------------------------------------------------
+
+SEARCHING for CONFIG symbols
+
+Searching in menuconfig:
+
+        The Search function searches for kernel configuration symbol
+        names, so you have to know something close to what you are
+        looking for.
+
+        Example:
+                /hotplug
+                This lists all config symbols that contain "hotplug",
+                e.g., HOTPLUG, HOTPLUG_CPU, MEMORY_HOTPLUG.
+
+        For search help, enter / followed TAB-TAB-TAB (to highlight
+        <Help>) and Enter.  This will tell you that you can also use
+        regular expressions (regexes) in the search string, so if you
+        are not interested in MEMORY_HOTPLUG, you could try
+
+                /^hotplug
+
+
+______________________________________________________________________
+Color Themes for 'menuconfig'
+
+It is possible to select different color themes using the variable
+MENUCONFIG_COLOR.  To select a theme use:
+
+        make MENUCONFIG_COLOR=<theme> menuconfig
+
+Available themes are:
+  mono       => selects colors suitable for monochrome displays
+  blackbg    => selects a color scheme with black background
+  classic    => theme with blue background. The classic look
+  bluetitle  => a LCD friendly version of classic. (default)
+
+______________________________________________________________________
+Environment variables in 'menuconfig'
+
+KCONFIG_ALLCONFIG
+--------------------------------------------------
+(partially based on lkml email from/by Rob Landley, re: miniconfig)
+--------------------------------------------------
+The allyesconfig/allmodconfig/allnoconfig/randconfig variants can
+also use the environment variable KCONFIG_ALLCONFIG as a flag or a
+filename that contains config symbols that the user requires to be
+set to a specific value.  If KCONFIG_ALLCONFIG is used without a
+filename, "make *config" checks for a file named
+"all{yes/mod/no/random}.config" (corresponding to the *config command
+that was used) for symbol values that are to be forced.  If this file
+is not found, it checks for a file named "all.config" to contain forced
+values.
+
+This enables you to create "miniature" config (miniconfig) or custom
+config files containing just the config symbols that you are interested
+in.  Then the kernel config system generates the full .config file,
+including dependencies of your miniconfig file, based on the miniconfig
+file.
+
+This 'KCONFIG_ALLCONFIG' file is a config file which contains
+(usually a subset of all) preset config symbols.  These variable
+settings are still subject to normal dependency checks.
+
+Examples:
+        KCONFIG_ALLCONFIG=custom-notebook.config make allnoconfig
+or
+        KCONFIG_ALLCONFIG=mini.config make allnoconfig
+or
+        make KCONFIG_ALLCONFIG=mini.config allnoconfig
+
+These examples will disable most options (allnoconfig) but enable or
+disable the options that are explicitly listed in the specified
+mini-config files.
+
+KCONFIG_NOSILENTUPDATE
+--------------------------------------------------
+If this variable has a non-blank value, it prevents silent kernel
+config udpates (requires explicit updates).
+
+KCONFIG_CONFIG
+--------------------------------------------------
+This environment variable can be used to specify a default kernel config
+file name to override the default name of ".config".
+
+KCONFIG_OVERWRITECONFIG
+--------------------------------------------------
+If you set KCONFIG_OVERWRITECONFIG in the environment, Kconfig will not
+break symlinks when .config is a symlink to somewhere else.
+
+KCONFIG_NOTIMESTAMP
+--------------------------------------------------
+If this environment variable exists and is non-null, the timestamp line
+in generated .config files is omitted.
+
+KCONFIG_AUTOCONFIG
+--------------------------------------------------
+This environment variable can be set to specify the path & name of the
+"auto.conf" file.  Its default value is "include/config/auto.conf".
+
+KCONFIG_AUTOHEADER
+--------------------------------------------------
+This environment variable can be set to specify the path & name of the
+"autoconf.h" (header) file.  Its default value is "include/linux/autoconf.h".
+
+______________________________________________________________________
+menuconfig User Interface Options
+----------------------------------------------------------------------
+MENUCONFIG_MODE
+--------------------------------------------------
+This mode shows all sub-menus in one large tree.
+
+Example:
+        MENUCONFIG_MODE=single_menu make menuconfig
+
+======================================================================
+xconfig
+--------------------------------------------------
+
+Searching in xconfig:
+
+        The Search function searches for kernel configuration symbol
+        names, so you have to know something close to what you are
+        looking for.
+
+        Example:
+                Ctrl-F hotplug
+        or
+                Menu: File, Search, hotplug
+
+        lists all config symbol entries that contain "hotplug" in
+        the symbol name.  In this Search dialog, you may change the
+        config setting for any of the entries that are not grayed out.
+        You can also enter a different search string without having
+        to return to the main menu.
+
+
+======================================================================
+gconfig
+--------------------------------------------------
+
+Searching in gconfig:
+
+        None (gconfig isn't maintained as well as xconfig or menuconfig);
+        however, gconfig does have a few more viewing choices than
+        xconfig does.
+
+###
diff --git a/Documentation/video4linux/CARDLIST.saa7134 b/Documentation/video4linux/CARDLIST.saa7134
index 335aef4dcaeb..b8d470596b0c 100644
--- a/Documentation/video4linux/CARDLIST.saa7134
+++ b/Documentation/video4linux/CARDLIST.saa7134
@@ -152,3 +152,4 @@
 151 -> ADS Tech Instant HDTV                    [1421:0380]
 152 -> Asus Tiger Rev:1.00                      [1043:4857]
 153 -> Kworld Plus TV Analog Lite PCI           [17de:7128]
+154 -> Avermedia AVerTV GO 007 FM Plus          [1461:f31d]
diff --git a/Documentation/video4linux/si470x.txt b/Documentation/video4linux/si470x.txt
index 11c5fd22a332..49679e6aaa76 100644
--- a/Documentation/video4linux/si470x.txt
+++ b/Documentation/video4linux/si470x.txt
@@ -41,6 +41,7 @@ chips are known to work:
 - 10c4:818a: Silicon Labs USB FM Radio Reference Design
 - 06e1:a155: ADS/Tech FM Radio Receiver (formerly Instant FM Music) (RDX-155-EF)
 - 1b80:d700: KWorld USB FM Radio SnapMusic Mobile 700 (FM700)
+- 10c5:819a: DealExtreme USB Radio
 
 
 Software
diff --git a/Documentation/video4linux/v4l2-framework.txt b/Documentation/video4linux/v4l2-framework.txt
index eeae76c22a93..ff124374e9ba 100644
--- a/Documentation/video4linux/v4l2-framework.txt
+++ b/Documentation/video4linux/v4l2-framework.txt
@@ -184,7 +184,7 @@ may be NULL if the subdev driver does not support anything from that category.
 It looks like this:
 
 struct v4l2_subdev_core_ops {
-        int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip);
+        int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);
         int (*log_status)(struct v4l2_subdev *sd);
         int (*init)(struct v4l2_subdev *sd, u32 val);
         ...
@@ -390,16 +390,18 @@ allocated memory.
 
 You should also set these fields:
 
-- parent: set to the parent device (same device as was used to register
-  v4l2_device).
+- v4l2_dev: set to the v4l2_device parent device.
 - name: set to something descriptive and unique.
-- fops: set to the file_operations struct.
+- fops: set to the v4l2_file_operations struct.
 - ioctl_ops: if you use the v4l2_ioctl_ops to simplify ioctl maintenance
   (highly recommended to use this and it might become compulsory in the
   future!), then set this to your v4l2_ioctl_ops struct.
 
-If you use v4l2_ioctl_ops, then you should set .unlocked_ioctl to
-__video_ioctl2 or .ioctl to video_ioctl2 in your file_operations struct.
+If you use v4l2_ioctl_ops, then you should set either .unlocked_ioctl or
+.ioctl to video_ioctl2 in your v4l2_file_operations struct.
+
+The v4l2_file_operations struct is a subset of file_operations. The main
+difference is that the inode argument is omitted since it is never used.
 
 
 video_device registration
@@ -410,7 +412,7 @@ for you.
 
         err = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
         if (err) {
-                video_device_release(vdev); // or kfree(my_vdev);
+                video_device_release(vdev); /* or kfree(my_vdev); */
                 return err;
         }
 
@@ -516,5 +518,4 @@ void *video_drvdata(struct file *file);
 
 You can go from a video_device struct to the v4l2_device struct using:
 
-struct v4l2_device *v4l2_dev = dev_get_drvdata(vdev->parent);
-
+struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
diff --git a/Makefile b/Makefile
index d13a9694e159..f9006663f01e 100644
--- a/Makefile
+++ b/Makefile
@@ -321,7 +321,8 @@ KALLSYMS	= scripts/kallsyms
 PERL            = perl
 CHECK           = sparse
 
-CHECKFLAGS     := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise $(CF)
+CHECKFLAGS     := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \
+                  -Wbitwise -Wno-return-void $(CF)
 MODFLAGS        = -DMODULE
 CFLAGS_MODULE   = $(MODFLAGS)
 AFLAGS_MODULE   = $(MODFLAGS)
diff --git a/README b/README
index 159912cf5155..90a07658ede1 100644
--- a/README
+++ b/README
@@ -52,11 +52,11 @@ DOCUMENTATION:
 
  - The Documentation/DocBook/ subdirectory contains several guides for
    kernel developers and users.  These guides can be rendered in a
-   number of formats:  PostScript (.ps), PDF, and HTML, among others.
-   After installation, "make psdocs", "make pdfdocs", or "make htmldocs"
-   will render the documentation in the requested format.
+   number of formats:  PostScript (.ps), PDF, HTML, & man-pages, among others.
+   After installation, "make psdocs", "make pdfdocs", "make htmldocs",
+   or "make mandocs" will render the documentation in the requested format.
 
-INSTALLING the kernel:
+INSTALLING the kernel source:
 
  - If you install the full sources, put the kernel tarball in a
    directory where you have permissions (eg. your home directory) and
@@ -187,14 +187,9 @@ CONFIGURING the kernel:
         "make randconfig"  Create a ./.config file by setting symbol
                            values to random values.
 
-   The allyesconfig/allmodconfig/allnoconfig/randconfig variants can
-   also use the environment variable KCONFIG_ALLCONFIG to specify a
-   filename that contains config options that the user requires to be
-   set to a specific value.  If KCONFIG_ALLCONFIG=filename is not used,
-   "make *config" checks for a file named "all{yes/mod/no/random}.config"
-   for symbol values that are to be forced.  If this file is not found,
-   it checks for a file named "all.config" to contain forced values.
-   
+   You can find more information on using the Linux kernel config tools
+   in Documentation/kbuild/make-configs.txt.
+
         NOTES on "make config":
         - having unnecessary drivers will make the kernel bigger, and can
           under some circumstances lead to problems: probing for a
@@ -231,6 +226,19 @@ COMPILING the kernel:
  - If you configured any of the parts of the kernel as `modules', you
    will also have to do "make modules_install".
 
+ - Verbose kernel compile/build output:
+
+   Normally the kernel build system runs in a fairly quiet mode (but not
+   totally silent).  However, sometimes you or other kernel developers need
+   to see compile, link, or other commands exactly as they are executed.
+   For this, use "verbose" build mode.  This is done by inserting
+   "V=1" in the "make" command.  E.g.:
+
+        make V=1 all
+
+   To have the build system also tell the reason for the rebuild of each
+   target, use "V=2".  The default is "V=0".
+
  - Keep a backup kernel handy in case something goes wrong.  This is 
    especially true for the development releases, since each new release
    contains new code which has not been debugged.  Make sure you keep a
diff --git a/arch/alpha/kernel/Makefile b/arch/alpha/kernel/Makefile
index ac706c1d7ada..b4697759a123 100644
--- a/arch/alpha/kernel/Makefile
+++ b/arch/alpha/kernel/Makefile
@@ -8,7 +8,7 @@ EXTRA_CFLAGS	:= -Werror -Wno-sign-compare
 
 obj-y    := entry.o traps.o process.o init_task.o osf_sys.o irq.o \
             irq_alpha.o signal.o setup.o ptrace.o time.o \
-            alpha_ksyms.o systbls.o err_common.o io.o
+            alpha_ksyms.o systbls.o err_common.o io.o binfmt_loader.o
 
 obj-$(CONFIG_VGA_HOSE)  += console.o
 obj-$(CONFIG_SMP)       += smp.o
diff --git a/arch/alpha/kernel/binfmt_loader.c b/arch/alpha/kernel/binfmt_loader.c
new file mode 100644
index 000000000000..4a0af906b00a
--- /dev/null
+++ b/arch/alpha/kernel/binfmt_loader.c
@@ -0,0 +1,51 @@
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/mm_types.h>
+#include <linux/binfmts.h>
+#include <linux/a.out.h>
+
+static int load_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+{
+        struct exec *eh = (struct exec *)bprm->buf;
+        unsigned long loader;
+        struct file *file;
+        int retval;
+
+        if (eh->fh.f_magic != 0x183 || (eh->fh.f_flags & 0x3000) != 0x3000)
+                return -ENOEXEC;
+
+        if (bprm->loader)
+                return -ENOEXEC;
+
+        allow_write_access(bprm->file);
+        fput(bprm->file);
+        bprm->file = NULL;
+
+        loader = bprm->vma->vm_end - sizeof(void *);
+
+        file = open_exec("/sbin/loader");
+        retval = PTR_ERR(file);
+        if (IS_ERR(file))
+                return retval;
+
+        /* Remember if the application is TASO.  */
+        bprm->taso = eh->ah.entry < 0x100000000UL;
+
+        bprm->file = file;
+        bprm->loader = loader;
+        retval = prepare_binprm(bprm);
+        if (retval < 0)
+                return retval;
+        return search_binary_handler(bprm,regs);
+}
+
+static struct linux_binfmt loader_format = {
+        .load_binary    = load_binary,
+};
+
+static int __init init_loader_binfmt(void)
+{
+        return register_binfmt(&loader_format);
+}
+arch_initcall(init_loader_binfmt);
diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index 65c10a42c88f..f0ebb342409d 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -93,13 +93,14 @@ void ia64_account_on_switch(struct task_struct *prev, struct task_struct *next)
         now = ia64_get_itc();
 
         delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));
-        account_system_time(prev, 0, delta_stime);
-        account_system_time_scaled(prev, delta_stime);
+        if (idle_task(smp_processor_id()) != prev)
+                account_system_time(prev, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
 
         if (pi->ac_utime) {
                 delta_utime = cycle_to_cputime(pi->ac_utime);
-                account_user_time(prev, delta_utime);
-                account_user_time_scaled(prev, delta_utime);
+                account_user_time(prev, delta_utime, delta_utime);
         }
 
         pi->ac_stamp = ni->ac_stamp = now;
@@ -122,8 +123,10 @@ void account_system_vtime(struct task_struct *tsk)
         now = ia64_get_itc();
 
         delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));
-        account_system_time(tsk, 0, delta_stime);
-        account_system_time_scaled(tsk, delta_stime);
+        if (irq_count() || idle_task(smp_processor_id()) != tsk)
+                account_system_time(tsk, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
         ti->ac_stime = 0;
 
         ti->ac_stamp = now;
@@ -143,8 +146,7 @@ void account_process_tick(struct task_struct *p, int user_tick)
 
         if (ti->ac_utime) {
                 delta_utime = cycle_to_cputime(ti->ac_utime);
-                account_user_time(p, delta_utime);
-                account_user_time_scaled(p, delta_utime);
+                account_user_time(p, delta_utime, delta_utime);
                 ti->ac_utime = 0;
         }
 }
diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig
index 836fb66f080d..c825bde17cb3 100644
--- a/arch/m68k/Kconfig
+++ b/arch/m68k/Kconfig
@@ -280,7 +280,6 @@ config M68060
 
 config MMU_MOTOROLA
         bool
-        depends on MMU && !MMU_SUN3
 
 config MMU_SUN3
         bool
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 51b201ddf9a1..fb7049c054c0 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -33,6 +33,7 @@
 #include <linux/mqueue.h>
 #include <linux/hardirq.h>
 #include <linux/utsname.h>
+#include <linux/kernel_stat.h>
 
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 99f1ddd68582..c9564031a2a9 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -256,8 +256,10 @@ void account_system_vtime(struct task_struct *tsk)
                 delta += sys_time;
                 get_paca()->system_time = 0;
         }
-        account_system_time(tsk, 0, delta);
-        account_system_time_scaled(tsk, deltascaled);
+        if (in_irq() || idle_task(smp_processor_id()) != tsk)
+                account_system_time(tsk, 0, delta, deltascaled);
+        else
+                account_idle_time(delta);
         per_cpu(cputime_last_delta, smp_processor_id()) = delta;
         per_cpu(cputime_scaled_last_delta, smp_processor_id()) = deltascaled;
         local_irq_restore(flags);
@@ -275,10 +277,8 @@ void account_process_tick(struct task_struct *tsk, int user_tick)
 
         utime = get_paca()->user_time;
         get_paca()->user_time = 0;
-        account_user_time(tsk, utime);
-
         utimescaled = cputime_to_scaled(utime);
-        account_user_time_scaled(tsk, utimescaled);
+        account_user_time(tsk, utime, utimescaled);
 }
 
 /*
@@ -338,8 +338,12 @@ void calculate_steal_time(void)
         tb = mftb();
         purr = mfspr(SPRN_PURR);
         stolen = (tb - pme->tb) - (purr - pme->purr);
-        if (stolen > 0)
-                account_steal_time(current, stolen);
+        if (stolen > 0) {
+                if (idle_task(smp_processor_id()) != current)
+                        account_steal_time(stolen);
+                else
+                        account_idle_time(stolen);
+        }
         pme->tb = tb;
         pme->purr = purr;
 }
diff --git a/arch/s390/include/asm/cpu.h b/arch/s390/include/asm/cpu.h
index e5a6a9ba3adf..d60a2eefb17b 100644
--- a/arch/s390/include/asm/cpu.h
+++ b/arch/s390/include/asm/cpu.h
@@ -14,7 +14,6 @@
 
 struct s390_idle_data {
         spinlock_t lock;
-        unsigned int in_idle;
         unsigned long long idle_count;
         unsigned long long idle_enter;
         unsigned long long idle_time;
@@ -22,12 +21,12 @@ struct s390_idle_data {
 
 DECLARE_PER_CPU(struct s390_idle_data, s390_idle);
 
-void s390_idle_leave(void);
+void vtime_start_cpu(void);
 
 static inline void s390_idle_check(void)
 {
-        if ((&__get_cpu_var(s390_idle))->in_idle)
-                s390_idle_leave();
+        if ((&__get_cpu_var(s390_idle))->idle_enter != 0ULL)
+                vtime_start_cpu();
 }
 
 #endif /* _ASM_S390_CPU_H_ */
diff --git a/arch/s390/include/asm/cputime.h b/arch/s390/include/asm/cputime.h
index 133ce054fc89..521726430afa 100644
--- a/arch/s390/include/asm/cputime.h
+++ b/arch/s390/include/asm/cputime.h
@@ -11,7 +11,7 @@
 
 #include <asm/div64.h>
 
-/* We want to use micro-second resolution. */
+/* We want to use full resolution of the CPU timer: 2**-12 micro-seconds. */
 
 typedef unsigned long long cputime_t;
 typedef unsigned long long cputime64_t;
@@ -53,9 +53,9 @@ __div(unsigned long long n, unsigned int base)
 #define cputime_ge(__a, __b)            ((__a) >= (__b))
 #define cputime_lt(__a, __b)            ((__a) <  (__b))
 #define cputime_le(__a, __b)            ((__a) <= (__b))
-#define cputime_to_jiffies(__ct)        (__div((__ct), 1000000 / HZ))
+#define cputime_to_jiffies(__ct)        (__div((__ct), 4096000000ULL / HZ))
 #define cputime_to_scaled(__ct)         (__ct)
-#define jiffies_to_cputime(__hz)        ((cputime_t)(__hz) * (1000000 / HZ))
+#define jiffies_to_cputime(__hz)        ((cputime_t)(__hz) * (4096000000ULL / HZ))
 
 #define cputime64_zero                  (0ULL)
 #define cputime64_add(__a, __b)         ((__a) + (__b))
@@ -64,7 +64,7 @@ __div(unsigned long long n, unsigned int base)
 static inline u64
 cputime64_to_jiffies64(cputime64_t cputime)
 {
-        do_div(cputime, 1000000 / HZ);
+        do_div(cputime, 4096000000ULL / HZ);
         return cputime;
 }
 
@@ -74,13 +74,13 @@ cputime64_to_jiffies64(cputime64_t cputime)
 static inline unsigned int
 cputime_to_msecs(const cputime_t cputime)
 {
-        return __div(cputime, 1000);
+        return __div(cputime, 4096000);
 }
 
 static inline cputime_t
 msecs_to_cputime(const unsigned int m)
 {
-        return (cputime_t) m * 1000;
+        return (cputime_t) m * 4096000;
 }
 
 /*
@@ -89,13 +89,13 @@ msecs_to_cputime(const unsigned int m)
 static inline unsigned int
 cputime_to_secs(const cputime_t cputime)
 {
-        return __div(cputime, 1000000);
+        return __div(cputime, 2048000000) >> 1;
 }
 
 static inline cputime_t
 secs_to_cputime(const unsigned int s)
 {
-        return (cputime_t) s * 1000000;
+        return (cputime_t) s * 4096000000ULL;
 }
 
 /*
@@ -104,7 +104,7 @@ secs_to_cputime(const unsigned int s)
 static inline cputime_t
 timespec_to_cputime(const struct timespec *value)
 {
-        return value->tv_nsec / 1000 + (u64) value->tv_sec * 1000000;
+        return value->tv_nsec * 4096 / 1000 + (u64) value->tv_sec * 4096000000ULL;
 }
 
 static inline void
@@ -114,12 +114,12 @@ cputime_to_timespec(const cputime_t cputime, struct timespec *value)
         register_pair rp;
 
         rp.pair = cputime >> 1;
-        asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));
-        value->tv_nsec = rp.subreg.even * 1000;
+        asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));
+        value->tv_nsec = rp.subreg.even * 1000 / 4096;
         value->tv_sec = rp.subreg.odd;
 #else
-        value->tv_nsec = (cputime % 1000000) * 1000;
-        value->tv_sec = cputime / 1000000;
+        value->tv_nsec = (cputime % 4096000000ULL) * 1000 / 4096;
+        value->tv_sec = cputime / 4096000000ULL;
 #endif
 }
 
@@ -131,7 +131,7 @@ cputime_to_timespec(const cputime_t cputime, struct timespec *value)
 static inline cputime_t
 timeval_to_cputime(const struct timeval *value)
 {
-        return value->tv_usec + (u64) value->tv_sec * 1000000;
+        return value->tv_usec * 4096 + (u64) value->tv_sec * 4096000000ULL;
 }
 
 static inline void
@@ -141,12 +141,12 @@ cputime_to_timeval(const cputime_t cputime, struct timeval *value)
         register_pair rp;
 
         rp.pair = cputime >> 1;
-        asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));
-        value->tv_usec = rp.subreg.even;
+        asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));
+        value->tv_usec = rp.subreg.even / 4096;
         value->tv_sec = rp.subreg.odd;
 #else
-        value->tv_usec = cputime % 1000000;
-        value->tv_sec = cputime / 1000000;
+        value->tv_usec = cputime % 4096000000ULL;
+        value->tv_sec = cputime / 4096000000ULL;
 #endif
 }
 
@@ -156,13 +156,13 @@ cputime_to_timeval(const cputime_t cputime, struct timeval *value)
 static inline clock_t
 cputime_to_clock_t(cputime_t cputime)
 {
-        return __div(cputime, 1000000 / USER_HZ);
+        return __div(cputime, 4096000000ULL / USER_HZ);
 }
 
 static inline cputime_t
 clock_t_to_cputime(unsigned long x)
 {
-        return (cputime_t) x * (1000000 / USER_HZ);
+        return (cputime_t) x * (4096000000ULL / USER_HZ);
 }
 
 /*
@@ -171,7 +171,7 @@ clock_t_to_cputime(unsigned long x)
 static inline clock_t
 cputime64_to_clock_t(cputime64_t cputime)
 {
-       return __div(cputime, 1000000 / USER_HZ);
+       return __div(cputime, 4096000000ULL / USER_HZ);
 }
 
 #endif /* _S390_CPUTIME_H */
diff --git a/arch/s390/include/asm/lowcore.h b/arch/s390/include/asm/lowcore.h
index 0bc51d52a899..ffdef5fe8587 100644
--- a/arch/s390/include/asm/lowcore.h
+++ b/arch/s390/include/asm/lowcore.h
@@ -67,11 +67,11 @@
 #define __LC_SYNC_ENTER_TIMER           0x248
 #define __LC_ASYNC_ENTER_TIMER          0x250
 #define __LC_EXIT_TIMER                 0x258
-#define __LC_LAST_UPDATE_TIMER          0x260
-#define __LC_USER_TIMER                 0x268
-#define __LC_SYSTEM_TIMER               0x270
-#define __LC_LAST_UPDATE_CLOCK          0x278
-#define __LC_STEAL_CLOCK                0x280
+#define __LC_USER_TIMER                 0x260
+#define __LC_SYSTEM_TIMER               0x268
+#define __LC_STEAL_TIMER                0x270
+#define __LC_LAST_UPDATE_TIMER          0x278
+#define __LC_LAST_UPDATE_CLOCK          0x280
 #define __LC_RETURN_MCCK_PSW            0x288
 #define __LC_KERNEL_STACK               0xC40
 #define __LC_THREAD_INFO                0xC44
@@ -89,11 +89,11 @@
 #define __LC_SYNC_ENTER_TIMER           0x250
 #define __LC_ASYNC_ENTER_TIMER          0x258
 #define __LC_EXIT_TIMER                 0x260
-#define __LC_LAST_UPDATE_TIMER          0x268
-#define __LC_USER_TIMER                 0x270
-#define __LC_SYSTEM_TIMER               0x278
-#define __LC_LAST_UPDATE_CLOCK          0x280
-#define __LC_STEAL_CLOCK                0x288
+#define __LC_USER_TIMER                 0x268
+#define __LC_SYSTEM_TIMER               0x270
+#define __LC_STEAL_TIMER                0x278
+#define __LC_LAST_UPDATE_TIMER          0x280
+#define __LC_LAST_UPDATE_CLOCK          0x288
 #define __LC_RETURN_MCCK_PSW            0x290
 #define __LC_KERNEL_STACK               0xD40
 #define __LC_THREAD_INFO                0xD48
@@ -106,8 +106,10 @@
 #define __LC_IPLDEV                     0xDB8
 #define __LC_CURRENT                    0xDD8
 #define __LC_INT_CLOCK                  0xDE8
+#define __LC_VDSO_PER_CPU               0xE38
 #endif /* __s390x__ */
 
+#define __LC_PASTE                      0xE40
 
 #define __LC_PANIC_MAGIC                0xE00
 #ifndef __s390x__
@@ -252,11 +254,11 @@ struct _lowcore
         __u64        sync_enter_timer;         /* 0x248 */
         __u64        async_enter_timer;        /* 0x250 */
         __u64        exit_timer;               /* 0x258 */
-        __u64        last_update_timer;        /* 0x260 */
-        __u64        user_timer;               /* 0x268 */
-        __u64        system_timer;             /* 0x270 */
-        __u64        last_update_clock;        /* 0x278 */
-        __u64        steal_clock;              /* 0x280 */
+        __u64        user_timer;               /* 0x260 */
+        __u64        system_timer;             /* 0x268 */
+        __u64        steal_timer;              /* 0x270 */
+        __u64        last_update_timer;        /* 0x278 */
+        __u64        last_update_clock;        /* 0x280 */
         psw_t        return_mcck_psw;          /* 0x288 */
         __u8         pad8[0xc00-0x290];        /* 0x290 */
 
@@ -343,11 +345,11 @@ struct _lowcore
         __u64        sync_enter_timer;         /* 0x250 */
         __u64        async_enter_timer;        /* 0x258 */
         __u64        exit_timer;               /* 0x260 */
-        __u64        last_update_timer;        /* 0x268 */
-        __u64        user_timer;               /* 0x270 */
-        __u64        system_timer;             /* 0x278 */
-        __u64        last_update_clock;        /* 0x280 */
-        __u64        steal_clock;              /* 0x288 */
+        __u64        user_timer;               /* 0x268 */
+        __u64        system_timer;             /* 0x270 */
+        __u64        steal_timer;              /* 0x278 */
+        __u64        last_update_timer;        /* 0x280 */
+        __u64        last_update_clock;        /* 0x288 */
         psw_t        return_mcck_psw;          /* 0x290 */
         __u8         pad8[0xc00-0x2a0];        /* 0x2a0 */
         /* System info area */
@@ -381,7 +383,12 @@ struct _lowcore
         /* whether the kernel died with panic() or not */
         __u32        panic_magic;              /* 0xe00 */
 
-        __u8         pad13[0x11b8-0xe04];      /* 0xe04 */
+        /* Per cpu primary space access list */
+        __u8         pad_0xe04[0xe3c-0xe04];   /* 0xe04 */
+        __u32        vdso_per_cpu_data;        /* 0xe3c */
+        __u32        paste[16];                /* 0xe40 */
+
+        __u8         pad13[0x11b8-0xe80];      /* 0xe80 */
 
         /* 64 bit extparam used for pfault, diag 250 etc  */
         __u64        ext_params2;               /* 0x11B8 */
diff --git a/arch/s390/include/asm/system.h b/arch/s390/include/asm/system.h
index 024ef42ed6d7..3a8b26eb1f2e 100644
--- a/arch/s390/include/asm/system.h
+++ b/arch/s390/include/asm/system.h
@@ -99,7 +99,7 @@ static inline void restore_access_regs(unsigned int *acrs)
         prev = __switch_to(prev,next);                                       \
 } while (0)
 
-extern void account_vtime(struct task_struct *);
+extern void account_vtime(struct task_struct *, struct task_struct *);
 extern void account_tick_vtime(struct task_struct *);
 extern void account_system_vtime(struct task_struct *);
 
@@ -121,7 +121,7 @@ static inline void cmma_init(void) { }
 
 #define finish_arch_switch(prev) do {                                        \
         set_fs(current->thread.mm_segment);                                  \
-        account_vtime(prev);                                                 \
+        account_vtime(prev, current);                                        \
 } while (0)
 
 #define nop() asm volatile("nop")
diff --git a/arch/s390/include/asm/thread_info.h b/arch/s390/include/asm/thread_info.h
index c1eaf9604da7..c544aa524535 100644
--- a/arch/s390/include/asm/thread_info.h
+++ b/arch/s390/include/asm/thread_info.h
@@ -47,6 +47,8 @@ struct thread_info {
         unsigned int            cpu;            /* current CPU */
         int                     preempt_count;  /* 0 => preemptable, <0 => BUG */
         struct restart_block    restart_block;
+        __u64                   user_timer;
+        __u64                   system_timer;
 };
 
 /*
diff --git a/arch/s390/include/asm/timer.h b/arch/s390/include/asm/timer.h
index 61705d60f995..e4bcab739c19 100644
--- a/arch/s390/include/asm/timer.h
+++ b/arch/s390/include/asm/timer.h
@@ -23,20 +23,18 @@ struct vtimer_list {
         __u64 expires;
         __u64 interval;
 
-        spinlock_t lock;
-        unsigned long magic;
-
         void (*function)(unsigned long);
         unsigned long data;
 };
 
-/* the offset value will wrap after ca. 71 years */
+/* the vtimer value will wrap after ca. 71 years */
 struct vtimer_queue {
         struct list_head list;
         spinlock_t lock;
-        __u64 to_expire;          /* current event expire time */
-        __u64 offset;             /* list offset to zero */
-        __u64 idle;               /* temp var for idle */
+        __u64 timer;            /* last programmed timer */
+        __u64 elapsed;          /* elapsed time of timer expire values */
+        __u64 idle;             /* temp var for idle */
+        int do_spt;             /* =1: reprogram cpu timer in idle */
 };
 
 extern void init_virt_timer(struct vtimer_list *timer);
@@ -48,8 +46,8 @@ extern int del_virt_timer(struct vtimer_list *timer);
 extern void init_cpu_vtimer(void);
 extern void vtime_init(void);
 
-extern void vtime_start_cpu_timer(void);
-extern void vtime_stop_cpu_timer(void);
+extern void vtime_stop_cpu(void);
+extern void vtime_start_leave(void);
 
 #endif /* __KERNEL__ */
 
diff --git a/arch/s390/include/asm/vdso.h b/arch/s390/include/asm/vdso.h
index a44f4fe16a35..7bdd7c8ebc91 100644
--- a/arch/s390/include/asm/vdso.h
+++ b/arch/s390/include/asm/vdso.h
@@ -12,9 +12,9 @@
 #ifndef __ASSEMBLY__
 
 /*
- * Note about this structure:
+ * Note about the vdso_data and vdso_per_cpu_data structures:
  *
- * NEVER USE THIS IN USERSPACE CODE DIRECTLY. The layout of this
+ * NEVER USE THEM IN USERSPACE CODE DIRECTLY. The layout of the
  * structure is supposed to be known only to the function in the vdso
  * itself and may change without notice.
  */
@@ -28,10 +28,21 @@ struct vdso_data {
         __u64 wtom_clock_nsec;          /*                              0x28 */
         __u32 tz_minuteswest;           /* Minutes west of Greenwich    0x30 */
         __u32 tz_dsttime;               /* Type of dst correction       0x34 */
+        __u32 ectg_available;
+};
+
+struct vdso_per_cpu_data {
+        __u64 ectg_timer_base;
+        __u64 ectg_user_time;
 };
 
 extern struct vdso_data *vdso_data;
 
+#ifdef CONFIG_64BIT
+int vdso_alloc_per_cpu(int cpu, struct _lowcore *lowcore);
+void vdso_free_per_cpu(int cpu, struct _lowcore *lowcore);
+#endif
+
 #endif /* __ASSEMBLY__ */
 
 #endif /* __KERNEL__ */
diff --git a/arch/s390/kernel/asm-offsets.c b/arch/s390/kernel/asm-offsets.c
index e641f60bac99..67a60016babb 100644
--- a/arch/s390/kernel/asm-offsets.c
+++ b/arch/s390/kernel/asm-offsets.c
@@ -48,6 +48,11 @@ int main(void)
         DEFINE(__VDSO_WTOM_SEC, offsetof(struct vdso_data, wtom_clock_sec));
         DEFINE(__VDSO_WTOM_NSEC, offsetof(struct vdso_data, wtom_clock_nsec));
         DEFINE(__VDSO_TIMEZONE, offsetof(struct vdso_data, tz_minuteswest));
+        DEFINE(__VDSO_ECTG_OK, offsetof(struct vdso_data, ectg_available));
+        DEFINE(__VDSO_ECTG_BASE,
+               offsetof(struct vdso_per_cpu_data, ectg_timer_base));
+        DEFINE(__VDSO_ECTG_USER,
+               offsetof(struct vdso_per_cpu_data, ectg_user_time));
         /* constants used by the vdso */
         DEFINE(CLOCK_REALTIME, CLOCK_REALTIME);
         DEFINE(CLOCK_MONOTONIC, CLOCK_MONOTONIC);
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index 55de521aef77..1268aa2991bf 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -583,8 +583,8 @@ kernel_per:
 
         .globl io_int_handler
 io_int_handler:
-        stpt    __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
+        stpt    __LC_ASYNC_ENTER_TIMER
         SAVE_ALL_BASE __LC_SAVE_AREA+16
         SAVE_ALL_ASYNC __LC_IO_OLD_PSW,__LC_SAVE_AREA+16
         CREATE_STACK_FRAME __LC_IO_OLD_PSW,__LC_SAVE_AREA+16
@@ -723,8 +723,8 @@ io_notify_resume:
 
         .globl  ext_int_handler
 ext_int_handler:
-        stpt    __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
+        stpt    __LC_ASYNC_ENTER_TIMER
         SAVE_ALL_BASE __LC_SAVE_AREA+16
         SAVE_ALL_ASYNC __LC_EXT_OLD_PSW,__LC_SAVE_AREA+16
         CREATE_STACK_FRAME __LC_EXT_OLD_PSW,__LC_SAVE_AREA+16
@@ -750,6 +750,7 @@ __critical_end:
 
         .globl mcck_int_handler
 mcck_int_handler:
+        stck    __LC_INT_CLOCK
         spt     __LC_CPU_TIMER_SAVE_AREA        # revalidate cpu timer
         lm      %r0,%r15,__LC_GPREGS_SAVE_AREA  # revalidate gprs
         SAVE_ALL_BASE __LC_SAVE_AREA+32
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 16bb4fd1a403..c6fbde13971a 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -177,8 +177,11 @@ _TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
         .if !\sync
         ni      \psworg+1,0xfd          # clear wait state bit
         .endif
-        lmg     %r0,%r15,SP_R0(%r15)    # load gprs 0-15 of user
+        lg      %r14,__LC_VDSO_PER_CPU
+        lmg     %r0,%r13,SP_R0(%r15)    # load gprs 0-13 of user
         stpt    __LC_EXIT_TIMER
+        mvc     __VDSO_ECTG_BASE(16,%r14),__LC_EXIT_TIMER
+        lmg     %r14,%r15,SP_R14(%r15)  # load grps 14-15 of user
         lpswe   \psworg                 # back to caller
         .endm
 
@@ -559,8 +562,8 @@ kernel_per:
  */
         .globl io_int_handler
 io_int_handler:
-        stpt    __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
+        stpt    __LC_ASYNC_ENTER_TIMER
         SAVE_ALL_BASE __LC_SAVE_AREA+32
         SAVE_ALL_ASYNC __LC_IO_OLD_PSW,__LC_SAVE_AREA+32
         CREATE_STACK_FRAME __LC_IO_OLD_PSW,__LC_SAVE_AREA+32
@@ -721,8 +724,8 @@ io_notify_resume:
  */
         .globl  ext_int_handler
 ext_int_handler:
-        stpt    __LC_ASYNC_ENTER_TIMER
         stck    __LC_INT_CLOCK
+        stpt    __LC_ASYNC_ENTER_TIMER
         SAVE_ALL_BASE __LC_SAVE_AREA+32
         SAVE_ALL_ASYNC __LC_EXT_OLD_PSW,__LC_SAVE_AREA+32
         CREATE_STACK_FRAME __LC_EXT_OLD_PSW,__LC_SAVE_AREA+32
@@ -746,6 +749,7 @@ __critical_end:
  */
         .globl mcck_int_handler
 mcck_int_handler:
+        stck    __LC_INT_CLOCK
         la      %r1,4095                # revalidate r1
         spt     __LC_CPU_TIMER_SAVE_AREA-4095(%r1)      # revalidate cpu timer
         lmg     %r0,%r15,__LC_GPREGS_SAVE_AREA-4095(%r1)# revalidate gprs
@@ -979,23 +983,23 @@ cleanup_sysc_return:
 
 cleanup_sysc_leave:
         clc     8(8,%r12),BASED(cleanup_sysc_leave_insn)
-        je      2f
-        mvc     __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER
+        je      3f
         clc     8(8,%r12),BASED(cleanup_sysc_leave_insn+8)
-        je      2f
-        mvc     __LC_RETURN_PSW(16),SP_PSW(%r15)
+        jhe     0f
+        mvc     __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER
+0:      mvc     __LC_RETURN_PSW(16),SP_PSW(%r15)
         cghi    %r12,__LC_MCK_OLD_PSW
-        jne     0f
+        jne     1f
         mvc     __LC_SAVE_AREA+64(32),SP_R12(%r15)
-        j       1f
-0:      mvc     __LC_SAVE_AREA+32(32),SP_R12(%r15)
-1:      lmg     %r0,%r11,SP_R0(%r15)
+        j       2f
+1:      mvc     __LC_SAVE_AREA+32(32),SP_R12(%r15)
+2:      lmg     %r0,%r11,SP_R0(%r15)
         lg      %r15,SP_R15(%r15)
-2:      la      %r12,__LC_RETURN_PSW
+3:      la      %r12,__LC_RETURN_PSW
         br      %r14
 cleanup_sysc_leave_insn:
         .quad   sysc_done - 4
-        .quad   sysc_done - 8
+        .quad   sysc_done - 16
 
 cleanup_io_return:
         mvc     __LC_RETURN_PSW(8),0(%r12)
@@ -1005,23 +1009,23 @@ cleanup_io_return:
 
 cleanup_io_leave:
         clc     8(8,%r12),BASED(cleanup_io_leave_insn)
-        je      2f
-        mvc     __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER
+        je      3f
         clc     8(8,%r12),BASED(cleanup_io_leave_insn+8)
-        je      2f
-        mvc     __LC_RETURN_PSW(16),SP_PSW(%r15)
+        jhe     0f
+        mvc     __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER
+0:      mvc     __LC_RETURN_PSW(16),SP_PSW(%r15)
         cghi    %r12,__LC_MCK_OLD_PSW
-        jne     0f
+        jne     1f
         mvc     __LC_SAVE_AREA+64(32),SP_R12(%r15)
-        j       1f
-0:      mvc     __LC_SAVE_AREA+32(32),SP_R12(%r15)
-1:      lmg     %r0,%r11,SP_R0(%r15)
+        j       2f
+1:      mvc     __LC_SAVE_AREA+32(32),SP_R12(%r15)
+2:      lmg     %r0,%r11,SP_R0(%r15)
         lg      %r15,SP_R15(%r15)
-2:      la      %r12,__LC_RETURN_PSW
+3:      la      %r12,__LC_RETURN_PSW
         br      %r14
 cleanup_io_leave_insn:
         .quad   io_done - 4
-        .quad   io_done - 8
+        .quad   io_done - 16
 
 /*
  * Integer constants
diff --git a/arch/s390/kernel/head64.S b/arch/s390/kernel/head64.S
index 3ccd36b24b8f..f9f70aa15244 100644
--- a/arch/s390/kernel/head64.S
+++ b/arch/s390/kernel/head64.S
@@ -87,6 +87,8 @@ startup_continue:
         lg      %r12,.Lparmaddr-.LPG1(%r13)     # pointer to parameter area
                                         # move IPL device to lowcore
         mvc     __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
+        lghi    %r0,__LC_PASTE
+        stg     %r0,__LC_VDSO_PER_CPU
 #
 # Setup stack
 #
diff --git a/arch/s390/kernel/process.c b/arch/s390/kernel/process.c
index 04f8c67a6101..b6110bdf8dc2 100644
--- a/arch/s390/kernel/process.c
+++ b/arch/s390/kernel/process.c
@@ -38,6 +38,7 @@
 #include <linux/utsname.h>
 #include <linux/tick.h>
 #include <linux/elfcore.h>
+#include <linux/kernel_stat.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
@@ -45,7 +46,6 @@
 #include <asm/processor.h>
 #include <asm/irq.h>
 #include <asm/timer.h>
-#include <asm/cpu.h>
 #include "entry.h"
 
 asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
@@ -75,36 +75,6 @@ unsigned long thread_saved_pc(struct task_struct *tsk)
         return sf->gprs[8];
 }
 
-DEFINE_PER_CPU(struct s390_idle_data, s390_idle) = {
-        .lock = __SPIN_LOCK_UNLOCKED(s390_idle.lock)
-};
-
-static int s390_idle_enter(void)
-{
-        struct s390_idle_data *idle;
-
-        idle = &__get_cpu_var(s390_idle);
-        spin_lock(&idle->lock);
-        idle->idle_count++;
-        idle->in_idle = 1;
-        idle->idle_enter = get_clock();
-        spin_unlock(&idle->lock);
-        vtime_stop_cpu_timer();
-        return NOTIFY_OK;
-}
-
-void s390_idle_leave(void)
-{
-        struct s390_idle_data *idle;
-
-        vtime_start_cpu_timer();
-        idle = &__get_cpu_var(s390_idle);
-        spin_lock(&idle->lock);
-        idle->idle_time += get_clock() - idle->idle_enter;
-        idle->in_idle = 0;
-        spin_unlock(&idle->lock);
-}
-
 extern void s390_handle_mcck(void);
 /*
  * The idle loop on a S390...
@@ -117,10 +87,6 @@ static void default_idle(void)
                 local_irq_enable();
                 return;
         }
-        if (s390_idle_enter() == NOTIFY_BAD) {
-                local_irq_enable();
-                return;
-        }
 #ifdef CONFIG_HOTPLUG_CPU
         if (cpu_is_offline(smp_processor_id())) {
                 preempt_enable_no_resched();
@@ -130,7 +96,6 @@ static void default_idle(void)
         local_mcck_disable();
         if (test_thread_flag(TIF_MCCK_PENDING)) {
                 local_mcck_enable();
-                s390_idle_leave();
                 local_irq_enable();
                 s390_handle_mcck();
                 return;
@@ -138,9 +103,9 @@ static void default_idle(void)
         trace_hardirqs_on();
         /* Don't trace preempt off for idle. */
         stop_critical_timings();
-        /* Wait for external, I/O or machine check interrupt. */
-        __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
-                        PSW_MASK_IO | PSW_MASK_EXT);
+        /* Stop virtual timer and halt the cpu. */
+        vtime_stop_cpu();
+        /* Reenable preemption tracer. */
         start_critical_timings();
 }
 
diff --git a/arch/s390/kernel/s390_ext.c b/arch/s390/kernel/s390_ext.c
index e019b419efc6..a0d2d55d7fb3 100644
--- a/arch/s390/kernel/s390_ext.c
+++ b/arch/s390/kernel/s390_ext.c
@@ -119,8 +119,8 @@ void do_extint(struct pt_regs *regs, unsigned short code)
         struct pt_regs *old_regs;
 
         old_regs = set_irq_regs(regs);
-        irq_enter();
         s390_idle_check();
+        irq_enter();
         if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
                 /* Serve timer interrupts first. */
                 clock_comparator_work();
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index b7a1efd5522c..d825f4950e4e 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -427,6 +427,8 @@ setup_lowcore(void)
                 /* enable extended save area */
                 __ctl_set_bit(14, 29);
         }
+#else
+        lc->vdso_per_cpu_data = (unsigned long) &lc->paste[0];
 #endif
         set_prefix((u32)(unsigned long) lc);
 }
diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index 3ed5c7a83c6c..9c0ccb532a45 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -47,6 +47,7 @@
 #include <asm/lowcore.h>
 #include <asm/sclp.h>
 #include <asm/cpu.h>
+#include <asm/vdso.h>
 #include "entry.h"
 
 /*
@@ -500,6 +501,9 @@ static int __cpuinit smp_alloc_lowcore(int cpu)
                         goto out;
                 lowcore->extended_save_area_addr = (u32) save_area;
         }
+#else
+        if (vdso_alloc_per_cpu(cpu, lowcore))
+                goto out;
 #endif
         lowcore_ptr[cpu] = lowcore;
         return 0;
@@ -522,6 +526,8 @@ static void smp_free_lowcore(int cpu)
 #ifndef CONFIG_64BIT
         if (MACHINE_HAS_IEEE)
                 free_page((unsigned long) lowcore->extended_save_area_addr);
+#else
+        vdso_free_per_cpu(cpu, lowcore);
 #endif
         free_page(lowcore->panic_stack - PAGE_SIZE);
         free_pages(lowcore->async_stack - ASYNC_SIZE, ASYNC_ORDER);
@@ -664,6 +670,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
         lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, lc_order);
         panic_stack = __get_free_page(GFP_KERNEL);
         async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
+        BUG_ON(!lowcore || !panic_stack || !async_stack);
 #ifndef CONFIG_64BIT
         if (MACHINE_HAS_IEEE)
                 save_area = get_zeroed_page(GFP_KERNEL);
@@ -677,6 +684,8 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
 #ifndef CONFIG_64BIT
         if (MACHINE_HAS_IEEE)
                 lowcore->extended_save_area_addr = (u32) save_area;
+#else
+        BUG_ON(vdso_alloc_per_cpu(smp_processor_id(), lowcore));
 #endif
         set_prefix((u32)(unsigned long) lowcore);
         local_mcck_enable();
@@ -845,9 +854,11 @@ static ssize_t show_idle_count(struct sys_device *dev,
         unsigned long long idle_count;
 
         idle = &per_cpu(s390_idle, dev->id);
-        spin_lock_irq(&idle->lock);
+        spin_lock(&idle->lock);
         idle_count = idle->idle_count;
-        spin_unlock_irq(&idle->lock);
+        if (idle->idle_enter)
+                idle_count++;
+        spin_unlock(&idle->lock);
         return sprintf(buf, "%llu\n", idle_count);
 }
 static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL);
@@ -856,18 +867,17 @@ static ssize_t show_idle_time(struct sys_device *dev,
                                 struct sysdev_attribute *attr, char *buf)
 {
         struct s390_idle_data *idle;
-        unsigned long long new_time;
+        unsigned long long now, idle_time, idle_enter;
 
         idle = &per_cpu(s390_idle, dev->id);
-        spin_lock_irq(&idle->lock);
-        if (idle->in_idle) {
-                new_time = get_clock();
-                idle->idle_time += new_time - idle->idle_enter;
-                idle->idle_enter = new_time;
-        }
-        new_time = idle->idle_time;
-        spin_unlock_irq(&idle->lock);
-        return sprintf(buf, "%llu\n", new_time >> 12);
+        spin_lock(&idle->lock);
+        now = get_clock();
+        idle_time = idle->idle_time;
+        idle_enter = idle->idle_enter;
+        if (idle_enter != 0ULL && idle_enter < now)
+                idle_time += now - idle_enter;
+        spin_unlock(&idle->lock);
+        return sprintf(buf, "%llu\n", idle_time >> 12);
 }
 static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL);
 
diff --git a/arch/s390/kernel/vdso.c b/arch/s390/kernel/vdso.c
index 10a6ccef4412..25a6a82f1c02 100644
--- a/arch/s390/kernel/vdso.c
+++ b/arch/s390/kernel/vdso.c
@@ -31,9 +31,6 @@
 #include <asm/sections.h>
 #include <asm/vdso.h>
 
-/* Max supported size for symbol names */
-#define MAX_SYMNAME     64
-
 #if defined(CONFIG_32BIT) || defined(CONFIG_COMPAT)
 extern char vdso32_start, vdso32_end;
 static void *vdso32_kbase = &vdso32_start;
@@ -71,6 +68,119 @@ static union {
 struct vdso_data *vdso_data = &vdso_data_store.data;
 
 /*
+ * Setup vdso data page.
+ */
+static void vdso_init_data(struct vdso_data *vd)
+{
+        unsigned int facility_list;
+
+        facility_list = stfl();
+        vd->ectg_available = switch_amode && (facility_list & 1);
+}
+
+#ifdef CONFIG_64BIT
+/*
+ * Setup per cpu vdso data page.
+ */
+static void vdso_init_per_cpu_data(int cpu, struct vdso_per_cpu_data *vpcd)
+{
+}
+
+/*
+ * Allocate/free per cpu vdso data.
+ */
+#ifdef CONFIG_64BIT
+#define SEGMENT_ORDER   2
+#else
+#define SEGMENT_ORDER   1
+#endif
+
+int vdso_alloc_per_cpu(int cpu, struct _lowcore *lowcore)
+{
+        unsigned long segment_table, page_table, page_frame;
+        u32 *psal, *aste;
+        int i;
+
+        lowcore->vdso_per_cpu_data = __LC_PASTE;
+
+        if (!switch_amode || !vdso_enabled)
+                return 0;
+
+        segment_table = __get_free_pages(GFP_KERNEL, SEGMENT_ORDER);
+        page_table = get_zeroed_page(GFP_KERNEL | GFP_DMA);
+        page_frame = get_zeroed_page(GFP_KERNEL);
+        if (!segment_table || !page_table || !page_frame)
+                goto out;
+
+        clear_table((unsigned long *) segment_table, _SEGMENT_ENTRY_EMPTY,
+                    PAGE_SIZE << SEGMENT_ORDER);
+        clear_table((unsigned long *) page_table, _PAGE_TYPE_EMPTY,
+                    256*sizeof(unsigned long));
+
+        *(unsigned long *) segment_table = _SEGMENT_ENTRY + page_table;
+        *(unsigned long *) page_table = _PAGE_RO + page_frame;
+
+        psal = (u32 *) (page_table + 256*sizeof(unsigned long));
+        aste = psal + 32;
+
+        for (i = 4; i < 32; i += 4)
+                psal[i] = 0x80000000;
+
+        lowcore->paste[4] = (u32)(addr_t) psal;
+        psal[0] = 0x20000000;
+        psal[2] = (u32)(addr_t) aste;
+        *(unsigned long *) (aste + 2) = segment_table +
+                _ASCE_TABLE_LENGTH + _ASCE_USER_BITS + _ASCE_TYPE_SEGMENT;
+        aste[4] = (u32)(addr_t) psal;
+        lowcore->vdso_per_cpu_data = page_frame;
+
+        vdso_init_per_cpu_data(cpu, (struct vdso_per_cpu_data *) page_frame);
+        return 0;
+
+out:
+        free_page(page_frame);
+        free_page(page_table);
+        free_pages(segment_table, SEGMENT_ORDER);
+        return -ENOMEM;
+}
+
+#ifdef CONFIG_HOTPLUG_CPU
+void vdso_free_per_cpu(int cpu, struct _lowcore *lowcore)
+{
+        unsigned long segment_table, page_table, page_frame;
+        u32 *psal, *aste;
+
+        if (!switch_amode || !vdso_enabled)
+                return;
+
+        psal = (u32 *)(addr_t) lowcore->paste[4];
+        aste = (u32 *)(addr_t) psal[2];
+        segment_table = *(unsigned long *)(aste + 2) & PAGE_MASK;
+        page_table = *(unsigned long *) segment_table;
+        page_frame = *(unsigned long *) page_table;
+
+        free_page(page_frame);
+        free_page(page_table);
+        free_pages(segment_table, SEGMENT_ORDER);
+}
+#endif /* CONFIG_HOTPLUG_CPU */
+
+static void __vdso_init_cr5(void *dummy)
+{
+        unsigned long cr5;
+
+        cr5 = offsetof(struct _lowcore, paste);
+        __ctl_load(cr5, 5, 5);
+}
+
+static void vdso_init_cr5(void)
+{
+        if (switch_amode && vdso_enabled)
+                on_each_cpu(__vdso_init_cr5, NULL, 1);
+}
+#endif /* CONFIG_64BIT */
+
+/*
  * This is called from binfmt_elf, we create the special vma for the
  * vDSO and insert it into the mm struct tree
  */
@@ -172,6 +282,9 @@ static int __init vdso_init(void)
 {
         int i;
 
+        if (!vdso_enabled)
+                return 0;
+        vdso_init_data(vdso_data);
 #if defined(CONFIG_32BIT) || defined(CONFIG_COMPAT)
         /* Calculate the size of the 32 bit vDSO */
         vdso32_pages = ((&vdso32_end - &vdso32_start
@@ -208,6 +321,10 @@ static int __init vdso_init(void)
         }
         vdso64_pagelist[vdso64_pages - 1] = virt_to_page(vdso_data);
         vdso64_pagelist[vdso64_pages] = NULL;
+#ifndef CONFIG_SMP
+        BUG_ON(vdso_alloc_per_cpu(0, S390_lowcore));
+#endif
+        vdso_init_cr5();
 #endif /* CONFIG_64BIT */
 
         get_page(virt_to_page(vdso_data));
diff --git a/arch/s390/kernel/vdso64/clock_getres.S b/arch/s390/kernel/vdso64/clock_getres.S
index 488e31a3c0e7..9ce8caafdb4e 100644
--- a/arch/s390/kernel/vdso64/clock_getres.S
+++ b/arch/s390/kernel/vdso64/clock_getres.S
@@ -22,7 +22,12 @@ __kernel_clock_getres:
         cghi    %r2,CLOCK_REALTIME
         je      0f
         cghi    %r2,CLOCK_MONOTONIC
+        je      0f
+        cghi    %r2,-2          /* CLOCK_THREAD_CPUTIME_ID for this thread */
         jne     2f
+        larl    %r5,_vdso_data
+        icm     %r0,15,__LC_ECTG_OK(%r5)
+        jz      2f
 0:      ltgr    %r3,%r3
         jz      1f                              /* res == NULL */
         larl    %r1,3f
diff --git a/arch/s390/kernel/vdso64/clock_gettime.S b/arch/s390/kernel/vdso64/clock_gettime.S
index 738a410b7eb2..79dbfee831ec 100644
--- a/arch/s390/kernel/vdso64/clock_gettime.S
+++ b/arch/s390/kernel/vdso64/clock_gettime.S
@@ -22,8 +22,10 @@ __kernel_clock_gettime:
         larl    %r5,_vdso_data
         cghi    %r2,CLOCK_REALTIME
         je      4f
+        cghi    %r2,-2          /* CLOCK_THREAD_CPUTIME_ID for this thread */
+        je      9f
         cghi    %r2,CLOCK_MONOTONIC
-        jne     9f
+        jne     12f
 
         /* CLOCK_MONOTONIC */
         ltgr    %r3,%r3
@@ -42,7 +44,7 @@ __kernel_clock_gettime:
         alg     %r0,__VDSO_WTOM_SEC(%r5)
         clg     %r4,__VDSO_UPD_COUNT(%r5)       /* check update counter */
         jne     0b
-        larl    %r5,10f
+        larl    %r5,13f
 1:      clg     %r1,0(%r5)
         jl      2f
         slg     %r1,0(%r5)
@@ -68,7 +70,7 @@ __kernel_clock_gettime:
         lg      %r0,__VDSO_XTIME_SEC(%r5)
         clg     %r4,__VDSO_UPD_COUNT(%r5)       /* check update counter */
         jne     5b
-        larl    %r5,10f
+        larl    %r5,13f
 6:      clg     %r1,0(%r5)
         jl      7f
         slg     %r1,0(%r5)
@@ -79,11 +81,38 @@ __kernel_clock_gettime:
 8:      lghi    %r2,0
         br      %r14
 
+        /* CLOCK_THREAD_CPUTIME_ID for this thread */
+9:      icm     %r0,15,__VDSO_ECTG_OK(%r5)
+        jz      12f
+        ear     %r2,%a4
+        llilh   %r4,0x0100
+        sar     %a4,%r4
+        lghi    %r4,0
+        sacf    512                             /* Magic ectg instruction */
+        .insn   ssf,0xc80100000000,__VDSO_ECTG_BASE(4),__VDSO_ECTG_USER(4),4
+        sacf    0
+        sar     %a4,%r2
+        algr    %r1,%r0                         /* r1 = cputime as TOD value */
+        mghi    %r1,1000                        /* convert to nanoseconds */
+        srlg    %r1,%r1,12                      /* r1 = cputime in nanosec */
+        lgr     %r4,%r1
+        larl    %r5,13f
+        srlg    %r1,%r1,9                       /* divide by 1000000000 */
+        mlg     %r0,8(%r5)
+        srlg    %r0,%r0,11                      /* r0 = tv_sec */
+        stg     %r0,0(%r3)
+        msg     %r0,0(%r5)                      /* calculate tv_nsec */
+        slgr    %r4,%r0                         /* r4 = tv_nsec */
+        stg     %r4,8(%r3)
+        lghi    %r2,0
+        br      %r14
+
         /* Fallback to system call */
-9:      lghi    %r1,__NR_clock_gettime
+12:     lghi    %r1,__NR_clock_gettime
         svc     0
         br      %r14
 
-10:     .quad   1000000000
+13:     .quad   1000000000
+14:     .quad   19342813113834067
         .cfi_endproc
         .size   __kernel_clock_gettime,.-__kernel_clock_gettime
diff --git a/arch/s390/kernel/vtime.c b/arch/s390/kernel/vtime.c
index 75a6e62ea973..2fb36e462194 100644
--- a/arch/s390/kernel/vtime.c
+++ b/arch/s390/kernel/vtime.c
@@ -23,19 +23,43 @@
 #include <asm/s390_ext.h>
 #include <asm/timer.h>
 #include <asm/irq_regs.h>
+#include <asm/cpu.h>
 
 static ext_int_info_t ext_int_info_timer;
+
 static DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
 
+DEFINE_PER_CPU(struct s390_idle_data, s390_idle) = {
+        .lock = __SPIN_LOCK_UNLOCKED(s390_idle.lock)
+};
+
+static inline __u64 get_vtimer(void)
+{
+        __u64 timer;
+
+        asm volatile("STPT %0" : "=m" (timer));
+        return timer;
+}
+
+static inline void set_vtimer(__u64 expires)
+{
+        __u64 timer;
+
+        asm volatile ("  STPT %0\n"  /* Store current cpu timer value */
+                      "  SPT %1"     /* Set new value immediatly afterwards */
+                      : "=m" (timer) : "m" (expires) );
+        S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
+        S390_lowcore.last_update_timer = expires;
+}
+
 /*
  * Update process times based on virtual cpu times stored by entry.S
  * to the lowcore fields user_timer, system_timer & steal_clock.
  */
-void account_process_tick(struct task_struct *tsk, int user_tick)
+static void do_account_vtime(struct task_struct *tsk, int hardirq_offset)
 {
-        cputime_t cputime;
-        __u64 timer, clock;
-        int rcu_user_flag;
+        struct thread_info *ti = task_thread_info(tsk);
+        __u64 timer, clock, user, system, steal;
 
         timer = S390_lowcore.last_update_timer;
         clock = S390_lowcore.last_update_clock;
@@ -44,50 +68,41 @@ void account_process_tick(struct task_struct *tsk, int user_tick)
                       : "=m" (S390_lowcore.last_update_timer),
                         "=m" (S390_lowcore.last_update_clock) );
         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
-        S390_lowcore.steal_clock += S390_lowcore.last_update_clock - clock;
-
-        cputime = S390_lowcore.user_timer >> 12;
-        rcu_user_flag = cputime != 0;
-        S390_lowcore.user_timer -= cputime << 12;
-        S390_lowcore.steal_clock -= cputime << 12;
-        account_user_time(tsk, cputime);
-
-        cputime =  S390_lowcore.system_timer >> 12;
-        S390_lowcore.system_timer -= cputime << 12;
-        S390_lowcore.steal_clock -= cputime << 12;
-        account_system_time(tsk, HARDIRQ_OFFSET, cputime);
-
-        cputime = S390_lowcore.steal_clock;
-        if ((__s64) cputime > 0) {
-                cputime >>= 12;
-                S390_lowcore.steal_clock -= cputime << 12;
-                account_steal_time(tsk, cputime);
+        S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;
+
+        user = S390_lowcore.user_timer - ti->user_timer;
+        S390_lowcore.steal_timer -= user;
+        ti->user_timer = S390_lowcore.user_timer;
+        account_user_time(tsk, user, user);
+
+        system = S390_lowcore.system_timer - ti->system_timer;
+        S390_lowcore.steal_timer -= system;
+        ti->system_timer = S390_lowcore.system_timer;
+        account_system_time(tsk, hardirq_offset, system, system);
+
+        steal = S390_lowcore.steal_timer;
+        if ((s64) steal > 0) {
+                S390_lowcore.steal_timer = 0;
+                account_steal_time(steal);
         }
 }
 
-/*
- * Update process times based on virtual cpu times stored by entry.S
- * to the lowcore fields user_timer, system_timer & steal_clock.
- */
-void account_vtime(struct task_struct *tsk)
+void account_vtime(struct task_struct *prev, struct task_struct *next)
 {
-        cputime_t cputime;
-        __u64 timer;
-
-        timer = S390_lowcore.last_update_timer;
-        asm volatile ("  STPT %0"    /* Store current cpu timer value */
-                      : "=m" (S390_lowcore.last_update_timer) );
-        S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
-
-        cputime = S390_lowcore.user_timer >> 12;
-        S390_lowcore.user_timer -= cputime << 12;
-        S390_lowcore.steal_clock -= cputime << 12;
-        account_user_time(tsk, cputime);
+        struct thread_info *ti;
+
+        do_account_vtime(prev, 0);
+        ti = task_thread_info(prev);
+        ti->user_timer = S390_lowcore.user_timer;
+        ti->system_timer = S390_lowcore.system_timer;
+        ti = task_thread_info(next);
+        S390_lowcore.user_timer = ti->user_timer;
+        S390_lowcore.system_timer = ti->system_timer;
+}
 
-        cputime =  S390_lowcore.system_timer >> 12;
-        S390_lowcore.system_timer -= cputime << 12;
-        S390_lowcore.steal_clock -= cputime << 12;
-        account_system_time(tsk, 0, cputime);
+void account_process_tick(struct task_struct *tsk, int user_tick)
+{
+        do_account_vtime(tsk, HARDIRQ_OFFSET);
 }
 
 /*
@@ -96,80 +111,131 @@ void account_vtime(struct task_struct *tsk)
  */
 void account_system_vtime(struct task_struct *tsk)
 {
-        cputime_t cputime;
-        __u64 timer;
+        struct thread_info *ti = task_thread_info(tsk);
+        __u64 timer, system;
 
         timer = S390_lowcore.last_update_timer;
-        asm volatile ("  STPT %0"    /* Store current cpu timer value */
-                      : "=m" (S390_lowcore.last_update_timer) );
+        S390_lowcore.last_update_timer = get_vtimer();
         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
 
-        cputime =  S390_lowcore.system_timer >> 12;
-        S390_lowcore.system_timer -= cputime << 12;
-        S390_lowcore.steal_clock -= cputime << 12;
-        account_system_time(tsk, 0, cputime);
+        system = S390_lowcore.system_timer - ti->system_timer;
+        S390_lowcore.steal_timer -= system;
+        ti->system_timer = S390_lowcore.system_timer;
+        account_system_time(tsk, 0, system, system);
 }
 EXPORT_SYMBOL_GPL(account_system_vtime);
 
-static inline void set_vtimer(__u64 expires)
-{
-        __u64 timer;
-
-        asm volatile ("  STPT %0\n"  /* Store current cpu timer value */
-                      "  SPT %1"     /* Set new value immediatly afterwards */
-                      : "=m" (timer) : "m" (expires) );
-        S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
-        S390_lowcore.last_update_timer = expires;
-
-        /* store expire time for this CPU timer */
-        __get_cpu_var(virt_cpu_timer).to_expire = expires;
-}
-
-void vtime_start_cpu_timer(void)
+void vtime_start_cpu(void)
 {
-        struct vtimer_queue *vt_list;
-
-        vt_list = &__get_cpu_var(virt_cpu_timer);
-
-        /* CPU timer interrupt is pending, don't reprogramm it */
-        if (vt_list->idle & 1LL<<63)
-                return;
+        struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
+        struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
+        __u64 idle_time, expires;
+
+        /* Account time spent with enabled wait psw loaded as idle time. */
+        idle_time = S390_lowcore.int_clock - idle->idle_enter;
+        account_idle_time(idle_time);
+        S390_lowcore.last_update_clock = S390_lowcore.int_clock;
+
+        /* Account system time spent going idle. */
+        S390_lowcore.system_timer += S390_lowcore.last_update_timer - vq->idle;
+        S390_lowcore.last_update_timer = S390_lowcore.async_enter_timer;
+
+        /* Restart vtime CPU timer */
+        if (vq->do_spt) {
+                /* Program old expire value but first save progress. */
+                expires = vq->idle - S390_lowcore.async_enter_timer;
+                expires += get_vtimer();
+                set_vtimer(expires);
+        } else {
+                /* Don't account the CPU timer delta while the cpu was idle. */
+                vq->elapsed -= vq->idle - S390_lowcore.async_enter_timer;
+        }
 
-        if (!list_empty(&vt_list->list))
-                set_vtimer(vt_list->idle);
+        spin_lock(&idle->lock);
+        idle->idle_time += idle_time;
+        idle->idle_enter = 0ULL;
+        idle->idle_count++;
+        spin_unlock(&idle->lock);
 }
 
-void vtime_stop_cpu_timer(void)
+void vtime_stop_cpu(void)
 {
-        struct vtimer_queue *vt_list;
-
-        vt_list = &__get_cpu_var(virt_cpu_timer);
-
-        /* nothing to do */
-        if (list_empty(&vt_list->list)) {
-                vt_list->idle = VTIMER_MAX_SLICE;
-                goto fire;
+        struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
+        struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
+        psw_t psw;
+
+        /* Wait for external, I/O or machine check interrupt. */
+        psw.mask = psw_kernel_bits | PSW_MASK_WAIT | PSW_MASK_IO | PSW_MASK_EXT;
+
+        /* Check if the CPU timer needs to be reprogrammed. */
+        if (vq->do_spt) {
+                __u64 vmax = VTIMER_MAX_SLICE;
+                /*
+                 * The inline assembly is equivalent to
+                 *      vq->idle = get_cpu_timer();
+                 *      set_cpu_timer(VTIMER_MAX_SLICE);
+                 *      idle->idle_enter = get_clock();
+                 *      __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
+                 *                         PSW_MASK_IO | PSW_MASK_EXT);
+                 * The difference is that the inline assembly makes sure that
+                 * the last three instruction are stpt, stck and lpsw in that
+                 * order. This is done to increase the precision.
+                 */
+                asm volatile(
+#ifndef CONFIG_64BIT
+                        "       basr    1,0\n"
+                        "0:     ahi     1,1f-0b\n"
+                        "       st      1,4(%2)\n"
+#else /* CONFIG_64BIT */
+                        "       larl    1,1f\n"
+                        "       stg     1,8(%2)\n"
+#endif /* CONFIG_64BIT */
+                        "       stpt    0(%4)\n"
+                        "       spt     0(%5)\n"
+                        "       stck    0(%3)\n"
+#ifndef CONFIG_64BIT
+                        "       lpsw    0(%2)\n"
+#else /* CONFIG_64BIT */
+                        "       lpswe   0(%2)\n"
+#endif /* CONFIG_64BIT */
+                        "1:"
+                        : "=m" (idle->idle_enter), "=m" (vq->idle)
+                        : "a" (&psw), "a" (&idle->idle_enter),
+                          "a" (&vq->idle), "a" (&vmax), "m" (vmax), "m" (psw)
+                        : "memory", "cc", "1");
+        } else {
+                /*
+                 * The inline assembly is equivalent to
+                 *      vq->idle = get_cpu_timer();
+                 *      idle->idle_enter = get_clock();
+                 *      __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
+                 *                         PSW_MASK_IO | PSW_MASK_EXT);
+                 * The difference is that the inline assembly makes sure that
+                 * the last three instruction are stpt, stck and lpsw in that
+                 * order. This is done to increase the precision.
+                 */
+                asm volatile(
+#ifndef CONFIG_64BIT
+                        "       basr    1,0\n"
+                        "0:     ahi     1,1f-0b\n"
+                        "       st      1,4(%2)\n"
+#else /* CONFIG_64BIT */
+                        "       larl    1,1f\n"
+                        "       stg     1,8(%2)\n"
+#endif /* CONFIG_64BIT */
+                        "       stpt    0(%4)\n"
+                        "       stck    0(%3)\n"
+#ifndef CONFIG_64BIT
+                        "       lpsw    0(%2)\n"
+#else /* CONFIG_64BIT */
+                        "       lpswe   0(%2)\n"
+#endif /* CONFIG_64BIT */
+                        "1:"
+                        : "=m" (idle->idle_enter), "=m" (vq->idle)
+                        : "a" (&psw), "a" (&idle->idle_enter),
+                          "a" (&vq->idle), "m" (psw)
+                        : "memory", "cc", "1");
         }
-
-        /* store the actual expire value */
-        asm volatile ("STPT %0" : "=m" (vt_list->idle));
-
-        /*
-         * If the CPU timer is negative we don't reprogramm
-         * it because we will get instantly an interrupt.
-         */
-        if (vt_list->idle & 1LL<<63)
-                return;
-
-        vt_list->offset += vt_list->to_expire - vt_list->idle;
-
-        /*
-         * We cannot halt the CPU timer, we just write a value that
-         * nearly never expires (only after 71 years) and re-write
-         * the stored expire value if we continue the timer
-         */
- fire:
-        set_vtimer(VTIMER_MAX_SLICE);
 }
 
 /*
@@ -195,30 +261,23 @@ static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
  */
 static void do_callbacks(struct list_head *cb_list)
 {
-        struct vtimer_queue *vt_list;
+        struct vtimer_queue *vq;
         struct vtimer_list *event, *tmp;
-        void (*fn)(unsigned long);
-        unsigned long data;
 
         if (list_empty(cb_list))
                 return;
 
-        vt_list = &__get_cpu_var(virt_cpu_timer);
+        vq = &__get_cpu_var(virt_cpu_timer);
 
         list_for_each_entry_safe(event, tmp, cb_list, entry) {
-                fn = event->function;
-                data = event->data;
-                fn(data);
-
-                if (!event->interval)
-                        /* delete one shot timer */
-                        list_del_init(&event->entry);
-                else {
-                        /* move interval timer back to list */
-                        spin_lock(&vt_list->lock);
-                        list_del_init(&event->entry);
-                        list_add_sorted(event, &vt_list->list);
-                        spin_unlock(&vt_list->lock);
+                list_del_init(&event->entry);
+                (event->function)(event->data);
+                if (event->interval) {
+                        /* Recharge interval timer */
+                        event->expires = event->interval + vq->elapsed;
+                        spin_lock(&vq->lock);
+                        list_add_sorted(event, &vq->list);
+                        spin_unlock(&vq->lock);
                 }
         }
 }
@@ -228,64 +287,57 @@ static void do_callbacks(struct list_head *cb_list)
  */
 static void do_cpu_timer_interrupt(__u16 error_code)
 {
-        __u64 next, delta;
-        struct vtimer_queue *vt_list;
+        struct vtimer_queue *vq;
         struct vtimer_list *event, *tmp;
-        struct list_head *ptr;
-        /* the callback queue */
-        struct list_head cb_list;
+        struct list_head cb_list;       /* the callback queue */
+        __u64 elapsed, next;
 
         INIT_LIST_HEAD(&cb_list);
-        vt_list = &__get_cpu_var(virt_cpu_timer);
+        vq = &__get_cpu_var(virt_cpu_timer);
 
         /* walk timer list, fire all expired events */
-        spin_lock(&vt_list->lock);
-
-        if (vt_list->to_expire < VTIMER_MAX_SLICE)
-                vt_list->offset += vt_list->to_expire;
-
-        list_for_each_entry_safe(event, tmp, &vt_list->list, entry) {
-                if (event->expires > vt_list->offset)
-                        /* found first unexpired event, leave */
-                        break;
-
-                /* re-charge interval timer, we have to add the offset */
-                if (event->interval)
-                        event->expires = event->interval + vt_list->offset;
-
-                /* move expired timer to the callback queue */
-                list_move_tail(&event->entry, &cb_list);
+        spin_lock(&vq->lock);
+
+        elapsed = vq->elapsed + (vq->timer - S390_lowcore.async_enter_timer);
+        BUG_ON((s64) elapsed < 0);
+        vq->elapsed = 0;
+        list_for_each_entry_safe(event, tmp, &vq->list, entry) {
+                if (event->expires < elapsed)
+                        /* move expired timer to the callback queue */
+                        list_move_tail(&event->entry, &cb_list);
+                else
+                        event->expires -= elapsed;
         }
-        spin_unlock(&vt_list->lock);
+        spin_unlock(&vq->lock);
+
+        vq->do_spt = list_empty(&cb_list);
         do_callbacks(&cb_list);
 
         /* next event is first in list */
-        spin_lock(&vt_list->lock);
-        if (!list_empty(&vt_list->list)) {
-                ptr = vt_list->list.next;
-                event = list_entry(ptr, struct vtimer_list, entry);
-                next = event->expires - vt_list->offset;
-
-                /* add the expired time from this interrupt handler
-                 * and the callback functions
-                 */
-                asm volatile ("STPT %0" : "=m" (delta));
-                delta = 0xffffffffffffffffLL - delta + 1;
-                vt_list->offset += delta;
-                next -= delta;
-        } else {
-                vt_list->offset = 0;
-                next = VTIMER_MAX_SLICE;
-        }
-        spin_unlock(&vt_list->lock);
-        set_vtimer(next);
+        next = VTIMER_MAX_SLICE;
+        spin_lock(&vq->lock);
+        if (!list_empty(&vq->list)) {
+                event = list_first_entry(&vq->list, struct vtimer_list, entry);
+                next = event->expires;
+        } else
+                vq->do_spt = 0;
+        spin_unlock(&vq->lock);
+        /*
+         * To improve precision add the time spent by the
+         * interrupt handler to the elapsed time.
+         * Note: CPU timer counts down and we got an interrupt,
+         *       the current content is negative
+         */
+        elapsed = S390_lowcore.async_enter_timer - get_vtimer();
+        set_vtimer(next - elapsed);
+        vq->timer = next - elapsed;
+        vq->elapsed = elapsed;
 }
 
 void init_virt_timer(struct vtimer_list *timer)
 {
         timer->function = NULL;
         INIT_LIST_HEAD(&timer->entry);
-        spin_lock_init(&timer->lock);
 }
 EXPORT_SYMBOL(init_virt_timer);
 
@@ -299,44 +351,40 @@ static inline int vtimer_pending(struct vtimer_list *timer)
  */
 static void internal_add_vtimer(struct vtimer_list *timer)
 {
+        struct vtimer_queue *vq;
         unsigned long flags;
-        __u64 done;
-        struct vtimer_list *event;
-        struct vtimer_queue *vt_list;
+        __u64 left, expires;
 
-        vt_list = &per_cpu(virt_cpu_timer, timer->cpu);
-        spin_lock_irqsave(&vt_list->lock, flags);
+        vq = &per_cpu(virt_cpu_timer, timer->cpu);
+        spin_lock_irqsave(&vq->lock, flags);
 
         BUG_ON(timer->cpu != smp_processor_id());
 
-        /* if list is empty we only have to set the timer */
-        if (list_empty(&vt_list->list)) {
-                /* reset the offset, this may happen if the last timer was
-                 * just deleted by mod_virt_timer and the interrupt
-                 * didn't happen until here
-                 */
-                vt_list->offset = 0;
-                goto fire;
+        if (list_empty(&vq->list)) {
+                /* First timer on this cpu, just program it. */
+                list_add(&timer->entry, &vq->list);
+                set_vtimer(timer->expires);
+                vq->timer = timer->expires;
+                vq->elapsed = 0;
+        } else {
+                /* Check progress of old timers. */
+                expires = timer->expires;
+                left = get_vtimer();
+                if (likely((s64) expires < (s64) left)) {
+                        /* The new timer expires before the current timer. */
+                        set_vtimer(expires);
+                        vq->elapsed += vq->timer - left;
+                        vq->timer = expires;
+                } else {
+                        vq->elapsed += vq->timer - left;
+                        vq->timer = left;
+                }
+                /* Insert new timer into per cpu list. */
+                timer->expires += vq->elapsed;
+                list_add_sorted(timer, &vq->list);
         }
 
-        /* save progress */
-        asm volatile ("STPT %0" : "=m" (done));
-
-        /* calculate completed work */
-        done = vt_list->to_expire - done + vt_list->offset;
-        vt_list->offset = 0;
-
-        list_for_each_entry(event, &vt_list->list, entry)
-                event->expires -= done;
-
- fire:
-        list_add_sorted(timer, &vt_list->list);
-
-        /* get first element, which is the next vtimer slice */
-        event = list_entry(vt_list->list.next, struct vtimer_list, entry);
-
-        set_vtimer(event->expires);
-        spin_unlock_irqrestore(&vt_list->lock, flags);
+        spin_unlock_irqrestore(&vq->lock, flags);
         /* release CPU acquired in prepare_vtimer or mod_virt_timer() */
         put_cpu();
 }
@@ -381,14 +429,15 @@ EXPORT_SYMBOL(add_virt_timer_periodic);
  * If we change a pending timer the function must be called on the CPU
  * where the timer is running on, e.g. by smp_call_function_single()
  *
- * The original mod_timer adds the timer if it is not pending. For compatibility
- * we do the same. The timer will be added on the current CPU as a oneshot timer.
+ * The original mod_timer adds the timer if it is not pending. For
+ * compatibility we do the same. The timer will be added on the current
+ * CPU as a oneshot timer.
  *
  * returns whether it has modified a pending timer (1) or not (0)
  */
 int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
 {
-        struct vtimer_queue *vt_list;
+        struct vtimer_queue *vq;
         unsigned long flags;
         int cpu;
 
@@ -404,17 +453,17 @@ int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
                 return 1;
 
         cpu = get_cpu();
-        vt_list = &per_cpu(virt_cpu_timer, cpu);
+        vq = &per_cpu(virt_cpu_timer, cpu);
 
         /* check if we run on the right CPU */
         BUG_ON(timer->cpu != cpu);
 
         /* disable interrupts before test if timer is pending */
-        spin_lock_irqsave(&vt_list->lock, flags);
+        spin_lock_irqsave(&vq->lock, flags);
 
         /* if timer isn't pending add it on the current CPU */
         if (!vtimer_pending(timer)) {
-                spin_unlock_irqrestore(&vt_list->lock, flags);
+                spin_unlock_irqrestore(&vq->lock, flags);
                 /* we do not activate an interval timer with mod_virt_timer */
                 timer->interval = 0;
                 timer->expires = expires;
@@ -431,7 +480,7 @@ int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
                 timer->interval = expires;
 
         /* the timer can't expire anymore so we can release the lock */
-        spin_unlock_irqrestore(&vt_list->lock, flags);
+        spin_unlock_irqrestore(&vq->lock, flags);
         internal_add_vtimer(timer);
         return 1;
 }
@@ -445,25 +494,19 @@ EXPORT_SYMBOL(mod_virt_timer);
 int del_virt_timer(struct vtimer_list *timer)
 {
         unsigned long flags;
-        struct vtimer_queue *vt_list;
+        struct vtimer_queue *vq;
 
         /* check if timer is pending */
         if (!vtimer_pending(timer))
                 return 0;
 
-        vt_list = &per_cpu(virt_cpu_timer, timer->cpu);
-        spin_lock_irqsave(&vt_list->lock, flags);
+        vq = &per_cpu(virt_cpu_timer, timer->cpu);
+        spin_lock_irqsave(&vq->lock, flags);
 
         /* we don't interrupt a running timer, just let it expire! */
         list_del_init(&timer->entry);
 
-        /* last timer removed */
-        if (list_empty(&vt_list->list)) {
-                vt_list->to_expire = 0;
-                vt_list->offset = 0;
-        }
-
-        spin_unlock_irqrestore(&vt_list->lock, flags);
+        spin_unlock_irqrestore(&vq->lock, flags);
         return 1;
 }
 EXPORT_SYMBOL(del_virt_timer);
@@ -473,24 +516,19 @@ EXPORT_SYMBOL(del_virt_timer);
  */
 void init_cpu_vtimer(void)
 {
-        struct vtimer_queue *vt_list;
+        struct vtimer_queue *vq;
 
         /* kick the virtual timer */
-        S390_lowcore.exit_timer = VTIMER_MAX_SLICE;
-        S390_lowcore.last_update_timer = VTIMER_MAX_SLICE;
-        asm volatile ("SPT %0" : : "m" (S390_lowcore.last_update_timer));
         asm volatile ("STCK %0" : "=m" (S390_lowcore.last_update_clock));
+        asm volatile ("STPT %0" : "=m" (S390_lowcore.last_update_timer));
+
+        /* initialize per cpu vtimer structure */
+        vq = &__get_cpu_var(virt_cpu_timer);
+        INIT_LIST_HEAD(&vq->list);
+        spin_lock_init(&vq->lock);
 
         /* enable cpu timer interrupts */
         __ctl_set_bit(0,10);
-
-        vt_list = &__get_cpu_var(virt_cpu_timer);
-        INIT_LIST_HEAD(&vt_list->list);
-        spin_lock_init(&vt_list->lock);
-        vt_list->to_expire = 0;
-        vt_list->offset = 0;
-        vt_list->idle = 0;
-
 }
 
 void __init vtime_init(void)
diff --git a/arch/x86/ia32/ia32_signal.c b/arch/x86/ia32/ia32_signal.c
index b195f85526e3..9dabd00e9805 100644
--- a/arch/x86/ia32/ia32_signal.c
+++ b/arch/x86/ia32/ia32_signal.c
@@ -24,15 +24,14 @@
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/i387.h>
-#include <asm/ia32.h>
 #include <asm/ptrace.h>
 #include <asm/ia32_unistd.h>
 #include <asm/user32.h>
 #include <asm/sigcontext32.h>
 #include <asm/proto.h>
 #include <asm/vdso.h>
-
 #include <asm/sigframe.h>
+#include <asm/sys_ia32.h>
 
 #define DEBUG_SIG 0
 
diff --git a/arch/x86/ia32/ipc32.c b/arch/x86/ia32/ipc32.c
index d21991ce606c..29cdcd02ead3 100644
--- a/arch/x86/ia32/ipc32.c
+++ b/arch/x86/ia32/ipc32.c
@@ -8,6 +8,7 @@
 #include <linux/shm.h>
 #include <linux/ipc.h>
 #include <linux/compat.h>
+#include <asm/sys_ia32.h>
 
 asmlinkage long sys32_ipc(u32 call, int first, int second, int third,
                           compat_uptr_t ptr, u32 fifth)
diff --git a/arch/x86/ia32/sys_ia32.c b/arch/x86/ia32/sys_ia32.c
index 2e09dcd3c0a6..6c0d7f6231af 100644
--- a/arch/x86/ia32/sys_ia32.c
+++ b/arch/x86/ia32/sys_ia32.c
@@ -44,8 +44,8 @@
 #include <asm/types.h>
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
-#include <asm/ia32.h>
 #include <asm/vgtod.h>
+#include <asm/sys_ia32.h>
 
 #define AA(__x)         ((unsigned long)(__x))
 
diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
index 25caa0738af5..ab1d51a8855e 100644
--- a/arch/x86/include/asm/apic.h
+++ b/arch/x86/include/asm/apic.h
@@ -54,7 +54,6 @@ extern int disable_apic;
 extern int is_vsmp_box(void);
 extern void xapic_wait_icr_idle(void);
 extern u32 safe_xapic_wait_icr_idle(void);
-extern u64 xapic_icr_read(void);
 extern void xapic_icr_write(u32, u32);
 extern int setup_profiling_timer(unsigned int);
 
@@ -93,7 +92,7 @@ static inline u32 native_apic_msr_read(u32 reg)
 }
 
 #ifndef CONFIG_X86_32
-extern int x2apic, x2apic_preenabled;
+extern int x2apic;
 extern void check_x2apic(void);
 extern void enable_x2apic(void);
 extern void enable_IR_x2apic(void);
diff --git a/arch/x86/include/asm/efi.h b/arch/x86/include/asm/efi.h
index a2e545c91c35..ca5ffb2856b6 100644
--- a/arch/x86/include/asm/efi.h
+++ b/arch/x86/include/asm/efi.h
@@ -90,6 +90,7 @@ extern void __iomem *efi_ioremap(unsigned long addr, unsigned long size);
 
 #endif /* CONFIG_X86_32 */
 
+extern int add_efi_memmap;
 extern void efi_reserve_early(void);
 extern void efi_call_phys_prelog(void);
 extern void efi_call_phys_epilog(void);
diff --git a/arch/x86/include/asm/mpspec.h b/arch/x86/include/asm/mpspec.h
index 91885c28f66b..62d14ce3cd00 100644
--- a/arch/x86/include/asm/mpspec.h
+++ b/arch/x86/include/asm/mpspec.h
@@ -6,13 +6,13 @@
 #include <asm/mpspec_def.h>
 
 extern int apic_version[MAX_APICS];
+extern int pic_mode;
 
 #ifdef CONFIG_X86_32
 #include <mach_mpspec.h>
 
 extern unsigned int def_to_bigsmp;
 extern u8 apicid_2_node[];
-extern int pic_mode;
 
 #ifdef CONFIG_X86_NUMAQ
 extern int mp_bus_id_to_node[MAX_MP_BUSSES];
diff --git a/arch/x86/pci/pci.h b/arch/x86/include/asm/pci_x86.h
index 1959018aac02..e60fd3e14bdf 100644
--- a/arch/x86/pci/pci.h
+++ b/arch/x86/include/asm/pci_x86.h
@@ -57,7 +57,8 @@ extern struct pci_ops pci_root_ops;
 struct irq_info {
         u8 bus, devfn;                  /* Bus, device and function */
         struct {
-                u8 link;                /* IRQ line ID, chipset dependent, 0=not routed */
+                u8 link;                /* IRQ line ID, chipset dependent,
+                                           0 = not routed */
                 u16 bitmap;             /* Available IRQs */
         } __attribute__((packed)) irq[4];
         u8 slot;                        /* Slot number, 0=onboard */
@@ -69,11 +70,13 @@ struct irq_routing_table {
         u16 version;                    /* PIRQ_VERSION */
         u16 size;                       /* Table size in bytes */
         u8 rtr_bus, rtr_devfn;          /* Where the interrupt router lies */
-        u16 exclusive_irqs;             /* IRQs devoted exclusively to PCI usage */
-        u16 rtr_vendor, rtr_device;     /* Vendor and device ID of interrupt router */
+        u16 exclusive_irqs;             /* IRQs devoted exclusively to
+                                           PCI usage */
+        u16 rtr_vendor, rtr_device;     /* Vendor and device ID of
+                                           interrupt router */
         u32 miniport_data;              /* Crap */
         u8 rfu[11];
-        u8 checksum;                    /* Modulo 256 checksum must give zero */
+        u8 checksum;                    /* Modulo 256 checksum must give 0 */
         struct irq_info slots[0];
 } __attribute__((packed));
 
@@ -148,15 +151,15 @@ static inline unsigned int mmio_config_readl(void __iomem *pos)
 
 static inline void mmio_config_writeb(void __iomem *pos, u8 val)
 {
-        asm volatile("movb %%al,(%1)" :: "a" (val), "r" (pos) : "memory");
+        asm volatile("movb %%al,(%1)" : : "a" (val), "r" (pos) : "memory");
 }
 
 static inline void mmio_config_writew(void __iomem *pos, u16 val)
 {
-        asm volatile("movw %%ax,(%1)" :: "a" (val), "r" (pos) : "memory");
+        asm volatile("movw %%ax,(%1)" : : "a" (val), "r" (pos) : "memory");
 }
 
 static inline void mmio_config_writel(void __iomem *pos, u32 val)
 {
-        asm volatile("movl %%eax,(%1)" :: "a" (val), "r" (pos) : "memory");
+        asm volatile("movl %%eax,(%1)" : : "a" (val), "r" (pos) : "memory");
 }
diff --git a/arch/x86/include/asm/sys_ia32.h b/arch/x86/include/asm/sys_ia32.h
new file mode 100644
index 000000000000..ffb08be2a530
--- /dev/null
+++ b/arch/x86/include/asm/sys_ia32.h
@@ -0,0 +1,101 @@
+/*
+ * sys_ia32.h - Linux ia32 syscall interfaces
+ *
+ * Copyright (c) 2008 Jaswinder Singh Rajput
+ *
+ * This file is released under the GPLv2.
+ * See the file COPYING for more details.
+ */
+
+#ifndef _ASM_X86_SYS_IA32_H
+#define _ASM_X86_SYS_IA32_H
+
+#include <linux/compiler.h>
+#include <linux/linkage.h>
+#include <linux/types.h>
+#include <linux/signal.h>
+#include <asm/compat.h>
+#include <asm/ia32.h>
+
+/* ia32/sys_ia32.c */
+asmlinkage long sys32_truncate64(char __user *, unsigned long, unsigned long);
+asmlinkage long sys32_ftruncate64(unsigned int, unsigned long, unsigned long);
+
+asmlinkage long sys32_stat64(char __user *, struct stat64 __user *);
+asmlinkage long sys32_lstat64(char __user *, struct stat64 __user *);
+asmlinkage long sys32_fstat64(unsigned int, struct stat64 __user *);
+asmlinkage long sys32_fstatat(unsigned int, char __user *,
+                              struct stat64 __user *, int);
+struct mmap_arg_struct;
+asmlinkage long sys32_mmap(struct mmap_arg_struct __user *);
+asmlinkage long sys32_mprotect(unsigned long, size_t, unsigned long);
+
+asmlinkage long sys32_pipe(int __user *);
+struct sigaction32;
+struct old_sigaction32;
+asmlinkage long sys32_rt_sigaction(int, struct sigaction32 __user *,
+                                   struct sigaction32 __user *, unsigned int);
+asmlinkage long sys32_sigaction(int, struct old_sigaction32 __user *,
+                                struct old_sigaction32 __user *);
+asmlinkage long sys32_rt_sigprocmask(int, compat_sigset_t __user *,
+                                     compat_sigset_t __user *, unsigned int);
+asmlinkage long sys32_alarm(unsigned int);
+
+struct sel_arg_struct;
+asmlinkage long sys32_old_select(struct sel_arg_struct __user *);
+asmlinkage long sys32_waitpid(compat_pid_t, unsigned int *, int);
+asmlinkage long sys32_sysfs(int, u32, u32);
+
+asmlinkage long sys32_sched_rr_get_interval(compat_pid_t,
+                                            struct compat_timespec __user *);
+asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *, compat_size_t);
+asmlinkage long sys32_rt_sigqueueinfo(int, int, compat_siginfo_t __user *);
+
+#ifdef CONFIG_SYSCTL_SYSCALL
+struct sysctl_ia32;
+asmlinkage long sys32_sysctl(struct sysctl_ia32 __user *);
+#endif
+
+asmlinkage long sys32_pread(unsigned int, char __user *, u32, u32, u32);
+asmlinkage long sys32_pwrite(unsigned int, char __user *, u32, u32, u32);
+
+asmlinkage long sys32_personality(unsigned long);
+asmlinkage long sys32_sendfile(int, int, compat_off_t __user *, s32);
+
+asmlinkage long sys32_mmap2(unsigned long, unsigned long, unsigned long,
+                            unsigned long, unsigned long, unsigned long);
+
+struct oldold_utsname;
+struct old_utsname;
+asmlinkage long sys32_olduname(struct oldold_utsname __user *);
+long sys32_uname(struct old_utsname __user *);
+
+long sys32_ustat(unsigned, struct ustat32 __user *);
+
+asmlinkage long sys32_execve(char __user *, compat_uptr_t __user *,
+                             compat_uptr_t __user *, struct pt_regs *);
+asmlinkage long sys32_clone(unsigned int, unsigned int, struct pt_regs *);
+
+long sys32_lseek(unsigned int, int, unsigned int);
+long sys32_kill(int, int);
+long sys32_fadvise64_64(int, __u32, __u32, __u32, __u32, int);
+long sys32_vm86_warning(void);
+long sys32_lookup_dcookie(u32, u32, char __user *, size_t);
+
+asmlinkage ssize_t sys32_readahead(int, unsigned, unsigned, size_t);
+asmlinkage long sys32_sync_file_range(int, unsigned, unsigned,
+                                      unsigned, unsigned, int);
+asmlinkage long sys32_fadvise64(int, unsigned, unsigned, size_t, int);
+asmlinkage long sys32_fallocate(int, int, unsigned,
+                                unsigned, unsigned, unsigned);
+
+/* ia32/ia32_signal.c */
+asmlinkage long sys32_sigsuspend(int, int, old_sigset_t);
+asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *,
+                                  stack_ia32_t __user *, struct pt_regs *);
+asmlinkage long sys32_sigreturn(struct pt_regs *);
+asmlinkage long sys32_rt_sigreturn(struct pt_regs *);
+
+/* ia32/ipc32.c */
+asmlinkage long sys32_ipc(u32, int, int, int, compat_uptr_t, u32);
+#endif /* _ASM_X86_SYS_IA32_H */
diff --git a/arch/x86/include/asm/uv/uv_bau.h b/arch/x86/include/asm/uv/uv_bau.h
index e2363253bbbf..50423c7b56b2 100644
--- a/arch/x86/include/asm/uv/uv_bau.h
+++ b/arch/x86/include/asm/uv/uv_bau.h
@@ -133,61 +133,61 @@ struct bau_msg_payload {
  * see table 4.2.3.0.1 in broacast_assist spec.
  */
 struct bau_msg_header {
-        int dest_subnodeid:6;   /* must be zero */
+        unsigned int dest_subnodeid:6;  /* must be zero */
         /* bits 5:0 */
-        int base_dest_nodeid:15; /* nasid>>1 (pnode) of first bit in node_map */
-        /* bits 20:6 */
-        int command:8;          /* message type */
+        unsigned int base_dest_nodeid:15; /* nasid>>1 (pnode) of */
+        /* bits 20:6 */                   /* first bit in node_map */
+        unsigned int command:8; /* message type */
         /* bits 28:21 */
                                 /* 0x38: SN3net EndPoint Message */
-        int rsvd_1:3;           /* must be zero */
+        unsigned int rsvd_1:3;  /* must be zero */
         /* bits 31:29 */
                                 /* int will align on 32 bits */
-        int rsvd_2:9;           /* must be zero */
+        unsigned int rsvd_2:9;  /* must be zero */
         /* bits 40:32 */
                                 /* Suppl_A is 56-41 */
-        int payload_2a:8;       /* becomes byte 16 of msg */
+        unsigned int payload_2a:8;/* becomes byte 16 of msg */
         /* bits 48:41 */        /* not currently using */
-        int payload_2b:8;       /* becomes byte 17 of msg */
+        unsigned int payload_2b:8;/* becomes byte 17 of msg */
         /* bits 56:49 */        /* not currently using */
                                 /* Address field (96:57) is never used as an
                                    address (these are address bits 42:3) */
-        int rsvd_3:1;           /* must be zero */
+        unsigned int rsvd_3:1;  /* must be zero */
         /* bit 57 */
                                 /* address bits 27:4 are payload */
                                 /* these 24 bits become bytes 12-14 of msg */
-        int replied_to:1;       /* sent as 0 by the source to byte 12 */
+        unsigned int replied_to:1;/* sent as 0 by the source to byte 12 */
         /* bit 58 */
 
-        int payload_1a:5;       /* not currently used */
+        unsigned int payload_1a:5;/* not currently used */
         /* bits 63:59 */
-        int payload_1b:8;       /* not currently used */
+        unsigned int payload_1b:8;/* not currently used */
         /* bits 71:64 */
-        int payload_1c:8;       /* not currently used */
+        unsigned int payload_1c:8;/* not currently used */
         /* bits 79:72 */
-        int payload_1d:2;       /* not currently used */
+        unsigned int payload_1d:2;/* not currently used */
         /* bits 81:80 */
 
-        int rsvd_4:7;           /* must be zero */
+        unsigned int rsvd_4:7;  /* must be zero */
         /* bits 88:82 */
-        int sw_ack_flag:1;      /* software acknowledge flag */
+        unsigned int sw_ack_flag:1;/* software acknowledge flag */
         /* bit 89 */
                                 /* INTD trasactions at destination are to
                                    wait for software acknowledge */
-        int rsvd_5:6;           /* must be zero */
+        unsigned int rsvd_5:6;  /* must be zero */
         /* bits 95:90 */
-        int rsvd_6:5;           /* must be zero */
+        unsigned int rsvd_6:5;  /* must be zero */
         /* bits 100:96 */
-        int int_both:1;         /* if 1, interrupt both sockets on the blade */
+        unsigned int int_both:1;/* if 1, interrupt both sockets on the blade */
         /* bit 101*/
-        int fairness:3;         /* usually zero */
+        unsigned int fairness:3;/* usually zero */
         /* bits 104:102 */
-        int multilevel:1;       /* multi-level multicast format */
+        unsigned int multilevel:1;      /* multi-level multicast format */
         /* bit 105 */
                                 /* 0 for TLB: endpoint multi-unicast messages */
-        int chaining:1;         /* next descriptor is part of this activation*/
+        unsigned int chaining:1;/* next descriptor is part of this activation*/
         /* bit 106 */
-        int rsvd_7:21;          /* must be zero */
+        unsigned int rsvd_7:21; /* must be zero */
         /* bits 127:107 */
 };
 
diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
index be81f6125c51..42c33cebf00f 100644
--- a/arch/x86/kernel/amd_iommu_init.c
+++ b/arch/x86/kernel/amd_iommu_init.c
@@ -244,7 +244,7 @@ static void __init iommu_feature_disable(struct amd_iommu *iommu, u8 bit)
 }
 
 /* Function to enable the hardware */
-void __init iommu_enable(struct amd_iommu *iommu)
+static void __init iommu_enable(struct amd_iommu *iommu)
 {
         printk(KERN_INFO "AMD IOMMU: Enabling IOMMU at %s cap 0x%hx\n",
                dev_name(&iommu->dev->dev), iommu->cap_ptr);
@@ -253,7 +253,7 @@ void __init iommu_enable(struct amd_iommu *iommu)
 }
 
 /* Function to enable IOMMU event logging and event interrupts */
-void __init iommu_enable_event_logging(struct amd_iommu *iommu)
+static void __init iommu_enable_event_logging(struct amd_iommu *iommu)
 {
         iommu_feature_enable(iommu, CONTROL_EVT_LOG_EN);
         iommu_feature_enable(iommu, CONTROL_EVT_INT_EN);
diff --git a/arch/x86/kernel/apic.c b/arch/x86/kernel/apic.c
index 6b7f824db160..d652515e2855 100644
--- a/arch/x86/kernel/apic.c
+++ b/arch/x86/kernel/apic.c
@@ -98,8 +98,8 @@ __setup("apicpmtimer", setup_apicpmtimer);
 #ifdef HAVE_X2APIC
 int x2apic;
 /* x2apic enabled before OS handover */
-int x2apic_preenabled;
-int disable_x2apic;
+static int x2apic_preenabled;
+static int disable_x2apic;
 static __init int setup_nox2apic(char *str)
 {
         disable_x2apic = 1;
@@ -226,7 +226,7 @@ void xapic_icr_write(u32 low, u32 id)
         apic_write(APIC_ICR, low);
 }
 
-u64 xapic_icr_read(void)
+static u64 xapic_icr_read(void)
 {
         u32 icr1, icr2;
 
@@ -266,7 +266,7 @@ void x2apic_icr_write(u32 low, u32 id)
         wrmsrl(APIC_BASE_MSR + (APIC_ICR >> 4), ((__u64) id) << 32 | low);
 }
 
-u64 x2apic_icr_read(void)
+static u64 x2apic_icr_read(void)
 {
         unsigned long val;
 
diff --git a/arch/x86/kernel/bios_uv.c b/arch/x86/kernel/bios_uv.c
index 2a0a2a3cac26..f63882728d91 100644
--- a/arch/x86/kernel/bios_uv.c
+++ b/arch/x86/kernel/bios_uv.c
@@ -25,7 +25,7 @@
 #include <asm/uv/bios.h>
 #include <asm/uv/uv_hub.h>
 
-struct uv_systab uv_systab;
+static struct uv_systab uv_systab;
 
 s64 uv_bios_call(enum uv_bios_cmd which, u64 a1, u64 a2, u64 a3, u64 a4, u64 a5)
 {
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
index d6ec7ec30274..d259e5d2e054 100644
--- a/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -824,16 +824,14 @@ static int enable_mtrr_cleanup __initdata =
 
 static int __init disable_mtrr_cleanup_setup(char *str)
 {
-        if (enable_mtrr_cleanup != -1)
-                enable_mtrr_cleanup = 0;
+        enable_mtrr_cleanup = 0;
         return 0;
 }
 early_param("disable_mtrr_cleanup", disable_mtrr_cleanup_setup);
 
 static int __init enable_mtrr_cleanup_setup(char *str)
 {
-        if (enable_mtrr_cleanup != -1)
-                enable_mtrr_cleanup = 1;
+        enable_mtrr_cleanup = 1;
         return 0;
 }
 early_param("enable_mtrr_cleanup", enable_mtrr_cleanup_setup);
diff --git a/arch/x86/kernel/cpuid.c b/arch/x86/kernel/cpuid.c
index 72cefd1e649b..85d28d53f5d3 100644
--- a/arch/x86/kernel/cpuid.c
+++ b/arch/x86/kernel/cpuid.c
@@ -39,10 +39,10 @@
 #include <linux/device.h>
 #include <linux/cpu.h>
 #include <linux/notifier.h>
+#include <linux/uaccess.h>
 
 #include <asm/processor.h>
 #include <asm/msr.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 static struct class *cpuid_class;
@@ -82,7 +82,7 @@ static loff_t cpuid_seek(struct file *file, loff_t offset, int orig)
 }
 
 static ssize_t cpuid_read(struct file *file, char __user *buf,
-                          size_t count, loff_t * ppos)
+                          size_t count, loff_t *ppos)
 {
         char __user *tmp = buf;
         struct cpuid_regs cmd;
@@ -117,7 +117,7 @@ static int cpuid_open(struct inode *inode, struct file *file)
         unsigned int cpu;
         struct cpuinfo_x86 *c;
         int ret = 0;
-        
+
         lock_kernel();
 
         cpu = iminor(file->f_path.dentry->d_inode);
diff --git a/arch/x86/kernel/early_printk.c b/arch/x86/kernel/early_printk.c
index 23b138e31e9c..504ad198e4ad 100644
--- a/arch/x86/kernel/early_printk.c
+++ b/arch/x86/kernel/early_printk.c
@@ -886,7 +886,7 @@ asmlinkage void early_printk(const char *fmt, ...)
         va_list ap;
 
         va_start(ap, fmt);
-        n = vscnprintf(buf, 512, fmt, ap);
+        n = vscnprintf(buf, sizeof(buf), fmt, ap);
         early_console->write(early_console, buf, n);
         va_end(ap);
 }
diff --git a/arch/x86/kernel/genx2apic_phys.c b/arch/x86/kernel/genx2apic_phys.c
index 62895cf315ff..21bcc0e098ba 100644
--- a/arch/x86/kernel/genx2apic_phys.c
+++ b/arch/x86/kernel/genx2apic_phys.c
@@ -161,12 +161,12 @@ static unsigned int phys_pkg_id(int index_msb)
         return current_cpu_data.initial_apicid >> index_msb;
 }
 
-void x2apic_send_IPI_self(int vector)
+static void x2apic_send_IPI_self(int vector)
 {
         apic_write(APIC_SELF_IPI, vector);
 }
 
-void init_x2apic_ldr(void)
+static void init_x2apic_ldr(void)
 {
         return;
 }
diff --git a/arch/x86/kernel/head64.c b/arch/x86/kernel/head64.c
index 388e05a5fc17..b9a4d8c4b935 100644
--- a/arch/x86/kernel/head64.c
+++ b/arch/x86/kernel/head64.c
@@ -27,7 +27,7 @@
 #include <asm/trampoline.h>
 
 /* boot cpu pda */
-static struct x8664_pda _boot_cpu_pda __read_mostly;
+static struct x8664_pda _boot_cpu_pda;
 
 #ifdef CONFIG_SMP
 /*
diff --git a/arch/x86/kernel/io_apic.c b/arch/x86/kernel/io_apic.c
index 62ecfc991e1e..69911722b9d3 100644
--- a/arch/x86/kernel/io_apic.c
+++ b/arch/x86/kernel/io_apic.c
@@ -706,7 +706,7 @@ static void __unmask_IO_APIC_irq(struct irq_cfg *cfg)
 }
 
 #ifdef CONFIG_X86_64
-void io_apic_sync(struct irq_pin_list *entry)
+static void io_apic_sync(struct irq_pin_list *entry)
 {
         /*
          * Synchronize the IO-APIC and the CPU by doing
diff --git a/arch/x86/kernel/ldt.c b/arch/x86/kernel/ldt.c
index eee32b43fee3..71f1d99a635d 100644
--- a/arch/x86/kernel/ldt.c
+++ b/arch/x86/kernel/ldt.c
@@ -12,8 +12,8 @@
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/vmalloc.h>
+#include <linux/uaccess.h>
 
-#include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/ldt.h>
 #include <asm/desc.h>
@@ -93,7 +93,7 @@ static inline int copy_ldt(mm_context_t *new, mm_context_t *old)
         if (err < 0)
                 return err;
 
-        for(i = 0; i < old->size; i++)
+        for (i = 0; i < old->size; i++)
                 write_ldt_entry(new->ldt, i, old->ldt + i * LDT_ENTRY_SIZE);
         return 0;
 }
diff --git a/arch/x86/kernel/mmconf-fam10h_64.c b/arch/x86/kernel/mmconf-fam10h_64.c
index efc2f361fe85..666e43df51f9 100644
--- a/arch/x86/kernel/mmconf-fam10h_64.c
+++ b/arch/x86/kernel/mmconf-fam10h_64.c
@@ -13,8 +13,7 @@
 #include <asm/msr.h>
 #include <asm/acpi.h>
 #include <asm/mmconfig.h>
-
-#include "../pci/pci.h"
+#include <asm/pci_x86.h>
 
 struct pci_hostbridge_probe {
         u32 bus;
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c
index 45e3b69808ba..c5c5b8df1dbc 100644
--- a/arch/x86/kernel/mpparse.c
+++ b/arch/x86/kernel/mpparse.c
@@ -16,14 +16,14 @@
 #include <linux/bitops.h>
 #include <linux/acpi.h>
 #include <linux/module.h>
+#include <linux/smp.h>
+#include <linux/acpi.h>
 
-#include <asm/smp.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
 #include <asm/pgalloc.h>
 #include <asm/io_apic.h>
 #include <asm/proto.h>
-#include <asm/acpi.h>
 #include <asm/bios_ebda.h>
 #include <asm/e820.h>
 #include <asm/trampoline.h>
@@ -95,8 +95,8 @@ static void __init MP_bus_info(struct mpc_config_bus *m)
 #endif
 
         if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
-                 set_bit(m->mpc_busid, mp_bus_not_pci);
-#if defined(CONFIG_EISA) || defined (CONFIG_MCA)
+                set_bit(m->mpc_busid, mp_bus_not_pci);
+#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
 #endif
         } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
@@ -104,7 +104,7 @@ static void __init MP_bus_info(struct mpc_config_bus *m)
                         x86_quirks->mpc_oem_pci_bus(m);
 
                 clear_bit(m->mpc_busid, mp_bus_not_pci);
-#if defined(CONFIG_EISA) || defined (CONFIG_MCA)
+#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
         } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
diff --git a/arch/x86/kernel/nmi.c b/arch/x86/kernel/nmi.c
index 8bd1bf9622a7..45a09ccdc214 100644
--- a/arch/x86/kernel/nmi.c
+++ b/arch/x86/kernel/nmi.c
@@ -26,11 +26,10 @@
 #include <linux/kernel_stat.h>
 #include <linux/kdebug.h>
 #include <linux/smp.h>
+#include <linux/nmi.h>
 
 #include <asm/i8259.h>
 #include <asm/io_apic.h>
-#include <asm/smp.h>
-#include <asm/nmi.h>
 #include <asm/proto.h>
 #include <asm/timer.h>
 
diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/pci-gart_64.c
index a35eaa379ff6..00c2bcd41463 100644
--- a/arch/x86/kernel/pci-gart_64.c
+++ b/arch/x86/kernel/pci-gart_64.c
@@ -52,7 +52,7 @@ static u32 *iommu_gatt_base;		/* Remapping table */
  * to trigger bugs with some popular PCI cards, in particular 3ware (but
  * has been also also seen with Qlogic at least).
  */
-int iommu_fullflush = 1;
+static int iommu_fullflush = 1;
 
 /* Allocation bitmap for the remapping area: */
 static DEFINE_SPINLOCK(iommu_bitmap_lock);
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 39643b1df061..bf088c61fa40 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -12,6 +12,7 @@
 #include <asm/proto.h>
 #include <asm/reboot_fixups.h>
 #include <asm/reboot.h>
+#include <asm/pci_x86.h>
 #include <asm/virtext.h>
 
 #ifdef CONFIG_X86_32
@@ -24,7 +25,6 @@
 
 #include <mach_ipi.h>
 
-
 /*
  * Power off function, if any
  */
diff --git a/arch/x86/kernel/tlb_uv.c b/arch/x86/kernel/tlb_uv.c
index 6a00e5faaa74..f885023167e0 100644
--- a/arch/x86/kernel/tlb_uv.c
+++ b/arch/x86/kernel/tlb_uv.c
@@ -582,7 +582,6 @@ static int __init uv_ptc_init(void)
 static struct bau_control * __init uv_table_bases_init(int blade, int node)
 {
         int i;
-        int *ip;
         struct bau_msg_status *msp;
         struct bau_control *bau_tabp;
 
@@ -599,13 +598,6 @@ static struct bau_control * __init uv_table_bases_init(int blade, int node)
                 bau_cpubits_clear(&msp->seen_by, (int)
                                   uv_blade_nr_possible_cpus(blade));
 
-        bau_tabp->watching =
-            kmalloc_node(sizeof(int) * DEST_NUM_RESOURCES, GFP_KERNEL, node);
-        BUG_ON(!bau_tabp->watching);
-
-        for (i = 0, ip = bau_tabp->watching; i < DEST_Q_SIZE; i++, ip++)
-                *ip = 0;
-
         uv_bau_table_bases[blade] = bau_tabp;
 
         return bau_tabp;
@@ -628,7 +620,6 @@ uv_table_bases_finish(int blade, int node, int cur_cpu,
                 bcp->bau_msg_head       = bau_tablesp->va_queue_first;
                 bcp->va_queue_first     = bau_tablesp->va_queue_first;
                 bcp->va_queue_last      = bau_tablesp->va_queue_last;
-                bcp->watching           = bau_tablesp->watching;
                 bcp->msg_statuses       = bau_tablesp->msg_statuses;
                 bcp->descriptor_base    = adp;
         }
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
index 2d1f4c7e4052..ce6650eb64e9 100644
--- a/arch/x86/kernel/traps.c
+++ b/arch/x86/kernel/traps.c
@@ -292,8 +292,10 @@ dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code)
         tsk->thread.error_code = error_code;
         tsk->thread.trap_no = 8;
 
-        /* This is always a kernel trap and never fixable (and thus must
-           never return). */
+        /*
+         * This is always a kernel trap and never fixable (and thus must
+         * never return).
+         */
         for (;;)
                 die(str, regs, error_code);
 }
@@ -520,9 +522,11 @@ dotraplinkage void __kprobes do_int3(struct pt_regs *regs, long error_code)
 }
 
 #ifdef CONFIG_X86_64
-/* Help handler running on IST stack to switch back to user stack
-   for scheduling or signal handling. The actual stack switch is done in
-   entry.S */
+/*
+ * Help handler running on IST stack to switch back to user stack
+ * for scheduling or signal handling. The actual stack switch is done in
+ * entry.S
+ */
 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
 {
         struct pt_regs *regs = eregs;
@@ -532,8 +536,10 @@ asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
         /* Exception from user space */
         else if (user_mode(eregs))
                 regs = task_pt_regs(current);
-        /* Exception from kernel and interrupts are enabled. Move to
-           kernel process stack. */
+        /*
+         * Exception from kernel and interrupts are enabled. Move to
+         * kernel process stack.
+         */
         else if (eregs->flags & X86_EFLAGS_IF)
                 regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs));
         if (eregs != regs)
@@ -685,12 +691,7 @@ void math_error(void __user *ip)
         cwd = get_fpu_cwd(task);
         swd = get_fpu_swd(task);
 
-        err = swd & ~cwd & 0x3f;
-
-#ifdef CONFIG_X86_32
-        if (!err)
-                return;
-#endif
+        err = swd & ~cwd;
 
         if (err & 0x001) {      /* Invalid op */
                 /*
@@ -708,7 +709,11 @@ void math_error(void __user *ip)
         } else if (err & 0x020) { /* Precision */
                 info.si_code = FPE_FLTRES;
         } else {
-                info.si_code = __SI_FAULT|SI_KERNEL; /* WTF? */
+                /*
+                 * If we're using IRQ 13, or supposedly even some trap 16
+                 * implementations, it's possible we get a spurious trap...
+                 */
+                return;         /* Spurious trap, no error */
         }
         force_sig_info(SIGFPE, &info, task);
 }
diff --git a/arch/x86/kernel/xsave.c b/arch/x86/kernel/xsave.c
index 15c3e6999182..2b54fe002e94 100644
--- a/arch/x86/kernel/xsave.c
+++ b/arch/x86/kernel/xsave.c
@@ -159,7 +159,7 @@ int save_i387_xstate(void __user *buf)
  * Restore the extended state if present. Otherwise, restore the FP/SSE
  * state.
  */
-int restore_user_xstate(void __user *buf)
+static int restore_user_xstate(void __user *buf)
 {
         struct _fpx_sw_bytes fx_sw_user;
         u64 mask;
diff --git a/arch/x86/mach-default/setup.c b/arch/x86/mach-default/setup.c
index 37b9ae4d44c5..df167f265622 100644
--- a/arch/x86/mach-default/setup.c
+++ b/arch/x86/mach-default/setup.c
@@ -133,29 +133,28 @@ void __init time_init_hook(void)
  **/
 void mca_nmi_hook(void)
 {
-        /* If I recall correctly, there's a whole bunch of other things that
+        /*
+         * If I recall correctly, there's a whole bunch of other things that
          * we can do to check for NMI problems, but that's all I know about
          * at the moment.
          */
-
-        printk("NMI generated from unknown source!\n");
+        pr_warning("NMI generated from unknown source!\n");
 }
 #endif
 
 static __init int no_ipi_broadcast(char *str)
 {
         get_option(&str, &no_broadcast);
-        printk ("Using %s mode\n", no_broadcast ? "No IPI Broadcast" :
-                                                                                        "IPI Broadcast");
+        pr_info("Using %s mode\n",
+                no_broadcast ? "No IPI Broadcast" : "IPI Broadcast");
         return 1;
 }
-
 __setup("no_ipi_broadcast=", no_ipi_broadcast);
 
 static int __init print_ipi_mode(void)
 {
-        printk ("Using IPI %s mode\n", no_broadcast ? "No-Shortcut" :
-                                                                                        "Shortcut");
+        pr_info("Using IPI %s mode\n",
+                no_broadcast ? "No-Shortcut" : "Shortcut");
         return 0;
 }
 
diff --git a/arch/x86/pci/acpi.c b/arch/x86/pci/acpi.c
index 1d88d2b39771..9e5752fe4d15 100644
--- a/arch/x86/pci/acpi.c
+++ b/arch/x86/pci/acpi.c
@@ -4,7 +4,7 @@
 #include <linux/irq.h>
 #include <linux/dmi.h>
 #include <asm/numa.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 struct pci_root_info {
         char *name;
diff --git a/arch/x86/pci/amd_bus.c b/arch/x86/pci/amd_bus.c
index 22e057665e55..9bb09823b362 100644
--- a/arch/x86/pci/amd_bus.c
+++ b/arch/x86/pci/amd_bus.c
@@ -2,7 +2,7 @@
 #include <linux/pci.h>
 #include <linux/topology.h>
 #include <linux/cpu.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 #ifdef CONFIG_X86_64
 #include <asm/pci-direct.h>
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
index bb1a01f089e2..62ddb73e09ed 100644
--- a/arch/x86/pci/common.c
+++ b/arch/x86/pci/common.c
@@ -14,8 +14,7 @@
 #include <asm/segment.h>
 #include <asm/io.h>
 #include <asm/smp.h>
-
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
                                 PCI_PROBE_MMCONF;
diff --git a/arch/x86/pci/direct.c b/arch/x86/pci/direct.c
index 9a5af6c8fbe9..bd13c3e4c6db 100644
--- a/arch/x86/pci/direct.c
+++ b/arch/x86/pci/direct.c
@@ -5,7 +5,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/dmi.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /*
  * Functions for accessing PCI base (first 256 bytes) and extended
diff --git a/arch/x86/pci/early.c b/arch/x86/pci/early.c
index 86631ccbc25a..f6adf2c6d751 100644
--- a/arch/x86/pci/early.c
+++ b/arch/x86/pci/early.c
@@ -2,7 +2,7 @@
 #include <linux/pci.h>
 #include <asm/pci-direct.h>
 #include <asm/io.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /* Direct PCI access. This is used for PCI accesses in early boot before
    the PCI subsystem works. */
diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c
index 2051dc96b8e9..7d388d5cf548 100644
--- a/arch/x86/pci/fixup.c
+++ b/arch/x86/pci/fixup.c
@@ -6,8 +6,7 @@
 #include <linux/dmi.h>
 #include <linux/pci.h>
 #include <linux/init.h>
-#include "pci.h"
-
+#include <asm/pci_x86.h>
 
 static void __devinit pci_fixup_i450nx(struct pci_dev *d)
 {
diff --git a/arch/x86/pci/i386.c b/arch/x86/pci/i386.c
index 844df0cbbd3e..e51bf2cda4b0 100644
--- a/arch/x86/pci/i386.c
+++ b/arch/x86/pci/i386.c
@@ -34,8 +34,8 @@
 
 #include <asm/pat.h>
 #include <asm/e820.h>
+#include <asm/pci_x86.h>
 
-#include "pci.h"
 
 static int
 skip_isa_ioresource_align(struct pci_dev *dev) {
diff --git a/arch/x86/pci/init.c b/arch/x86/pci/init.c
index d6c950f81858..bec3b048e72b 100644
--- a/arch/x86/pci/init.c
+++ b/arch/x86/pci/init.c
@@ -1,6 +1,6 @@
 #include <linux/pci.h>
 #include <linux/init.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /* arch_initcall has too random ordering, so call the initializers
    in the right sequence from here. */
diff --git a/arch/x86/pci/irq.c b/arch/x86/pci/irq.c
index bf69dbe08bff..373b9afe6d44 100644
--- a/arch/x86/pci/irq.c
+++ b/arch/x86/pci/irq.c
@@ -16,8 +16,7 @@
 #include <asm/io_apic.h>
 #include <linux/irq.h>
 #include <linux/acpi.h>
-
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 #define PIRQ_SIGNATURE  (('$' << 0) + ('P' << 8) + ('I' << 16) + ('R' << 24))
 #define PIRQ_VERSION 0x0100
diff --git a/arch/x86/pci/legacy.c b/arch/x86/pci/legacy.c
index b722dd481b39..f1065b129e9c 100644
--- a/arch/x86/pci/legacy.c
+++ b/arch/x86/pci/legacy.c
@@ -3,7 +3,7 @@
  */
 #include <linux/init.h>
 #include <linux/pci.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /*
  * Discover remaining PCI buses in case there are peer host bridges.
diff --git a/arch/x86/pci/mmconfig-shared.c b/arch/x86/pci/mmconfig-shared.c
index 654a2234f8f3..89bf9242c80a 100644
--- a/arch/x86/pci/mmconfig-shared.c
+++ b/arch/x86/pci/mmconfig-shared.c
@@ -15,8 +15,7 @@
 #include <linux/acpi.h>
 #include <linux/bitmap.h>
 #include <asm/e820.h>
-
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /* aperture is up to 256MB but BIOS may reserve less */
 #define MMCONFIG_APER_MIN       (2 * 1024*1024)
diff --git a/arch/x86/pci/mmconfig_32.c b/arch/x86/pci/mmconfig_32.c
index f3c761dce695..8b2d561046a3 100644
--- a/arch/x86/pci/mmconfig_32.c
+++ b/arch/x86/pci/mmconfig_32.c
@@ -13,7 +13,7 @@
 #include <linux/init.h>
 #include <linux/acpi.h>
 #include <asm/e820.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /* Assume systems with more busses have correct MCFG */
 #define mmcfg_virt_addr ((void __iomem *) fix_to_virt(FIX_PCIE_MCFG))
diff --git a/arch/x86/pci/mmconfig_64.c b/arch/x86/pci/mmconfig_64.c
index a1994163c99d..30007ffc8e11 100644
--- a/arch/x86/pci/mmconfig_64.c
+++ b/arch/x86/pci/mmconfig_64.c
@@ -10,8 +10,7 @@
 #include <linux/acpi.h>
 #include <linux/bitmap.h>
 #include <asm/e820.h>
-
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /* Static virtual mapping of the MMCONFIG aperture */
 struct mmcfg_virt {
diff --git a/arch/x86/pci/numaq_32.c b/arch/x86/pci/numaq_32.c
index 1177845d3186..2089354968a2 100644
--- a/arch/x86/pci/numaq_32.c
+++ b/arch/x86/pci/numaq_32.c
@@ -7,7 +7,7 @@
 #include <linux/nodemask.h>
 #include <mach_apic.h>
 #include <asm/mpspec.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 #define XQUAD_PORTIO_BASE 0xfe400000
 #define XQUAD_PORTIO_QUAD 0x40000  /* 256k per quad. */
diff --git a/arch/x86/pci/olpc.c b/arch/x86/pci/olpc.c
index e11e9e803d5f..b889d824f7c6 100644
--- a/arch/x86/pci/olpc.c
+++ b/arch/x86/pci/olpc.c
@@ -29,7 +29,7 @@
 #include <linux/init.h>
 #include <asm/olpc.h>
 #include <asm/geode.h>
-#include "pci.h"
+#include <asm/pci_x86.h>
 
 /*
  * In the tables below, the first two line (8 longwords) are the
diff --git a/arch/x86/pci/pcbios.c b/arch/x86/pci/pcbios.c
index 37472fc6f729..b82cae970dfd 100644
--- a/arch/x86/pci/pcbios.c
+++ b/arch/x86/pci/pcbios.c
@@ -6,9 +6,8 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
-#include "pci.h"
-#include "pci-functions.h"
-
+#include <asm/pci_x86.h>
+#include <asm/mach-default/pci-functions.h>
 
 /* BIOS32 signature: "_32_" */
 #define BIOS32_SIGNATURE        (('_' << 0) + ('3' << 8) + ('2' << 16) + ('_' << 24))
diff --git a/arch/x86/pci/visws.c b/arch/x86/pci/visws.c
index 42f4cb19faca..16d0c0eb0d19 100644
--- a/arch/x86/pci/visws.c
+++ b/arch/x86/pci/visws.c
@@ -9,11 +9,10 @@
 #include <linux/init.h>
 
 #include <asm/setup.h>
+#include <asm/pci_x86.h>
 #include <asm/visws/cobalt.h>
 #include <asm/visws/lithium.h>
 
-#include "pci.h"
-
 static int pci_visws_enable_irq(struct pci_dev *dev) { return 0; }
 static void pci_visws_disable_irq(struct pci_dev *dev) { }
 
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index 65d75a6be0ba..14f240623497 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -132,8 +132,7 @@ static void do_stolen_accounting(void)
         *snap = state;
 
         /* Add the appropriate number of ticks of stolen time,
-           including any left-overs from last time.  Passing NULL to
-           account_steal_time accounts the time as stolen. */
+           including any left-overs from last time. */
         stolen = runnable + offline + __get_cpu_var(residual_stolen);
 
         if (stolen < 0)
@@ -141,11 +140,10 @@ static void do_stolen_accounting(void)
 
         ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
         __get_cpu_var(residual_stolen) = stolen;
-        account_steal_time(NULL, ticks);
+        account_steal_ticks(ticks);
 
         /* Add the appropriate number of ticks of blocked time,
-           including any left-overs from last time.  Passing idle to
-           account_steal_time accounts the time as idle/wait. */
+           including any left-overs from last time. */
         blocked += __get_cpu_var(residual_blocked);
 
         if (blocked < 0)
@@ -153,7 +151,7 @@ static void do_stolen_accounting(void)
 
         ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
         __get_cpu_var(residual_blocked) = blocked;
-        account_steal_time(idle_task(smp_processor_id()), ticks);
+        account_idle_ticks(ticks);
 }
 
 /*
diff --git a/drivers/char/random.c b/drivers/char/random.c
index d26891bfcd41..c7afc068c28d 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -559,7 +559,40 @@ struct timer_rand_state {
 };
 
 #ifndef CONFIG_SPARSE_IRQ
-struct timer_rand_state *irq_timer_state[NR_IRQS];
+
+static struct timer_rand_state *irq_timer_state[NR_IRQS];
+
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
+{
+        return irq_timer_state[irq];
+}
+
+static void set_timer_rand_state(unsigned int irq,
+                                 struct timer_rand_state *state)
+{
+        irq_timer_state[irq] = state;
+}
+
+#else
+
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
+{
+        struct irq_desc *desc;
+
+        desc = irq_to_desc(irq);
+
+        return desc->timer_rand_state;
+}
+
+static void set_timer_rand_state(unsigned int irq,
+                                 struct timer_rand_state *state)
+{
+        struct irq_desc *desc;
+
+        desc = irq_to_desc(irq);
+
+        desc->timer_rand_state = state;
+}
 #endif
 
 static struct timer_rand_state input_timer_state;
@@ -919,11 +952,6 @@ void rand_initialize_irq(int irq)
 {
         struct timer_rand_state *state;
 
-#ifndef CONFIG_SPARSE_IRQ
-        if (irq >= nr_irqs)
-                return;
-#endif
-
         state = get_timer_rand_state(irq);
 
         if (state)
diff --git a/drivers/media/common/saa7146_fops.c b/drivers/media/common/saa7146_fops.c
index 7d844af88384..cf06f4d10ad4 100644
--- a/drivers/media/common/saa7146_fops.c
+++ b/drivers/media/common/saa7146_fops.c
@@ -192,9 +192,9 @@ void saa7146_buffer_timeout(unsigned long data)
 /********************************************************************************/
 /* file operations */
 
-static int fops_open(struct inode *inode, struct file *file)
+static int fops_open(struct file *file)
 {
-        unsigned int minor = iminor(inode);
+        unsigned int minor = video_devdata(file)->minor;
         struct saa7146_dev *h = NULL, *dev = NULL;
         struct list_head *list;
         struct saa7146_fh *fh = NULL;
@@ -202,7 +202,7 @@ static int fops_open(struct inode *inode, struct file *file)
 
         enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
-        DEB_EE(("inode:%p, file:%p, minor:%d\n",inode,file,minor));
+        DEB_EE(("file:%p, minor:%d\n", file, minor));
 
         if (mutex_lock_interruptible(&saa7146_devices_lock))
                 return -ERESTARTSYS;
@@ -255,7 +255,7 @@ static int fops_open(struct inode *inode, struct file *file)
                 if (dev->ext_vv_data->capabilities & V4L2_CAP_VBI_CAPTURE)
                         result = saa7146_vbi_uops.open(dev,file);
                 if (dev->ext_vv_data->vbi_fops.open)
-                        dev->ext_vv_data->vbi_fops.open(inode, file);
+                        dev->ext_vv_data->vbi_fops.open(file);
         } else {
                 DEB_S(("initializing video...\n"));
                 result = saa7146_video_uops.open(dev,file);
@@ -280,12 +280,12 @@ out:
         return result;
 }
 
-static int fops_release(struct inode *inode, struct file *file)
+static int fops_release(struct file *file)
 {
         struct saa7146_fh  *fh  = file->private_data;
         struct saa7146_dev *dev = fh->dev;
 
-        DEB_EE(("inode:%p, file:%p\n",inode,file));
+        DEB_EE(("file:%p\n", file));
 
         if (mutex_lock_interruptible(&saa7146_devices_lock))
                 return -ERESTARTSYS;
@@ -294,7 +294,7 @@ static int fops_release(struct inode *inode, struct file *file)
                 if (dev->ext_vv_data->capabilities & V4L2_CAP_VBI_CAPTURE)
                         saa7146_vbi_uops.release(dev,file);
                 if (dev->ext_vv_data->vbi_fops.release)
-                        dev->ext_vv_data->vbi_fops.release(inode, file);
+                        dev->ext_vv_data->vbi_fops.release(file);
         } else {
                 saa7146_video_uops.release(dev,file);
         }
@@ -308,10 +308,10 @@ static int fops_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int fops_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long fops_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 /*
-        DEB_EE(("inode:%p, file:%p, cmd:%d, arg:%li\n",inode, file, cmd, arg));
+        DEB_EE(("file:%p, cmd:%d, arg:%li\n", file, cmd, arg));
 */
         return video_usercopy(file, cmd, arg, saa7146_video_do_ioctl);
 }
@@ -416,7 +416,7 @@ static ssize_t fops_write(struct file *file, const char __user *data, size_t cou
         }
 }
 
-static const struct file_operations video_fops =
+static const struct v4l2_file_operations video_fops =
 {
         .owner          = THIS_MODULE,
         .open           = fops_open,
@@ -426,7 +426,6 @@ static const struct file_operations video_fops =
         .poll           = fops_poll,
         .mmap           = fops_mmap,
         .ioctl          = fops_ioctl,
-        .llseek         = no_llseek,
 };
 
 static void vv_callback(struct saa7146_dev *dev, unsigned long status)
diff --git a/drivers/media/common/saa7146_video.c b/drivers/media/common/saa7146_video.c
index 101b01dbb8ea..6098b626811f 100644
--- a/drivers/media/common/saa7146_video.c
+++ b/drivers/media/common/saa7146_video.c
@@ -834,13 +834,14 @@ static int video_end(struct saa7146_fh *fh, struct file *file)
  * copying is done already, arg is a kernel pointer.
  */
 
-int saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+long saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct saa7146_fh *fh  = file->private_data;
         struct saa7146_dev *dev = fh->dev;
         struct saa7146_vv *vv = dev->vv_data;
 
-        int err = 0, result = 0, ee = 0;
+        long err = 0;
+        int result = 0, ee = 0;
 
         struct saa7146_use_ops *ops;
         struct videobuf_queue *q;
diff --git a/drivers/media/common/tuners/tuner-simple.c b/drivers/media/common/tuners/tuner-simple.c
index fb3f3b3adaba..de7adaf5fa5b 100644
--- a/drivers/media/common/tuners/tuner-simple.c
+++ b/drivers/media/common/tuners/tuner-simple.c
@@ -820,6 +820,15 @@ static u32 simple_dvb_configure(struct dvb_frontend *fe, u8 *buf,
         int ret;
         unsigned frequency = params->frequency / 62500;
 
+        if (!tun->stepsize) {
+                /* tuner-core was loaded before the digital tuner was
+                 * configured and somehow picked the wrong tuner type */
+                tuner_err("attempt to treat tuner %d (%s) as digital tuner "
+                          "without stepsize defined.\n",
+                          priv->type, priv->tun->name);
+                return 0; /* failure */
+        }
+
         t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL);
         ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb);
         if (ret < 0)
@@ -1059,7 +1068,12 @@ struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
         memcpy(&fe->ops.tuner_ops, &simple_tuner_ops,
                sizeof(struct dvb_tuner_ops));
 
-        tuner_info("type set to %d (%s)\n", type, priv->tun->name);
+        if (type != priv->type)
+                tuner_warn("couldn't set type to %d. Using %d (%s) instead\n",
+                            type, priv->type, priv->tun->name);
+        else
+                tuner_info("type set to %d (%s)\n",
+                           priv->type, priv->tun->name);
 
         if ((debug) || ((atv_input[priv->nr] > 0) ||
                         (dtv_input[priv->nr] > 0))) {
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 6c571d9f011c..65d69665f1fc 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -436,8 +436,9 @@ static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct dvb_device *dvbdev = dev_get_drvdata(dev);
 
-        add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
         add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num);
+        add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]);
+        add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
         return 0;
 }
 
diff --git a/drivers/media/dvb/dvb-usb/gp8psk.c b/drivers/media/dvb/dvb-usb/gp8psk.c
index c1da962cc886..3dd6843864ed 100644
--- a/drivers/media/dvb/dvb-usb/gp8psk.c
+++ b/drivers/media/dvb/dvb-usb/gp8psk.c
@@ -187,7 +187,7 @@ int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
         /* load BCM4500 firmware */
         if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
                 if (gp8psk_load_bcm4500fw(d))
-                        return EINVAL;
+                        return -EINVAL;
         return 0;
 }
 
diff --git a/drivers/media/dvb/frontends/cx24116.c b/drivers/media/dvb/frontends/cx24116.c
index 9b6c89e93f16..4f514d39b98f 100644
--- a/drivers/media/dvb/frontends/cx24116.c
+++ b/drivers/media/dvb/frontends/cx24116.c
@@ -1463,6 +1463,7 @@ static struct dvb_frontend_ops cx24116_ops = {
                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
                         FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
                         FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                        FE_CAN_2G_MODULATION |
                         FE_CAN_QPSK | FE_CAN_RECOVER
         },
 
diff --git a/drivers/media/dvb/frontends/cx24116.h b/drivers/media/dvb/frontends/cx24116.h
index 4cb3ddd6c626..b1b76b47a14c 100644
--- a/drivers/media/dvb/frontends/cx24116.h
+++ b/drivers/media/dvb/frontends/cx24116.h
@@ -37,7 +37,8 @@ struct cx24116_config {
         u8 mpg_clk_pos_pol:0x02;
 };
 
-#if defined(CONFIG_DVB_CX24116) || defined(CONFIG_DVB_CX24116_MODULE)
+#if defined(CONFIG_DVB_CX24116) || \
+        (defined(CONFIG_DVB_CX24116_MODULE) && defined(MODULE))
 extern struct dvb_frontend *cx24116_attach(
         const struct cx24116_config *config,
         struct i2c_adapter *i2c);
diff --git a/drivers/media/dvb/frontends/stb0899_drv.c b/drivers/media/dvb/frontends/stb0899_drv.c
index 528820170228..bee28f77b93f 100644
--- a/drivers/media/dvb/frontends/stb0899_drv.c
+++ b/drivers/media/dvb/frontends/stb0899_drv.c
@@ -1618,6 +1618,7 @@ static struct dvb_frontend_ops stb0899_ops = {
 
                 .caps                   = FE_CAN_INVERSION_AUTO |
                                           FE_CAN_FEC_AUTO       |
+                                          FE_CAN_2G_MODULATION  |
                                           FE_CAN_QPSK
         },
 
diff --git a/drivers/media/dvb/frontends/zl10353.c b/drivers/media/dvb/frontends/zl10353.c
index 5506f80e180e..170720b02815 100644
--- a/drivers/media/dvb/frontends/zl10353.c
+++ b/drivers/media/dvb/frontends/zl10353.c
@@ -587,8 +587,15 @@ static int zl10353_init(struct dvb_frontend *fe)
 
 static int zl10353_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 {
+        struct zl10353_state *state = fe->demodulator_priv;
         u8 val = 0x0a;
 
+        if (state->config.no_tuner) {
+                /* No tuner attached to the internal I2C bus */
+                /* If set enable I2C bridge, the main I2C bus stopped hardly */
+                return 0;
+        }
+
         if (enable)
                 val |= 0x10;
 
diff --git a/drivers/media/dvb/siano/sms-cards.c b/drivers/media/dvb/siano/sms-cards.c
index fd62e0b85621..4307e4e8aa34 100644
--- a/drivers/media/dvb/siano/sms-cards.c
+++ b/drivers/media/dvb/siano/sms-cards.c
@@ -120,7 +120,7 @@ static struct sms_board sms_boards[] = {
                 .name   = "Hauppauge WinTV MiniCard",
                 .type   = SMS_NOVA_B0,
                 .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-hcw-55xxx-dvbt-02.fw",
-                .lna_ctrl  = 1,
+                .lna_ctrl  = -1,
         },
 };
 
@@ -131,9 +131,10 @@ struct sms_board *sms_get_board(int id)
         return &sms_boards[id];
 }
 
-static int sms_set_gpio(struct smscore_device_t *coredev, u32 pin, int enable)
+static int sms_set_gpio(struct smscore_device_t *coredev, int pin, int enable)
 {
-        int ret;
+        int lvl, ret;
+        u32 gpio;
         struct smscore_gpio_config gpioconfig = {
                 .direction            = SMS_GPIO_DIRECTION_OUTPUT,
                 .pullupdown           = SMS_GPIO_PULLUPDOWN_NONE,
@@ -145,12 +146,20 @@ static int sms_set_gpio(struct smscore_device_t *coredev, u32 pin, int enable)
         if (pin == 0)
                 return -EINVAL;
 
-        ret = smscore_configure_gpio(coredev, pin, &gpioconfig);
+        if (pin < 0) {
+                /* inverted gpio */
+                gpio = pin * -1;
+                lvl = enable ? 0 : 1;
+        } else {
+                gpio = pin;
+                lvl = enable ? 1 : 0;
+        }
 
+        ret = smscore_configure_gpio(coredev, gpio, &gpioconfig);
         if (ret < 0)
                 return ret;
 
-        return smscore_set_gpio(coredev, pin, enable);
+        return smscore_set_gpio(coredev, gpio, lvl);
 }
 
 int sms_board_setup(struct smscore_device_t *coredev)
diff --git a/drivers/media/dvb/ttpci/av7110_v4l.c b/drivers/media/dvb/ttpci/av7110_v4l.c
index b4a0cc5dc935..c5b9c70563dc 100644
--- a/drivers/media/dvb/ttpci/av7110_v4l.c
+++ b/drivers/media/dvb/ttpci/av7110_v4l.c
@@ -316,7 +316,7 @@ static int av7110_dvb_c_switch(struct saa7146_fh *fh)
         return 0;
 }
 
-static int av7110_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
+static long av7110_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 {
         struct saa7146_dev *dev = fh->dev;
         struct av7110 *av7110 = (struct av7110*) dev->ext_priv;
@@ -567,7 +567,7 @@ static int av7110_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int av7110_vbi_reset(struct inode *inode, struct file *file)
+static int av7110_vbi_reset(struct file *file)
 {
         struct saa7146_fh *fh = file->private_data;
         struct saa7146_dev *dev = fh->dev;
diff --git a/drivers/media/dvb/ttpci/budget-av.c b/drivers/media/dvb/ttpci/budget-av.c
index f996cef79ec1..4182121d7e5d 100644
--- a/drivers/media/dvb/ttpci/budget-av.c
+++ b/drivers/media/dvb/ttpci/budget-av.c
@@ -1493,7 +1493,7 @@ static struct saa7146_extension_ioctls ioctls[] = {
         {0, 0}
 };
 
-static int av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
+static long av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 {
         struct saa7146_dev *dev = fh->dev;
         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
diff --git a/drivers/media/dvb/ttusb-budget/Kconfig b/drivers/media/dvb/ttusb-budget/Kconfig
index f546bccdb997..2663ae39b886 100644
--- a/drivers/media/dvb/ttusb-budget/Kconfig
+++ b/drivers/media/dvb/ttusb-budget/Kconfig
@@ -1,6 +1,6 @@
 config DVB_TTUSB_BUDGET
         tristate "Technotrend/Hauppauge Nova-USB devices"
-        depends on DVB_CORE && USB && I2C
+        depends on DVB_CORE && USB && I2C && PCI
         select DVB_CX22700 if !DVB_FE_CUSTOMISE
         select DVB_TDA1004X if !DVB_FE_CUSTOMISE
         select DVB_VES1820 if !DVB_FE_CUSTOMISE
diff --git a/drivers/media/dvb/ttusb-dec/Kconfig b/drivers/media/dvb/ttusb-dec/Kconfig
index d5f48a3102bd..290254ab06db 100644
--- a/drivers/media/dvb/ttusb-dec/Kconfig
+++ b/drivers/media/dvb/ttusb-dec/Kconfig
@@ -1,6 +1,6 @@
 config DVB_TTUSB_DEC
         tristate "Technotrend/Hauppauge USB DEC devices"
-        depends on DVB_CORE && USB && INPUT
+        depends on DVB_CORE && USB && INPUT && PCI
         select CRC32
         help
           Support for external USB adapters designed by Technotrend and
diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
index 5189c4eb439f..3315cac875e5 100644
--- a/drivers/media/radio/Kconfig
+++ b/drivers/media/radio/Kconfig
@@ -387,4 +387,23 @@ config USB_MR800
           To compile this driver as a module, choose M here: the
           module will be called radio-mr800.
 
+config RADIO_TEA5764
+        tristate "TEA5764 I2C FM radio support"
+        depends on I2C && VIDEO_V4L2
+        ---help---
+          Say Y here if you want to use the TEA5764 FM chip found in
+          EZX phones. This FM chip is present in EZX phones from Motorola,
+          connected to internal pxa I2C bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called radio-tea5764.
+
+config RADIO_TEA5764_XTAL
+        bool "TEA5764 crystal reference"
+        depends on RADIO_TEA5764=y
+        default y
+        help
+          Say Y here if TEA5764 have a 32768 Hz crystal in circuit, say N
+          here if TEA5764 reference frequency is connected in FREQIN.
+
 endif # RADIO_ADAPTERS
diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile
index 240ec63cdafc..0f2b35b3e560 100644
--- a/drivers/media/radio/Makefile
+++ b/drivers/media/radio/Makefile
@@ -19,5 +19,6 @@ obj-$(CONFIG_RADIO_MAESTRO) += radio-maestro.o
 obj-$(CONFIG_USB_DSBR) += dsbr100.o
 obj-$(CONFIG_USB_SI470X) += radio-si470x.o
 obj-$(CONFIG_USB_MR800) += radio-mr800.o
+obj-$(CONFIG_RADIO_TEA5764) += radio-tea5764.o
 
 EXTRA_CFLAGS += -Isound
diff --git a/drivers/media/radio/dsbr100.c b/drivers/media/radio/dsbr100.c
index 5474a22c1b22..2014ebc4e984 100644
--- a/drivers/media/radio/dsbr100.c
+++ b/drivers/media/radio/dsbr100.c
@@ -154,8 +154,8 @@ devices, that would be 76 and 91.  */
 static int usb_dsbr100_probe(struct usb_interface *intf,
                              const struct usb_device_id *id);
 static void usb_dsbr100_disconnect(struct usb_interface *intf);
-static int usb_dsbr100_open(struct inode *inode, struct file *file);
-static int usb_dsbr100_close(struct inode *inode, struct file *file);
+static int usb_dsbr100_open(struct file *file);
+static int usb_dsbr100_close(struct file *file);
 static int usb_dsbr100_suspend(struct usb_interface *intf,
                                                 pm_message_t message);
 static int usb_dsbr100_resume(struct usb_interface *intf);
@@ -566,7 +566,7 @@ static int vidioc_s_audio(struct file *file, void *priv,
         return 0;
 }
 
-static int usb_dsbr100_open(struct inode *inode, struct file *file)
+static int usb_dsbr100_open(struct file *file)
 {
         struct dsbr100_device *radio = video_drvdata(file);
         int retval;
@@ -593,7 +593,7 @@ static int usb_dsbr100_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int usb_dsbr100_close(struct inode *inode, struct file *file)
+static int usb_dsbr100_close(struct file *file)
 {
         struct dsbr100_device *radio = video_drvdata(file);
         int retval;
@@ -653,15 +653,11 @@ static void usb_dsbr100_video_device_release(struct video_device *videodev)
 }
 
 /* File system interface */
-static const struct file_operations usb_dsbr100_fops = {
+static const struct v4l2_file_operations usb_dsbr100_fops = {
         .owner          = THIS_MODULE,
         .open           = usb_dsbr100_open,
         .release        = usb_dsbr100_close,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
diff --git a/drivers/media/radio/radio-aimslab.c b/drivers/media/radio/radio-aimslab.c
index dd6d3dfcd7d2..bfa13b8b3043 100644
--- a/drivers/media/radio/radio-aimslab.c
+++ b/drivers/media/radio/radio-aimslab.c
@@ -374,26 +374,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct rt_device rtrack_unit;
 
-static int rtrack_exclusive_open(struct inode *inode, struct file *file)
+static int rtrack_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &rtrack_unit.in_use) ? -EBUSY : 0;
 }
 
-static int rtrack_exclusive_release(struct inode *inode, struct file *file)
+static int rtrack_exclusive_release(struct file *file)
 {
         clear_bit(0, &rtrack_unit.in_use);
         return 0;
 }
 
-static const struct file_operations rtrack_fops = {
+static const struct v4l2_file_operations rtrack_fops = {
         .owner          = THIS_MODULE,
         .open           = rtrack_exclusive_open,
         .release        = rtrack_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops rtrack_ioctl_ops = {
diff --git a/drivers/media/radio/radio-aztech.c b/drivers/media/radio/radio-aztech.c
index d78489573230..5604e881e96c 100644
--- a/drivers/media/radio/radio-aztech.c
+++ b/drivers/media/radio/radio-aztech.c
@@ -338,26 +338,22 @@ static int vidioc_s_ctrl (struct file *file, void *priv,
 
 static struct az_device aztech_unit;
 
-static int aztech_exclusive_open(struct inode *inode, struct file *file)
+static int aztech_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &aztech_unit.in_use) ? -EBUSY : 0;
 }
 
-static int aztech_exclusive_release(struct inode *inode, struct file *file)
+static int aztech_exclusive_release(struct file *file)
 {
         clear_bit(0, &aztech_unit.in_use);
         return 0;
 }
 
-static const struct file_operations aztech_fops = {
+static const struct v4l2_file_operations aztech_fops = {
         .owner          = THIS_MODULE,
         .open           = aztech_exclusive_open,
         .release        = aztech_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops aztech_ioctl_ops = {
diff --git a/drivers/media/radio/radio-cadet.c b/drivers/media/radio/radio-cadet.c
index bfd37f38b9ab..cb3075ac104c 100644
--- a/drivers/media/radio/radio-cadet.c
+++ b/drivers/media/radio/radio-cadet.c
@@ -529,7 +529,7 @@ static int vidioc_s_audio(struct file *file, void *priv,
 }
 
 static int
-cadet_open(struct inode *inode, struct file *file)
+cadet_open(struct file *file)
 {
         users++;
         if (1 == users) init_waitqueue_head(&read_queue);
@@ -537,7 +537,7 @@ cadet_open(struct inode *inode, struct file *file)
 }
 
 static int
-cadet_release(struct inode *inode, struct file *file)
+cadet_release(struct file *file)
 {
         users--;
         if (0 == users){
@@ -557,17 +557,13 @@ cadet_poll(struct file *file, struct poll_table_struct *wait)
 }
 
 
-static const struct file_operations cadet_fops = {
+static const struct v4l2_file_operations cadet_fops = {
         .owner          = THIS_MODULE,
         .open           = cadet_open,
         .release        = cadet_release,
         .read           = cadet_read,
         .ioctl          = video_ioctl2,
         .poll           = cadet_poll,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops cadet_ioctl_ops = {
diff --git a/drivers/media/radio/radio-gemtek-pci.c b/drivers/media/radio/radio-gemtek-pci.c
index e15bee6d7cfc..0c96bf8525b0 100644
--- a/drivers/media/radio/radio-gemtek-pci.c
+++ b/drivers/media/radio/radio-gemtek-pci.c
@@ -358,26 +358,22 @@ MODULE_DEVICE_TABLE( pci, gemtek_pci_id );
 
 static int mx = 1;
 
-static int gemtek_pci_exclusive_open(struct inode *inode, struct file *file)
+static int gemtek_pci_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
 }
 
-static int gemtek_pci_exclusive_release(struct inode *inode, struct file *file)
+static int gemtek_pci_exclusive_release(struct file *file)
 {
         clear_bit(0, &in_use);
         return 0;
 }
 
-static const struct file_operations gemtek_pci_fops = {
+static const struct v4l2_file_operations gemtek_pci_fops = {
         .owner          = THIS_MODULE,
         .open           = gemtek_pci_exclusive_open,
         .release        = gemtek_pci_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops gemtek_pci_ioctl_ops = {
diff --git a/drivers/media/radio/radio-gemtek.c b/drivers/media/radio/radio-gemtek.c
index e13118da307b..2b68be773f13 100644
--- a/drivers/media/radio/radio-gemtek.c
+++ b/drivers/media/radio/radio-gemtek.c
@@ -394,26 +394,22 @@ static struct v4l2_queryctrl radio_qctrl[] = {
         }
 };
 
-static int gemtek_exclusive_open(struct inode *inode, struct file *file)
+static int gemtek_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
 }
 
-static int gemtek_exclusive_release(struct inode *inode, struct file *file)
+static int gemtek_exclusive_release(struct file *file)
 {
         clear_bit(0, &in_use);
         return 0;
 }
 
-static const struct file_operations gemtek_fops = {
+static const struct v4l2_file_operations gemtek_fops = {
         .owner          = THIS_MODULE,
         .open           = gemtek_exclusive_open,
         .release        = gemtek_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek
 };
 
 static int vidioc_querycap(struct file *file, void *priv,
diff --git a/drivers/media/radio/radio-maestro.c b/drivers/media/radio/radio-maestro.c
index 4bf4d007bcfa..ba3a13a90013 100644
--- a/drivers/media/radio/radio-maestro.c
+++ b/drivers/media/radio/radio-maestro.c
@@ -79,12 +79,12 @@ static unsigned long in_use;
 
 static int maestro_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 
-static int maestro_exclusive_open(struct inode *inode, struct file *file)
+static int maestro_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
 }
 
-static int maestro_exclusive_release(struct inode *inode, struct file *file)
+static int maestro_exclusive_release(struct file *file)
 {
         clear_bit(0, &in_use);
         return 0;
@@ -110,15 +110,11 @@ static struct pci_driver maestro_r_driver = {
         .remove         = __devexit_p(maestro_remove),
 };
 
-static const struct file_operations maestro_fops = {
+static const struct v4l2_file_operations maestro_fops = {
         .owner          = THIS_MODULE,
         .open           = maestro_exclusive_open,
         .release        = maestro_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 struct radio_device {
diff --git a/drivers/media/radio/radio-maxiradio.c b/drivers/media/radio/radio-maxiradio.c
index c777a17b00bc..c5dc00aa9c9f 100644
--- a/drivers/media/radio/radio-maxiradio.c
+++ b/drivers/media/radio/radio-maxiradio.c
@@ -100,26 +100,22 @@ static unsigned long in_use;
 #define BITS2FREQ(x)    ((x) * FREQ_STEP - FREQ_IF)
 
 
-static int maxiradio_exclusive_open(struct inode *inode, struct file *file)
+static int maxiradio_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
 }
 
-static int maxiradio_exclusive_release(struct inode *inode, struct file *file)
+static int maxiradio_exclusive_release(struct file *file)
 {
         clear_bit(0, &in_use);
         return 0;
 }
 
-static const struct file_operations maxiradio_fops = {
+static const struct v4l2_file_operations maxiradio_fops = {
         .owner          = THIS_MODULE,
         .open           = maxiradio_exclusive_open,
         .release        = maxiradio_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static struct radio_device
diff --git a/drivers/media/radio/radio-mr800.c b/drivers/media/radio/radio-mr800.c
index e730eddb2bb5..0747dc8862b0 100644
--- a/drivers/media/radio/radio-mr800.c
+++ b/drivers/media/radio/radio-mr800.c
@@ -127,8 +127,8 @@ static struct v4l2_queryctrl radio_qctrl[] = {
 static int usb_amradio_probe(struct usb_interface *intf,
                              const struct usb_device_id *id);
 static void usb_amradio_disconnect(struct usb_interface *intf);
-static int usb_amradio_open(struct inode *inode, struct file *file);
-static int usb_amradio_close(struct inode *inode, struct file *file);
+static int usb_amradio_open(struct file *file);
+static int usb_amradio_close(struct file *file);
 static int usb_amradio_suspend(struct usb_interface *intf,
                                 pm_message_t message);
 static int usb_amradio_resume(struct usb_interface *intf);
@@ -500,7 +500,7 @@ static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 }
 
 /* open device - amradio_start() and amradio_setfreq() */
-static int usb_amradio_open(struct inode *inode, struct file *file)
+static int usb_amradio_open(struct file *file)
 {
         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
 
@@ -525,7 +525,7 @@ static int usb_amradio_open(struct inode *inode, struct file *file)
 }
 
 /*close device */
-static int usb_amradio_close(struct inode *inode, struct file *file)
+static int usb_amradio_close(struct file *file)
 {
         struct amradio_device *radio = video_get_drvdata(video_devdata(file));
         int retval;
@@ -572,15 +572,11 @@ static int usb_amradio_resume(struct usb_interface *intf)
 }
 
 /* File system interface */
-static const struct file_operations usb_amradio_fops = {
+static const struct v4l2_file_operations usb_amradio_fops = {
         .owner          = THIS_MODULE,
         .open           = usb_amradio_open,
         .release        = usb_amradio_close,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops usb_amradio_ioctl_ops = {
diff --git a/drivers/media/radio/radio-rtrack2.c b/drivers/media/radio/radio-rtrack2.c
index 7704f243b6f0..2587227214bf 100644
--- a/drivers/media/radio/radio-rtrack2.c
+++ b/drivers/media/radio/radio-rtrack2.c
@@ -280,26 +280,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct rt_device rtrack2_unit;
 
-static int rtrack2_exclusive_open(struct inode *inode, struct file *file)
+static int rtrack2_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &rtrack2_unit.in_use) ? -EBUSY : 0;
 }
 
-static int rtrack2_exclusive_release(struct inode *inode, struct file *file)
+static int rtrack2_exclusive_release(struct file *file)
 {
         clear_bit(0, &rtrack2_unit.in_use);
         return 0;
 }
 
-static const struct file_operations rtrack2_fops = {
+static const struct v4l2_file_operations rtrack2_fops = {
         .owner          = THIS_MODULE,
         .open           = rtrack2_exclusive_open,
         .release        = rtrack2_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops rtrack2_ioctl_ops = {
diff --git a/drivers/media/radio/radio-sf16fmi.c b/drivers/media/radio/radio-sf16fmi.c
index 834d43651c70..d358e48c2422 100644
--- a/drivers/media/radio/radio-sf16fmi.c
+++ b/drivers/media/radio/radio-sf16fmi.c
@@ -280,26 +280,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct fmi_device fmi_unit;
 
-static int fmi_exclusive_open(struct inode *inode, struct file *file)
+static int fmi_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &fmi_unit.in_use) ? -EBUSY : 0;
 }
 
-static int fmi_exclusive_release(struct inode *inode, struct file *file)
+static int fmi_exclusive_release(struct file *file)
 {
         clear_bit(0, &fmi_unit.in_use);
         return 0;
 }
 
-static const struct file_operations fmi_fops = {
+static const struct v4l2_file_operations fmi_fops = {
         .owner          = THIS_MODULE,
         .open           = fmi_exclusive_open,
         .release        = fmi_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops fmi_ioctl_ops = {
diff --git a/drivers/media/radio/radio-sf16fmr2.c b/drivers/media/radio/radio-sf16fmr2.c
index b1f47c322e02..92f17a347fa7 100644
--- a/drivers/media/radio/radio-sf16fmr2.c
+++ b/drivers/media/radio/radio-sf16fmr2.c
@@ -396,26 +396,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct fmr2_device fmr2_unit;
 
-static int fmr2_exclusive_open(struct inode *inode, struct file *file)
+static int fmr2_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &fmr2_unit.in_use) ? -EBUSY : 0;
 }
 
-static int fmr2_exclusive_release(struct inode *inode, struct file *file)
+static int fmr2_exclusive_release(struct file *file)
 {
         clear_bit(0, &fmr2_unit.in_use);
         return 0;
 }
 
-static const struct file_operations fmr2_fops = {
+static const struct v4l2_file_operations fmr2_fops = {
         .owner          = THIS_MODULE,
         .open           = fmr2_exclusive_open,
         .release        = fmr2_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops fmr2_ioctl_ops = {
diff --git a/drivers/media/radio/radio-si470x.c b/drivers/media/radio/radio-si470x.c
index 3e1830293de5..67cbce82cb91 100644
--- a/drivers/media/radio/radio-si470x.c
+++ b/drivers/media/radio/radio-si470x.c
@@ -96,6 +96,8 @@
  * 2008-10-20   Alexey Klimov <klimov.linux@gmail.com>
  *              - add support for KWorld USB FM Radio FM700
  *              - blacklisted KWorld radio in hid-core.c and hid-ids.h
+ * 2008-12-03   Mark Lord <mlord@pobox.com>
+ *              - add support for DealExtreme USB Radio
  *
  * ToDo:
  * - add firmware download/update support
@@ -138,6 +140,8 @@ static struct usb_device_id si470x_usb_driver_id_table[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(0x06e1, 0xa155, USB_CLASS_HID, 0, 0) },
         /* KWorld USB FM Radio SnapMusic Mobile 700 (FM700) */
         { USB_DEVICE_AND_INTERFACE_INFO(0x1b80, 0xd700, USB_CLASS_HID, 0, 0) },
+        /* DealExtreme USB Radio */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x10c5, 0x819a, USB_CLASS_HID, 0, 0) },
         /* Terminating entry */
         { }
 };
@@ -1075,7 +1079,7 @@ static unsigned int si470x_fops_poll(struct file *file,
 /*
  * si470x_fops_open - file open
  */
-static int si470x_fops_open(struct inode *inode, struct file *file)
+static int si470x_fops_open(struct file *file)
 {
         struct si470x_device *radio = video_drvdata(file);
         int retval;
@@ -1105,7 +1109,7 @@ done:
 /*
  * si470x_fops_release - file release
  */
-static int si470x_fops_release(struct inode *inode, struct file *file)
+static int si470x_fops_release(struct file *file)
 {
         struct si470x_device *radio = video_drvdata(file);
         int retval = 0;
@@ -1147,15 +1151,11 @@ done:
 /*
  * si470x_fops - file operations interface
  */
-static const struct file_operations si470x_fops = {
+static const struct v4l2_file_operations si470x_fops = {
         .owner          = THIS_MODULE,
-        .llseek         = no_llseek,
         .read           = si470x_fops_read,
         .poll           = si470x_fops_poll,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .open           = si470x_fops_open,
         .release        = si470x_fops_release,
 };
diff --git a/drivers/media/radio/radio-tea5764.c b/drivers/media/radio/radio-tea5764.c
new file mode 100644
index 000000000000..4d35308fc1ff
--- /dev/null
+++ b/drivers/media/radio/radio-tea5764.c
@@ -0,0 +1,634 @@
+/*
+ * driver/media/radio/radio-tea5764.c
+ *
+ * Driver for TEA5764 radio chip for linux 2.6.
+ * This driver is for TEA5764 chip from NXP, used in EZX phones from Motorola.
+ * The I2C protocol is used for communicate with chip.
+ *
+ * Based in radio-tea5761.c Copyright (C) 2005 Nokia Corporation
+ *
+ *  Copyright (c) 2008 Fabio Belavenuto <belavenuto@gmail.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.
+ *
+ * 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
+ *
+ * History:
+ * 2008-12-06   Fabio Belavenuto <belavenuto@gmail.com>
+ *              initial code
+ *
+ * TODO:
+ *  add platform_data support for IRQs platform dependencies
+ *  add RDS support
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>                 /* Initdata                     */
+#include <linux/videodev2.h>            /* kernel radio structs         */
+#include <linux/i2c.h>                  /* I2C                          */
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <linux/version.h>              /* for KERNEL_VERSION MACRO     */
+
+#define DRIVER_VERSION  "v0.01"
+#define RADIO_VERSION   KERNEL_VERSION(0, 0, 1)
+
+#define DRIVER_AUTHOR   "Fabio Belavenuto <belavenuto@gmail.com>"
+#define DRIVER_DESC     "A driver for the TEA5764 radio chip for EZX Phones."
+
+#define PINFO(format, ...)\
+        printk(KERN_INFO KBUILD_MODNAME ": "\
+                DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
+#define PWARN(format, ...)\
+        printk(KERN_WARNING KBUILD_MODNAME ": "\
+                DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
+# define PDEBUG(format, ...)\
+        printk(KERN_DEBUG KBUILD_MODNAME ": "\
+                DRIVER_VERSION ": " format "\n", ## __VA_ARGS__)
+
+/* Frequency limits in MHz -- these are European values.  For Japanese
+devices, that would be 76000 and 91000.  */
+#define FREQ_MIN  87500
+#define FREQ_MAX 108000
+#define FREQ_MUL 16
+
+/* TEA5764 registers */
+#define TEA5764_MANID           0x002b
+#define TEA5764_CHIPID          0x5764
+
+#define TEA5764_INTREG_BLMSK    0x0001
+#define TEA5764_INTREG_FRRMSK   0x0002
+#define TEA5764_INTREG_LEVMSK   0x0008
+#define TEA5764_INTREG_IFMSK    0x0010
+#define TEA5764_INTREG_BLMFLAG  0x0100
+#define TEA5764_INTREG_FRRFLAG  0x0200
+#define TEA5764_INTREG_LEVFLAG  0x0800
+#define TEA5764_INTREG_IFFLAG   0x1000
+
+#define TEA5764_FRQSET_SUD      0x8000
+#define TEA5764_FRQSET_SM       0x4000
+
+#define TEA5764_TNCTRL_PUPD1    0x8000
+#define TEA5764_TNCTRL_PUPD0    0x4000
+#define TEA5764_TNCTRL_BLIM     0x2000
+#define TEA5764_TNCTRL_SWPM     0x1000
+#define TEA5764_TNCTRL_IFCTC    0x0800
+#define TEA5764_TNCTRL_AFM      0x0400
+#define TEA5764_TNCTRL_SMUTE    0x0200
+#define TEA5764_TNCTRL_SNC      0x0100
+#define TEA5764_TNCTRL_MU       0x0080
+#define TEA5764_TNCTRL_SSL1     0x0040
+#define TEA5764_TNCTRL_SSL0     0x0020
+#define TEA5764_TNCTRL_HLSI     0x0010
+#define TEA5764_TNCTRL_MST      0x0008
+#define TEA5764_TNCTRL_SWP      0x0004
+#define TEA5764_TNCTRL_DTC      0x0002
+#define TEA5764_TNCTRL_AHLSI    0x0001
+
+#define TEA5764_TUNCHK_LEVEL(x) (((x) & 0x00F0) >> 4)
+#define TEA5764_TUNCHK_IFCNT(x) (((x) & 0xFE00) >> 9)
+#define TEA5764_TUNCHK_TUNTO    0x0100
+#define TEA5764_TUNCHK_LD       0x0008
+#define TEA5764_TUNCHK_STEREO   0x0004
+
+#define TEA5764_TESTREG_TRIGFR  0x0800
+
+struct tea5764_regs {
+        u16 intreg;                             /* INTFLAG & INTMSK */
+        u16 frqset;                             /* FRQSETMSB & FRQSETLSB */
+        u16 tnctrl;                             /* TNCTRL1 & TNCTRL2 */
+        u16 frqchk;                             /* FRQCHKMSB & FRQCHKLSB */
+        u16 tunchk;                             /* IFCHK & LEVCHK */
+        u16 testreg;                            /* TESTBITS & TESTMODE */
+        u16 rdsstat;                            /* RDSSTAT1 & RDSSTAT2 */
+        u16 rdslb;                              /* RDSLBMSB & RDSLBLSB */
+        u16 rdspb;                              /* RDSPBMSB & RDSPBLSB */
+        u16 rdsbc;                              /* RDSBBC & RDSGBC */
+        u16 rdsctrl;                            /* RDSCTRL1 & RDSCTRL2 */
+        u16 rdsbbl;                             /* PAUSEDET & RDSBBL */
+        u16 manid;                              /* MANID1 & MANID2 */
+        u16 chipid;                             /* CHIPID1 & CHIPID2 */
+} __attribute__ ((packed));
+
+struct tea5764_write_regs {
+        u8 intreg;                              /* INTMSK */
+        u16 frqset;                             /* FRQSETMSB & FRQSETLSB */
+        u16 tnctrl;                             /* TNCTRL1 & TNCTRL2 */
+        u16 testreg;                            /* TESTBITS & TESTMODE */
+        u16 rdsctrl;                            /* RDSCTRL1 & RDSCTRL2 */
+        u16 rdsbbl;                             /* PAUSEDET & RDSBBL */
+} __attribute__ ((packed));
+
+#ifndef RADIO_TEA5764_XTAL
+#define RADIO_TEA5764_XTAL 1
+#endif
+
+static int radio_nr = -1;
+static int use_xtal = RADIO_TEA5764_XTAL;
+
+struct tea5764_device {
+        struct i2c_client               *i2c_client;
+        struct video_device             *videodev;
+        struct tea5764_regs             regs;
+        struct mutex                    mutex;
+        int                             users;
+};
+
+/* I2C code related */
+int tea5764_i2c_read(struct tea5764_device *radio)
+{
+        int i;
+        u16 *p = (u16 *) &radio->regs;
+
+        struct i2c_msg msgs[1] = {
+                { radio->i2c_client->addr, I2C_M_RD, sizeof(radio->regs),
+                        (void *)&radio->regs },
+        };
+        if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
+                return -EIO;
+        for (i = 0; i < sizeof(struct tea5764_regs) / sizeof(u16); i++)
+                p[i] = __be16_to_cpu(p[i]);
+
+        return 0;
+}
+
+int tea5764_i2c_write(struct tea5764_device *radio)
+{
+        struct tea5764_write_regs wr;
+        struct tea5764_regs *r = &radio->regs;
+        struct i2c_msg msgs[1] = {
+                { radio->i2c_client->addr, 0, sizeof(wr), (void *) &wr },
+        };
+        wr.intreg  = r->intreg & 0xff;
+        wr.frqset  = __cpu_to_be16(r->frqset);
+        wr.tnctrl  = __cpu_to_be16(r->tnctrl);
+        wr.testreg = __cpu_to_be16(r->testreg);
+        wr.rdsctrl = __cpu_to_be16(r->rdsctrl);
+        wr.rdsbbl  = __cpu_to_be16(r->rdsbbl);
+        if (i2c_transfer(radio->i2c_client->adapter, msgs, 1) != 1)
+                return -EIO;
+        return 0;
+}
+
+/* V4L2 code related */
+static struct v4l2_queryctrl radio_qctrl[] = {
+        {
+                .id            = V4L2_CID_AUDIO_MUTE,
+                .name          = "Mute",
+                .minimum       = 0,
+                .maximum       = 1,
+                .default_value = 1,
+                .type          = V4L2_CTRL_TYPE_BOOLEAN,
+        }
+};
+
+static void tea5764_power_up(struct tea5764_device *radio)
+{
+        struct tea5764_regs *r = &radio->regs;
+
+        if (!(r->tnctrl & TEA5764_TNCTRL_PUPD0)) {
+                r->tnctrl &= ~(TEA5764_TNCTRL_AFM | TEA5764_TNCTRL_MU |
+                               TEA5764_TNCTRL_HLSI);
+                if (!use_xtal)
+                        r->testreg |= TEA5764_TESTREG_TRIGFR;
+                else
+                        r->testreg &= ~TEA5764_TESTREG_TRIGFR;
+
+                r->tnctrl |= TEA5764_TNCTRL_PUPD0;
+                tea5764_i2c_write(radio);
+        }
+}
+
+static void tea5764_power_down(struct tea5764_device *radio)
+{
+        struct tea5764_regs *r = &radio->regs;
+
+        if (r->tnctrl & TEA5764_TNCTRL_PUPD0) {
+                r->tnctrl &= ~TEA5764_TNCTRL_PUPD0;
+                tea5764_i2c_write(radio);
+        }
+}
+
+static void tea5764_set_freq(struct tea5764_device *radio, int freq)
+{
+        struct tea5764_regs *r = &radio->regs;
+
+        /* formula: (freq [+ or -] 225000) / 8192 */
+        if (r->tnctrl & TEA5764_TNCTRL_HLSI)
+                r->frqset = (freq + 225000) / 8192;
+        else
+                r->frqset = (freq - 225000) / 8192;
+}
+
+static int tea5764_get_freq(struct tea5764_device *radio)
+{
+        struct tea5764_regs *r = &radio->regs;
+
+        if (r->tnctrl & TEA5764_TNCTRL_HLSI)
+                return (r->frqchk * 8192) - 225000;
+        else
+                return (r->frqchk * 8192) + 225000;
+}
+
+/* tune an frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
+static void tea5764_tune(struct tea5764_device *radio, int freq)
+{
+        tea5764_set_freq(radio, freq);
+        if (tea5764_i2c_write(radio))
+                PWARN("Could not set frequency!");
+}
+
+static void tea5764_set_audout_mode(struct tea5764_device *radio, int audmode)
+{
+        struct tea5764_regs *r = &radio->regs;
+        int tnctrl = r->tnctrl;
+
+        if (audmode == V4L2_TUNER_MODE_MONO)
+                r->tnctrl |= TEA5764_TNCTRL_MST;
+        else
+                r->tnctrl &= ~TEA5764_TNCTRL_MST;
+        if (tnctrl != r->tnctrl)
+                tea5764_i2c_write(radio);
+}
+
+static int tea5764_get_audout_mode(struct tea5764_device *radio)
+{
+        struct tea5764_regs *r = &radio->regs;
+
+        if (r->tnctrl & TEA5764_TNCTRL_MST)
+                return V4L2_TUNER_MODE_MONO;
+        else
+                return V4L2_TUNER_MODE_STEREO;
+}
+
+static void tea5764_mute(struct tea5764_device *radio, int on)
+{
+        struct tea5764_regs *r = &radio->regs;
+        int tnctrl = r->tnctrl;
+
+        if (on)
+                r->tnctrl |= TEA5764_TNCTRL_MU;
+        else
+                r->tnctrl &= ~TEA5764_TNCTRL_MU;
+        if (tnctrl != r->tnctrl)
+                tea5764_i2c_write(radio);
+}
+
+static int tea5764_is_muted(struct tea5764_device *radio)
+{
+        return radio->regs.tnctrl & TEA5764_TNCTRL_MU;
+}
+
+/* V4L2 vidioc */
+static int vidioc_querycap(struct file *file, void  *priv,
+                                        struct v4l2_capability *v)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+        struct video_device *dev = radio->videodev;
+
+        strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
+        strlcpy(v->card, dev->name, sizeof(v->card));
+        snprintf(v->bus_info, sizeof(v->bus_info), "I2C:%s", dev->dev.bus_id);
+        v->version = RADIO_VERSION;
+        v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
+        return 0;
+}
+
+static int vidioc_g_tuner(struct file *file, void *priv,
+                                struct v4l2_tuner *v)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+        struct tea5764_regs *r = &radio->regs;
+
+        if (v->index > 0)
+                return -EINVAL;
+
+        memset(v, 0, sizeof(v));
+        strcpy(v->name, "FM");
+        v->type = V4L2_TUNER_RADIO;
+        tea5764_i2c_read(radio);
+        v->rangelow   = FREQ_MIN * FREQ_MUL;
+        v->rangehigh  = FREQ_MAX * FREQ_MUL;
+        v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
+        if (r->tunchk & TEA5764_TUNCHK_STEREO)
+                        v->rxsubchans = V4L2_TUNER_SUB_STEREO;
+        v->audmode = tea5764_get_audout_mode(radio);
+        v->signal = TEA5764_TUNCHK_LEVEL(r->tunchk) * 0xffff / 0xf;
+        v->afc = TEA5764_TUNCHK_IFCNT(r->tunchk);
+
+        return 0;
+}
+
+static int vidioc_s_tuner(struct file *file, void *priv,
+                                struct v4l2_tuner *v)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+
+        if (v->index > 0)
+                return -EINVAL;
+
+        tea5764_set_audout_mode(radio, v->audmode);
+        return 0;
+}
+
+static int vidioc_s_frequency(struct file *file, void *priv,
+                                struct v4l2_frequency *f)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+
+        if (f->tuner != 0)
+                return -EINVAL;
+        if (f->frequency == 0) {
+                /* We special case this as a power down control. */
+                tea5764_power_down(radio);
+        }
+        if (f->frequency < (FREQ_MIN * FREQ_MUL))
+                return -EINVAL;
+        if (f->frequency > (FREQ_MAX * FREQ_MUL))
+                return -EINVAL;
+        tea5764_power_up(radio);
+        tea5764_tune(radio, (f->frequency * 125) / 2);
+        return 0;
+}
+
+static int vidioc_g_frequency(struct file *file, void *priv,
+                                struct v4l2_frequency *f)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+        struct tea5764_regs *r = &radio->regs;
+
+        tea5764_i2c_read(radio);
+        memset(f, 0, sizeof(f));
+        f->type = V4L2_TUNER_RADIO;
+        if (r->tnctrl & TEA5764_TNCTRL_PUPD0)
+                f->frequency = (tea5764_get_freq(radio) * 2) / 125;
+        else
+                f->frequency = 0;
+
+        return 0;
+}
+
+static int vidioc_queryctrl(struct file *file, void *priv,
+                            struct v4l2_queryctrl *qc)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
+                if (qc->id && qc->id == radio_qctrl[i].id) {
+                        memcpy(qc, &(radio_qctrl[i]), sizeof(*qc));
+                        return 0;
+                }
+        }
+        return -EINVAL;
+}
+
+static int vidioc_g_ctrl(struct file *file, void *priv,
+                            struct v4l2_control *ctrl)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+
+        switch (ctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+                tea5764_i2c_read(radio);
+                ctrl->value = tea5764_is_muted(radio) ? 1 : 0;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int vidioc_s_ctrl(struct file *file, void *priv,
+                            struct v4l2_control *ctrl)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+
+        switch (ctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+                tea5764_mute(radio, ctrl->value);
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
+{
+        *i = 0;
+        return 0;
+}
+
+static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
+{
+        if (i != 0)
+                return -EINVAL;
+        return 0;
+}
+
+static int vidioc_g_audio(struct file *file, void *priv,
+                           struct v4l2_audio *a)
+{
+        if (a->index > 1)
+                return -EINVAL;
+
+        strcpy(a->name, "Radio");
+        a->capability = V4L2_AUDCAP_STEREO;
+        return 0;
+}
+
+static int vidioc_s_audio(struct file *file, void *priv,
+                           struct v4l2_audio *a)
+{
+        if (a->index != 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int tea5764_open(struct file *file)
+{
+        /* Currently we support only one device */
+        int minor = video_devdata(file)->minor;
+        struct tea5764_device *radio = video_drvdata(file);
+
+        if (radio->videodev->minor != minor)
+                return -ENODEV;
+
+        mutex_lock(&radio->mutex);
+        /* Only exclusive access */
+        if (radio->users) {
+                mutex_unlock(&radio->mutex);
+                return -EBUSY;
+        }
+        radio->users++;
+        mutex_unlock(&radio->mutex);
+        file->private_data = radio;
+        return 0;
+}
+
+static int tea5764_close(struct file *file)
+{
+        struct tea5764_device *radio = video_drvdata(file);
+
+        if (!radio)
+                return -ENODEV;
+        mutex_lock(&radio->mutex);
+        radio->users--;
+        mutex_unlock(&radio->mutex);
+        return 0;
+}
+
+/* File system interface */
+static const struct v4l2_file_operations tea5764_fops = {
+        .owner          = THIS_MODULE,
+        .open           = tea5764_open,
+        .release        = tea5764_close,
+        .ioctl          = video_ioctl2,
+};
+
+static const struct v4l2_ioctl_ops tea5764_ioctl_ops = {
+        .vidioc_querycap    = vidioc_querycap,
+        .vidioc_g_tuner     = vidioc_g_tuner,
+        .vidioc_s_tuner     = vidioc_s_tuner,
+        .vidioc_g_audio     = vidioc_g_audio,
+        .vidioc_s_audio     = vidioc_s_audio,
+        .vidioc_g_input     = vidioc_g_input,
+        .vidioc_s_input     = vidioc_s_input,
+        .vidioc_g_frequency = vidioc_g_frequency,
+        .vidioc_s_frequency = vidioc_s_frequency,
+        .vidioc_queryctrl   = vidioc_queryctrl,
+        .vidioc_g_ctrl      = vidioc_g_ctrl,
+        .vidioc_s_ctrl      = vidioc_s_ctrl,
+};
+
+/* V4L2 interface */
+static struct video_device tea5764_radio_template = {
+        .name           = "TEA5764 FM-Radio",
+        .fops           = &tea5764_fops,
+        .ioctl_ops      = &tea5764_ioctl_ops,
+        .release        = video_device_release,
+};
+
+/* I2C probe: check if the device exists and register with v4l if it is */
+static int __devinit tea5764_i2c_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct tea5764_device *radio;
+        struct tea5764_regs *r;
+        int ret;
+
+        PDEBUG("probe");
+        radio = kmalloc(sizeof(struct tea5764_device), GFP_KERNEL);
+        if (!radio)
+                return -ENOMEM;
+
+        mutex_init(&radio->mutex);
+        radio->i2c_client = client;
+        ret = tea5764_i2c_read(radio);
+        if (ret)
+                goto errfr;
+        r = &radio->regs;
+        PDEBUG("chipid = %04X, manid = %04X", r->chipid, r->manid);
+        if (r->chipid != TEA5764_CHIPID ||
+                (r->manid & 0x0fff) != TEA5764_MANID) {
+                PWARN("This chip is not a TEA5764!");
+                ret = -EINVAL;
+                goto errfr;
+        }
+
+        radio->videodev = video_device_alloc();
+        if (!(radio->videodev)) {
+                ret = -ENOMEM;
+                goto errfr;
+        }
+        memcpy(radio->videodev, &tea5764_radio_template,
+                sizeof(tea5764_radio_template));
+
+        i2c_set_clientdata(client, radio);
+        video_set_drvdata(radio->videodev, radio);
+
+        ret = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr);
+        if (ret < 0) {
+                PWARN("Could not register video device!");
+                goto errrel;
+        }
+
+        /* initialize and power off the chip */
+        tea5764_i2c_read(radio);
+        tea5764_set_audout_mode(radio, V4L2_TUNER_MODE_STEREO);
+        tea5764_mute(radio, 1);
+        tea5764_power_down(radio);
+
+        PINFO("registered.");
+        return 0;
+errrel:
+        video_device_release(radio->videodev);
+errfr:
+        kfree(radio);
+        return ret;
+}
+
+static int __devexit tea5764_i2c_remove(struct i2c_client *client)
+{
+        struct tea5764_device *radio = i2c_get_clientdata(client);
+
+        PDEBUG("remove");
+        if (radio) {
+                tea5764_power_down(radio);
+                video_unregister_device(radio->videodev);
+                kfree(radio);
+        }
+        return 0;
+}
+
+/* I2C subsystem interface */
+static const struct i2c_device_id tea5764_id[] = {
+        { "radio-tea5764", 0 },
+        { }                                     /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(i2c, tea5764_id);
+
+static struct i2c_driver tea5764_i2c_driver = {
+        .driver = {
+                .name = "radio-tea5764",
+                .owner = THIS_MODULE,
+        },
+        .probe = tea5764_i2c_probe,
+        .remove = __devexit_p(tea5764_i2c_remove),
+        .id_table = tea5764_id,
+};
+
+/* init the driver */
+static int __init tea5764_init(void)
+{
+        int ret = i2c_add_driver(&tea5764_i2c_driver);
+
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ": "
+                DRIVER_DESC "\n");
+        return ret;
+}
+
+/* cleanup the driver */
+static void __exit tea5764_exit(void)
+{
+        i2c_del_driver(&tea5764_i2c_driver);
+}
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+module_param(use_xtal, int, 1);
+MODULE_PARM_DESC(use_xtal, "Chip have a xtal connected in board");
+module_param(radio_nr, int, 0);
+MODULE_PARM_DESC(radio_nr, "video4linux device number to use");
+
+module_init(tea5764_init);
+module_exit(tea5764_exit);
diff --git a/drivers/media/radio/radio-terratec.c b/drivers/media/radio/radio-terratec.c
index 0abb186a9473..0798d71abd00 100644
--- a/drivers/media/radio/radio-terratec.c
+++ b/drivers/media/radio/radio-terratec.c
@@ -352,26 +352,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct tt_device terratec_unit;
 
-static int terratec_exclusive_open(struct inode *inode, struct file *file)
+static int terratec_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &terratec_unit.in_use) ? -EBUSY : 0;
 }
 
-static int terratec_exclusive_release(struct inode *inode, struct file *file)
+static int terratec_exclusive_release(struct file *file)
 {
         clear_bit(0, &terratec_unit.in_use);
         return 0;
 }
 
-static const struct file_operations terratec_fops = {
+static const struct v4l2_file_operations terratec_fops = {
         .owner          = THIS_MODULE,
         .open           = terratec_exclusive_open,
         .release        = terratec_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops terratec_ioctl_ops = {
diff --git a/drivers/media/radio/radio-trust.c b/drivers/media/radio/radio-trust.c
index e7b111fcd105..bdf9cb6a75f4 100644
--- a/drivers/media/radio/radio-trust.c
+++ b/drivers/media/radio/radio-trust.c
@@ -337,26 +337,22 @@ static int vidioc_s_audio(struct file *file, void *priv,
         return 0;
 }
 
-static int trust_exclusive_open(struct inode *inode, struct file *file)
+static int trust_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &in_use) ? -EBUSY : 0;
 }
 
-static int trust_exclusive_release(struct inode *inode, struct file *file)
+static int trust_exclusive_release(struct file *file)
 {
         clear_bit(0, &in_use);
         return 0;
 }
 
-static const struct file_operations trust_fops = {
+static const struct v4l2_file_operations trust_fops = {
         .owner          = THIS_MODULE,
         .open           = trust_exclusive_open,
         .release        = trust_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops trust_ioctl_ops = {
diff --git a/drivers/media/radio/radio-typhoon.c b/drivers/media/radio/radio-typhoon.c
index 952ec35a8415..5c3b319dab37 100644
--- a/drivers/media/radio/radio-typhoon.c
+++ b/drivers/media/radio/radio-typhoon.c
@@ -330,26 +330,22 @@ static struct typhoon_device typhoon_unit =
         .mutefreq       = CONFIG_RADIO_TYPHOON_MUTEFREQ,
 };
 
-static int typhoon_exclusive_open(struct inode *inode, struct file *file)
+static int typhoon_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &typhoon_unit.in_use) ? -EBUSY : 0;
 }
 
-static int typhoon_exclusive_release(struct inode *inode, struct file *file)
+static int typhoon_exclusive_release(struct file *file)
 {
         clear_bit(0, &typhoon_unit.in_use);
         return 0;
 }
 
-static const struct file_operations typhoon_fops = {
+static const struct v4l2_file_operations typhoon_fops = {
         .owner          = THIS_MODULE,
         .open           = typhoon_exclusive_open,
         .release        = typhoon_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops typhoon_ioctl_ops = {
diff --git a/drivers/media/radio/radio-zoltrix.c b/drivers/media/radio/radio-zoltrix.c
index 15b10bad6796..d2ac17eeec5f 100644
--- a/drivers/media/radio/radio-zoltrix.c
+++ b/drivers/media/radio/radio-zoltrix.c
@@ -401,27 +401,23 @@ static int vidioc_s_audio(struct file *file, void *priv,
 
 static struct zol_device zoltrix_unit;
 
-static int zoltrix_exclusive_open(struct inode *inode, struct file *file)
+static int zoltrix_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &zoltrix_unit.in_use) ? -EBUSY : 0;
 }
 
-static int zoltrix_exclusive_release(struct inode *inode, struct file *file)
+static int zoltrix_exclusive_release(struct file *file)
 {
         clear_bit(0, &zoltrix_unit.in_use);
         return 0;
 }
 
-static const struct file_operations zoltrix_fops =
+static const struct v4l2_file_operations zoltrix_fops =
 {
         .owner          = THIS_MODULE,
         .open           = zoltrix_exclusive_open,
         .release        = zoltrix_exclusive_release,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops zoltrix_ioctl_ops = {
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 1611c33b1aee..72f6d03d2d8f 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -12,7 +12,10 @@ omap2cam-objs	:=	omap24xxcam.o omap24xxcam-dma.o
 
 videodev-objs   :=      v4l2-dev.o v4l2-ioctl.o v4l2-device.o v4l2-subdev.o
 
-obj-$(CONFIG_VIDEO_DEV) += videodev.o v4l2-compat-ioctl32.o v4l2-int-device.o
+obj-$(CONFIG_VIDEO_DEV) += videodev.o v4l2-int-device.o
+ifeq ($(CONFIG_COMPAT),y)
+  obj-$(CONFIG_VIDEO_DEV) += v4l2-compat-ioctl32.o
+endif
 
 obj-$(CONFIG_VIDEO_V4L2_COMMON) += v4l2-common.o
 
diff --git a/drivers/media/video/arv.c b/drivers/media/video/arv.c
index 2ba6abd92b6f..d137bac84511 100644
--- a/drivers/media/video/arv.c
+++ b/drivers/media/video/arv.c
@@ -396,7 +396,7 @@ out_up:
         return ret;
 }
 
-static int ar_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long ar_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *dev = video_devdata(file);
         struct ar_device *ar = video_get_drvdata(dev);
@@ -539,7 +539,7 @@ static int ar_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int ar_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+static long ar_ioctl(struct file *file, unsigned int cmd,
                     unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, ar_do_ioctl);
@@ -744,27 +744,23 @@ void ar_release(struct video_device *vfd)
  ****************************************************************************/
 static struct ar_device ardev;
 
-static int ar_exclusive_open(struct inode *inode, struct file *file)
+static int ar_exclusive_open(struct file *file)
 {
         return test_and_set_bit(0, &ardev.in_use) ? -EBUSY : 0;
 }
 
-static int ar_exclusive_release(struct inode *inode, struct file *file)
+static int ar_exclusive_release(struct file *file)
 {
         clear_bit(0, &ardev.in_use);
         return 0;
 }
 
-static const struct file_operations ar_fops = {
+static const struct v4l2_file_operations ar_fops = {
         .owner          = THIS_MODULE,
         .open           = ar_exclusive_open,
         .release        = ar_exclusive_release,
         .read           = ar_read,
         .ioctl          = ar_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static struct video_device ar_template = {
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 9ec4cec2e52d..c71f394fc0ea 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -2039,7 +2039,7 @@ static int bttv_log_status(struct file *file, void *f)
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int bttv_g_register(struct file *file, void *f,
-                                        struct v4l2_register *reg)
+                                        struct v4l2_dbg_register *reg)
 {
         struct bttv_fh *fh = f;
         struct bttv *btv = fh->btv;
@@ -2047,18 +2047,19 @@ static int bttv_g_register(struct file *file, void *f,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
 
         /* bt848 has a 12-bit register space */
         reg->reg &= 0xfff;
         reg->val = btread(reg->reg);
+        reg->size = 1;
 
         return 0;
 }
 
 static int bttv_s_register(struct file *file, void *f,
-                                        struct v4l2_register *reg)
+                                        struct v4l2_dbg_register *reg)
 {
         struct bttv_fh *fh = f;
         struct bttv *btv = fh->btv;
@@ -2066,7 +2067,7 @@ static int bttv_s_register(struct file *file, void *f,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
 
         /* bt848 has a 12-bit register space */
@@ -3208,9 +3209,9 @@ err:
         return POLLERR;
 }
 
-static int bttv_open(struct inode *inode, struct file *file)
+static int bttv_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct bttv *btv = NULL;
         struct bttv_fh *fh;
         enum v4l2_buf_type type = 0;
@@ -3291,7 +3292,7 @@ static int bttv_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int bttv_release(struct inode *inode, struct file *file)
+static int bttv_release(struct file *file)
 {
         struct bttv_fh *fh = file->private_data;
         struct bttv *btv = fh->btv;
@@ -3346,14 +3347,12 @@ bttv_mmap(struct file *file, struct vm_area_struct *vma)
         return videobuf_mmap_mapper(bttv_queue(fh),vma);
 }
 
-static const struct file_operations bttv_fops =
+static const struct v4l2_file_operations bttv_fops =
 {
         .owner    = THIS_MODULE,
         .open     = bttv_open,
         .release  = bttv_release,
         .ioctl    = video_ioctl2,
-        .compat_ioctl   = v4l_compat_ioctl32,
-        .llseek   = no_llseek,
         .read     = bttv_read,
         .mmap     = bttv_mmap,
         .poll     = bttv_poll,
@@ -3422,9 +3421,9 @@ static struct video_device bttv_video_template = {
 /* ----------------------------------------------------------------------- */
 /* radio interface                                                         */
 
-static int radio_open(struct inode *inode, struct file *file)
+static int radio_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct bttv *btv = NULL;
         struct bttv_fh *fh;
         unsigned int i;
@@ -3467,12 +3466,13 @@ static int radio_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int radio_release(struct inode *inode, struct file *file)
+static int radio_release(struct file *file)
 {
         struct bttv_fh *fh = file->private_data;
         struct bttv *btv = fh->btv;
         struct rds_command cmd;
 
+        v4l2_prio_close(&btv->prio,&fh->prio);
         file->private_data = NULL;
         kfree(fh);
 
@@ -3633,15 +3633,13 @@ static unsigned int radio_poll(struct file *file, poll_table *wait)
         return cmd.result;
 }
 
-static const struct file_operations radio_fops =
+static const struct v4l2_file_operations radio_fops =
 {
         .owner    = THIS_MODULE,
         .open     = radio_open,
         .read     = radio_read,
         .release  = radio_release,
-        .compat_ioctl   = v4l_compat_ioctl32,
         .ioctl    = video_ioctl2,
-        .llseek   = no_llseek,
         .poll     = radio_poll,
 };
 
diff --git a/drivers/media/video/bw-qcam.c b/drivers/media/video/bw-qcam.c
index 17f80d03f38e..10dbd4a11b30 100644
--- a/drivers/media/video/bw-qcam.c
+++ b/drivers/media/video/bw-qcam.c
@@ -706,7 +706,7 @@ static long qc_capture(struct qcam_device * q, char __user *buf, unsigned long l
  *      Video4linux interfacing
  */
 
-static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam=(struct qcam_device *)dev;
@@ -863,7 +863,7 @@ static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int qcam_ioctl(struct inode *inode, struct file *file,
+static long qcam_ioctl(struct file *file,
                      unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, qcam_do_ioctl);
@@ -893,7 +893,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
         return len;
 }
 
-static int qcam_exclusive_open(struct inode *inode, struct file *file)
+static int qcam_exclusive_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam = (struct qcam_device *)dev;
@@ -901,7 +901,7 @@ static int qcam_exclusive_open(struct inode *inode, struct file *file)
         return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
 }
 
-static int qcam_exclusive_release(struct inode *inode, struct file *file)
+static int qcam_exclusive_release(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam = (struct qcam_device *)dev;
@@ -910,16 +910,12 @@ static int qcam_exclusive_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations qcam_fops = {
+static const struct v4l2_file_operations qcam_fops = {
         .owner          = THIS_MODULE,
         .open           = qcam_exclusive_open,
         .release        = qcam_exclusive_release,
         .ioctl          = qcam_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .read           = qcam_read,
-        .llseek         = no_llseek,
 };
 static struct video_device qcam_template=
 {
diff --git a/drivers/media/video/c-qcam.c b/drivers/media/video/c-qcam.c
index 21c71eb085db..85cf1778827a 100644
--- a/drivers/media/video/c-qcam.c
+++ b/drivers/media/video/c-qcam.c
@@ -500,7 +500,7 @@ static long qc_capture(struct qcam_device *q, char __user *buf, unsigned long le
  *      Video4linux interfacing
  */
 
-static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam=(struct qcam_device *)dev;
@@ -665,7 +665,7 @@ static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int qcam_ioctl(struct inode *inode, struct file *file,
+static long qcam_ioctl(struct file *file,
                       unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, qcam_do_ioctl);
@@ -687,7 +687,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
         return len;
 }
 
-static int qcam_exclusive_open(struct inode *inode, struct file *file)
+static int qcam_exclusive_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam = (struct qcam_device *)dev;
@@ -695,7 +695,7 @@ static int qcam_exclusive_open(struct inode *inode, struct file *file)
         return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
 }
 
-static int qcam_exclusive_release(struct inode *inode, struct file *file)
+static int qcam_exclusive_release(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct qcam_device *qcam = (struct qcam_device *)dev;
@@ -705,16 +705,12 @@ static int qcam_exclusive_release(struct inode *inode, struct file *file)
 }
 
 /* video device template */
-static const struct file_operations qcam_fops = {
+static const struct v4l2_file_operations qcam_fops = {
         .owner          = THIS_MODULE,
         .open           = qcam_exclusive_open,
         .release        = qcam_exclusive_release,
         .ioctl          = qcam_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .read           = qcam_read,
-        .llseek         = no_llseek,
 };
 
 static struct video_device qcam_template=
diff --git a/drivers/media/video/cafe_ccic.c b/drivers/media/video/cafe_ccic.c
index 1740b9ebdcef..34a39d2e4703 100644
--- a/drivers/media/video/cafe_ccic.c
+++ b/drivers/media/video/cafe_ccic.c
@@ -859,7 +859,7 @@ static int __cafe_cam_reset(struct cafe_camera *cam)
  */
 static int cafe_cam_init(struct cafe_camera *cam)
 {
-        struct v4l2_chip_ident chip = { V4L2_CHIP_MATCH_I2C_ADDR, 0, 0, 0 };
+        struct v4l2_dbg_chip_ident chip;
         int ret;
 
         mutex_lock(&cam->s_mutex);
@@ -869,8 +869,9 @@ static int cafe_cam_init(struct cafe_camera *cam)
         ret = __cafe_cam_reset(cam);
         if (ret)
                 goto out;
-        chip.match_chip = cam->sensor->addr;
-        ret = __cafe_cam_cmd(cam, VIDIOC_G_CHIP_IDENT, &chip);
+        chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
+        chip.match.addr = cam->sensor->addr;
+        ret = __cafe_cam_cmd(cam, VIDIOC_DBG_G_CHIP_IDENT, &chip);
         if (ret)
                 goto out;
         cam->sensor_type = chip.ident;
@@ -1472,11 +1473,11 @@ static int cafe_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
 
 
 
-static int cafe_v4l_open(struct inode *inode, struct file *filp)
+static int cafe_v4l_open(struct file *filp)
 {
         struct cafe_camera *cam;
 
-        cam = cafe_find_dev(iminor(inode));
+        cam = cafe_find_dev(video_devdata(filp)->minor);
         if (cam == NULL)
                 return -ENODEV;
         filp->private_data = cam;
@@ -1494,7 +1495,7 @@ static int cafe_v4l_open(struct inode *inode, struct file *filp)
 }
 
 
-static int cafe_v4l_release(struct inode *inode, struct file *filp)
+static int cafe_v4l_release(struct file *filp)
 {
         struct cafe_camera *cam = filp->private_data;
 
@@ -1759,7 +1760,7 @@ static void cafe_v4l_dev_release(struct video_device *vd)
  * clone it for specific real devices.
  */
 
-static const struct file_operations cafe_v4l_fops = {
+static const struct v4l2_file_operations cafe_v4l_fops = {
         .owner = THIS_MODULE,
         .open = cafe_v4l_open,
         .release = cafe_v4l_release,
@@ -1767,7 +1768,6 @@ static const struct file_operations cafe_v4l_fops = {
         .poll = cafe_v4l_poll,
         .mmap = cafe_v4l_mmap,
         .ioctl = video_ioctl2,
-        .llseek = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops cafe_v4l_ioctl_ops = {
diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c
index 028a400d2453..c3b0c8c63c76 100644
--- a/drivers/media/video/cpia.c
+++ b/drivers/media/video/cpia.c
@@ -3148,7 +3148,7 @@ static void put_cam(struct cpia_camera_ops* ops)
 }
 
 /* ------------------------- V4L interface --------------------- */
-static int cpia_open(struct inode *inode, struct file *file)
+static int cpia_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct cam_data *cam = video_get_drvdata(dev);
@@ -3225,7 +3225,7 @@ static int cpia_open(struct inode *inode, struct file *file)
         return err;
 }
 
-static int cpia_close(struct inode *inode, struct file *file)
+static int cpia_close(struct file *file)
 {
         struct  video_device *dev = file->private_data;
         struct cam_data *cam = video_get_drvdata(dev);
@@ -3333,7 +3333,7 @@ static ssize_t cpia_read(struct file *file, char __user *buf,
         return cam->decompressed_frame.count;
 }
 
-static int cpia_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long cpia_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *dev = file->private_data;
         struct cam_data *cam = video_get_drvdata(dev);
@@ -3720,7 +3720,7 @@ static int cpia_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return retval;
 }
 
-static int cpia_ioctl(struct inode *inode, struct file *file,
+static long cpia_ioctl(struct file *file,
                      unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, cpia_do_ioctl);
@@ -3780,17 +3780,13 @@ static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
         return 0;
 }
 
-static const struct file_operations cpia_fops = {
+static const struct v4l2_file_operations cpia_fops = {
         .owner          = THIS_MODULE,
         .open           = cpia_open,
         .release        = cpia_close,
         .read           = cpia_read,
         .mmap           = cpia_mmap,
         .ioctl          = cpia_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static struct video_device cpia_template = {
diff --git a/drivers/media/video/cpia2/cpia2_v4l.c b/drivers/media/video/cpia2/cpia2_v4l.c
index 3c2d7eac1197..9c25894fdd8e 100644
--- a/drivers/media/video/cpia2/cpia2_v4l.c
+++ b/drivers/media/video/cpia2/cpia2_v4l.c
@@ -239,7 +239,7 @@ static struct v4l2_queryctrl controls[] = {
  *  cpia2_open
  *
  *****************************************************************************/
-static int cpia2_open(struct inode *inode, struct file *file)
+static int cpia2_open(struct file *file)
 {
         struct camera_data *cam = video_drvdata(file);
         int retval = 0;
@@ -302,7 +302,7 @@ err_return:
  *  cpia2_close
  *
  *****************************************************************************/
-static int cpia2_close(struct inode *inode, struct file *file)
+static int cpia2_close(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct camera_data *cam = video_get_drvdata(dev);
@@ -1572,10 +1572,10 @@ static int ioctl_dqbuf(void *arg,struct camera_data *cam, struct file *file)
  *  cpia2_ioctl
  *
  *****************************************************************************/
-static int cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct camera_data *cam = video_drvdata(file);
-        int retval = 0;
+        long retval = 0;
 
         if (!cam)
                 return -ENOTTY;
@@ -1841,7 +1841,7 @@ static int cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return retval;
 }
 
-static int cpia2_ioctl(struct inode *inode, struct file *file,
+static long cpia2_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, cpia2_do_ioctl);
@@ -1912,17 +1912,13 @@ static void reset_camera_struct_v4l(struct camera_data *cam)
 /***
  * The v4l video device structure initialized for this device
  ***/
-static const struct file_operations fops_template = {
+static const struct v4l2_file_operations fops_template = {
         .owner          = THIS_MODULE,
         .open           = cpia2_open,
         .release        = cpia2_close,
         .read           = cpia2_v4l_read,
         .poll           = cpia2_v4l_poll,
         .ioctl          = cpia2_ioctl,
-        .llseek         = no_llseek,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .mmap           = cpia2_mmap,
 };
 
diff --git a/drivers/media/video/cs5345.c b/drivers/media/video/cs5345.c
index 70fcd0d5de13..14bebf8a116f 100644
--- a/drivers/media/video/cs5345.c
+++ b/drivers/media/video/cs5345.c
@@ -95,25 +95,24 @@ static int cs5345_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int cs5345_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int cs5345_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
+        reg->size = 1;
         reg->val = cs5345_read(sd, reg->reg & 0x1f);
         return 0;
 }
 
-static int cs5345_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int cs5345_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -122,7 +121,7 @@ static int cs5345_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
 }
 #endif
 
-static int cs5345_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int cs5345_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/cs53l32a.c b/drivers/media/video/cs53l32a.c
index cb65d519cf78..7292a6316e63 100644
--- a/drivers/media/video/cs53l32a.c
+++ b/drivers/media/video/cs53l32a.c
@@ -102,7 +102,7 @@ static int cs53l32a_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
         return 0;
 }
 
-static int cs53l32a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int cs53l32a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/cx18/cx18-fileops.c b/drivers/media/video/cx18/cx18-fileops.c
index 425271a29517..055f6e004b2d 100644
--- a/drivers/media/video/cx18/cx18-fileops.c
+++ b/drivers/media/video/cx18/cx18-fileops.c
@@ -552,7 +552,7 @@ void cx18_stop_capture(struct cx18_open_id *id, int gop_end)
         }
 }
 
-int cx18_v4l2_close(struct inode *inode, struct file *filp)
+int cx18_v4l2_close(struct file *filp)
 {
         struct cx18_open_id *id = filp->private_data;
         struct cx18 *cx = id->cx;
@@ -650,12 +650,12 @@ static int cx18_serialized_open(struct cx18_stream *s, struct file *filp)
         return 0;
 }
 
-int cx18_v4l2_open(struct inode *inode, struct file *filp)
+int cx18_v4l2_open(struct file *filp)
 {
         int res, x, y = 0;
         struct cx18 *cx = NULL;
         struct cx18_stream *s = NULL;
-        int minor = iminor(inode);
+        int minor = video_devdata(filp)->minor;
 
         /* Find which card this open was on */
         spin_lock(&cx18_cards_lock);
diff --git a/drivers/media/video/cx18/cx18-fileops.h b/drivers/media/video/cx18/cx18-fileops.h
index 46da0282fc7d..92e2d5dab936 100644
--- a/drivers/media/video/cx18/cx18-fileops.h
+++ b/drivers/media/video/cx18/cx18-fileops.h
@@ -22,12 +22,12 @@
  */
 
 /* Testing/Debugging */
-int cx18_v4l2_open(struct inode *inode, struct file *filp);
+int cx18_v4l2_open(struct file *filp);
 ssize_t cx18_v4l2_read(struct file *filp, char __user *buf, size_t count,
                       loff_t *pos);
 ssize_t cx18_v4l2_write(struct file *filp, const char __user *buf, size_t count,
                        loff_t *pos);
-int cx18_v4l2_close(struct inode *inode, struct file *filp);
+int cx18_v4l2_close(struct file *filp);
 unsigned int cx18_v4l2_enc_poll(struct file *filp, poll_table *wait);
 int cx18_start_capture(struct cx18_open_id *id);
 void cx18_stop_capture(struct cx18_open_id *id, int gop_end);
diff --git a/drivers/media/video/cx18/cx18-i2c.c b/drivers/media/video/cx18/cx18-i2c.c
index 8941f58bed7f..83e1c6333126 100644
--- a/drivers/media/video/cx18/cx18-i2c.c
+++ b/drivers/media/video/cx18/cx18-i2c.c
@@ -242,7 +242,7 @@ int cx18_call_i2c_client(struct cx18 *cx, int addr, unsigned cmd, void *arg)
                         return retval;
                 }
         }
-        if (cmd != VIDIOC_G_CHIP_IDENT)
+        if (cmd != VIDIOC_DBG_G_CHIP_IDENT)
                 CX18_ERR("i2c addr 0x%02x not found for cmd 0x%x!\n",
                                addr, cmd);
         return -ENODEV;
@@ -268,17 +268,6 @@ static int cx18_i2c_id_addr(struct cx18 *cx, u32 id)
         return retval;
 }
 
-/* Find the i2c device name matching the DRIVERID */
-static const char *cx18_i2c_id_name(u32 id)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
-                if (hw_driverids[i] == id)
-                        return hw_devicenames[i];
-        return "unknown device";
-}
-
 /* Find the i2c device name matching the CX18_HW_ flag */
 static const char *cx18_i2c_hw_name(u32 hw)
 {
@@ -326,21 +315,6 @@ int cx18_i2c_hw(struct cx18 *cx, u32 hw, unsigned int cmd, void *arg)
         return cx18_call_i2c_client(cx, addr, cmd, arg);
 }
 
-/* Calls i2c device based on I2C driver ID. */
-int cx18_i2c_id(struct cx18 *cx, u32 id, unsigned int cmd, void *arg)
-{
-        int addr;
-
-        addr = cx18_i2c_id_addr(cx, id);
-        if (addr < 0) {
-                if (cmd != VIDIOC_G_CHIP_IDENT)
-                        CX18_ERR("i2c ID 0x%08x (%s) not found for cmd 0x%x!\n",
-                                id, cx18_i2c_id_name(id), cmd);
-                return addr;
-        }
-        return cx18_call_i2c_client(cx, addr, cmd, arg);
-}
-
 /* broadcast cmd for all I2C clients and for the gpio subsystem */
 void cx18_call_i2c_clients(struct cx18 *cx, unsigned int cmd, void *arg)
 {
diff --git a/drivers/media/video/cx18/cx18-i2c.h b/drivers/media/video/cx18/cx18-i2c.h
index 113c3f9a2cc0..4869739013bd 100644
--- a/drivers/media/video/cx18/cx18-i2c.h
+++ b/drivers/media/video/cx18/cx18-i2c.h
@@ -23,7 +23,6 @@
 
 int cx18_i2c_hw_addr(struct cx18 *cx, u32 hw);
 int cx18_i2c_hw(struct cx18 *cx, u32 hw, unsigned int cmd, void *arg);
-int cx18_i2c_id(struct cx18 *cx, u32 id, unsigned int cmd, void *arg);
 int cx18_call_i2c_client(struct cx18 *cx, int addr, unsigned cmd, void *arg);
 void cx18_call_i2c_clients(struct cx18 *cx, unsigned int cmd, void *arg);
 int cx18_i2c_register(struct cx18 *cx, unsigned idx);
diff --git a/drivers/media/video/cx18/cx18-ioctl.c b/drivers/media/video/cx18/cx18-ioctl.c
index e6087486f889..7086aaba77d6 100644
--- a/drivers/media/video/cx18/cx18-ioctl.c
+++ b/drivers/media/video/cx18/cx18-ioctl.c
@@ -254,30 +254,24 @@ static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh,
 }
 
 static int cx18_g_chip_ident(struct file *file, void *fh,
-                                struct v4l2_chip_ident *chip)
+                                struct v4l2_dbg_chip_ident *chip)
 {
         struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
         chip->ident = V4L2_IDENT_NONE;
         chip->revision = 0;
-        if (chip->match_type == V4L2_CHIP_MATCH_HOST) {
-                if (v4l2_chip_match_host(chip->match_type, chip->match_chip))
-                        chip->ident = V4L2_IDENT_CX23418;
+        if (v4l2_chip_match_host(&chip->match)) {
+                chip->ident = V4L2_IDENT_CX23418;
                 return 0;
         }
-        if (chip->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-                return cx18_i2c_id(cx, chip->match_chip, VIDIOC_G_CHIP_IDENT,
-                                        chip);
-        if (chip->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
-                return cx18_call_i2c_client(cx, chip->match_chip,
-                                                VIDIOC_G_CHIP_IDENT, chip);
-        return -EINVAL;
+        cx18_call_i2c_clients(cx, VIDIOC_DBG_G_CHIP_IDENT, chip);
+        return 0;
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
 {
-        struct v4l2_register *regs = arg;
+        struct v4l2_dbg_register *regs = arg;
         unsigned long flags;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -286,6 +280,7 @@ static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
                 return -EINVAL;
 
         spin_lock_irqsave(&cx18_cards_lock, flags);
+        regs->size = 4;
         if (cmd == VIDIOC_DBG_G_REGISTER)
                 regs->val = cx18_read_enc(cx, regs->reg);
         else
@@ -295,31 +290,25 @@ static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
 }
 
 static int cx18_g_register(struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-        if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (v4l2_chip_match_host(&reg->match))
                 return cx18_cxc(cx, VIDIOC_DBG_G_REGISTER, reg);
-        if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-                return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
-                                        reg);
-        return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
-                                        reg);
+        cx18_call_i2c_clients(cx, VIDIOC_DBG_G_REGISTER, reg);
+        return 0;
 }
 
 static int cx18_s_register(struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-        if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (v4l2_chip_match_host(&reg->match))
                 return cx18_cxc(cx, VIDIOC_DBG_S_REGISTER, reg);
-        if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-                return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
-                                        reg);
-        return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
-                                        reg);
+        cx18_call_i2c_clients(cx, VIDIOC_DBG_S_REGISTER, reg);
+        return 0;
 }
 #endif
 
@@ -755,7 +744,7 @@ static int cx18_log_status(struct file *file, void *fh)
         return 0;
 }
 
-static int cx18_default(struct file *file, void *fh, int cmd, void *arg)
+static long cx18_default(struct file *file, void *fh, int cmd, void *arg)
 {
         struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
@@ -783,19 +772,19 @@ static int cx18_default(struct file *file, void *fh, int cmd, void *arg)
         return 0;
 }
 
-int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
+long cx18_v4l2_ioctl(struct file *filp, unsigned int cmd,
                     unsigned long arg)
 {
         struct video_device *vfd = video_devdata(filp);
         struct cx18_open_id *id = (struct cx18_open_id *)filp->private_data;
         struct cx18 *cx = id->cx;
-        int res;
+        long res;
 
         mutex_lock(&cx->serialize_lock);
 
         if (cx18_debug & CX18_DBGFLG_IOCTL)
                 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
-        res = video_ioctl2(inode, filp, cmd, arg);
+        res = video_ioctl2(filp, cmd, arg);
         vfd->debug = 0;
         mutex_unlock(&cx->serialize_lock);
         return res;
diff --git a/drivers/media/video/cx18/cx18-ioctl.h b/drivers/media/video/cx18/cx18-ioctl.h
index 08fe24e9510e..e2ca0d152116 100644
--- a/drivers/media/video/cx18/cx18-ioctl.h
+++ b/drivers/media/video/cx18/cx18-ioctl.h
@@ -29,5 +29,5 @@ void cx18_set_funcs(struct video_device *vdev);
 int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std);
 int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf);
 int cx18_s_input(struct file *file, void *fh, unsigned int inp);
-int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
+long cx18_v4l2_ioctl(struct file *filp, unsigned int cmd,
                     unsigned long arg);
diff --git a/drivers/media/video/cx18/cx18-streams.c b/drivers/media/video/cx18/cx18-streams.c
index 63c336c95ff5..89c1ec94f335 100644
--- a/drivers/media/video/cx18/cx18-streams.c
+++ b/drivers/media/video/cx18/cx18-streams.c
@@ -37,13 +37,12 @@
 
 #define CX18_DSP0_INTERRUPT_MASK        0xd0004C
 
-static struct file_operations cx18_v4l2_enc_fops = {
+static struct v4l2_file_operations cx18_v4l2_enc_fops = {
         .owner = THIS_MODULE,
         .read = cx18_v4l2_read,
         .open = cx18_v4l2_open,
         /* FIXME change to video_ioctl2 if serialization lock can be removed */
         .ioctl = cx18_v4l2_ioctl,
-        .compat_ioctl = v4l_compat_ioctl32,
         .release = cx18_v4l2_close,
         .poll = cx18_v4l2_enc_poll,
 };
@@ -61,49 +60,41 @@ static struct {
         int num_offset;
         int dma;
         enum v4l2_buf_type buf_type;
-        struct file_operations *fops;
 } cx18_stream_info[] = {
         {       /* CX18_ENC_STREAM_TYPE_MPG */
                 "encoder MPEG",
                 VFL_TYPE_GRABBER, 0,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_TS */
                 "TS",
                 VFL_TYPE_GRABBER, -1,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_YUV */
                 "encoder YUV",
                 VFL_TYPE_GRABBER, CX18_V4L2_ENC_YUV_OFFSET,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_VBI */
                 "encoder VBI",
                 VFL_TYPE_VBI, 0,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_VBI_CAPTURE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_PCM */
                 "encoder PCM audio",
                 VFL_TYPE_GRABBER, CX18_V4L2_ENC_PCM_OFFSET,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_PRIVATE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_IDX */
                 "encoder IDX",
                 VFL_TYPE_GRABBER, -1,
                 PCI_DMA_FROMDEVICE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                &cx18_v4l2_enc_fops
         },
         {       /* CX18_ENC_STREAM_TYPE_RAD */
                 "encoder radio",
                 VFL_TYPE_RADIO, 0,
                 PCI_DMA_NONE, V4L2_BUF_TYPE_PRIVATE,
-                &cx18_v4l2_enc_fops
         },
 };
 
@@ -184,7 +175,7 @@ static int cx18_prep_dev(struct cx18 *cx, int type)
 
         s->v4l2dev->num = num;
         s->v4l2dev->parent = &cx->dev->dev;
-        s->v4l2dev->fops = cx18_stream_info[type].fops;
+        s->v4l2dev->fops = &cx18_v4l2_enc_fops;
         s->v4l2dev->release = video_device_release;
         s->v4l2dev->tvnorms = V4L2_STD_ALL;
         cx18_set_funcs(s->v4l2dev);
diff --git a/drivers/media/video/cx23885/cx23885-417.c b/drivers/media/video/cx23885/cx23885-417.c
index 798d24024353..8f1db57bd1dd 100644
--- a/drivers/media/video/cx23885/cx23885-417.c
+++ b/drivers/media/video/cx23885/cx23885-417.c
@@ -1027,12 +1027,13 @@ static int cx23885_initialize_codec(struct cx23885_dev *dev)
                         printk(KERN_ERR "%s() f/w load failed\n", __func__);
                         return retval;
                 }
-                dev->cx23417_mailbox = cx23885_find_mailbox(dev);
-                if (dev->cx23417_mailbox < 0) {
+                retval = cx23885_find_mailbox(dev);
+                if (retval < 0) {
                         printk(KERN_ERR "%s() mailbox < 0, error\n",
                                 __func__);
                         return -1;
                 }
+                dev->cx23417_mailbox = retval;
                 retval = cx23885_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0);
                 if (retval < 0) {
                         printk(KERN_ERR
@@ -1573,9 +1574,9 @@ static int vidioc_queryctrl(struct file *file, void *priv,
         return cx23885_queryctrl(dev, c);
 }
 
-static int mpeg_open(struct inode *inode, struct file *file)
+static int mpeg_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct cx23885_dev *h, *dev = NULL;
         struct list_head *list;
         struct cx23885_fh *fh;
@@ -1617,7 +1618,7 @@ static int mpeg_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int mpeg_release(struct inode *inode, struct file *file)
+static int mpeg_release(struct file *file)
 {
         struct cx23885_fh  *fh  = file->private_data;
         struct cx23885_dev *dev = fh->dev;
@@ -1694,15 +1695,13 @@ static int mpeg_mmap(struct file *file, struct vm_area_struct *vma)
         return videobuf_mmap_mapper(&fh->mpegq, vma);
 }
 
-static struct file_operations mpeg_fops = {
+static struct v4l2_file_operations mpeg_fops = {
         .owner         = THIS_MODULE,
         .open          = mpeg_open,
         .release       = mpeg_release,
         .read          = mpeg_read,
         .poll          = mpeg_poll,
         .mmap          = mpeg_mmap,
-        .ioctl         = video_ioctl2,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index c742a10be5cb..2d81c4d04340 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -718,9 +718,9 @@ static int get_resource(struct cx23885_fh *fh)
         }
 }
 
-static int video_open(struct inode *inode, struct file *file)
+static int video_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct cx23885_dev *h, *dev = NULL;
         struct cx23885_fh *fh;
         struct list_head *list;
@@ -834,7 +834,7 @@ static unsigned int video_poll(struct file *file,
         return 0;
 }
 
-static int video_release(struct inode *inode, struct file *file)
+static int video_release(struct file *file)
 {
         struct cx23885_fh *fh = file->private_data;
         struct cx23885_dev *dev = fh->dev;
@@ -1326,11 +1326,11 @@ static int vidioc_s_frequency(struct file *file, void *priv,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register(struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx23885_dev *dev = ((struct cx23885_fh *)fh)->dev;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
 
         cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_DBG_G_REGISTER, reg);
@@ -1339,11 +1339,11 @@ static int vidioc_g_register(struct file *file, void *fh,
 }
 
 static int vidioc_s_register(struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx23885_dev *dev = ((struct cx23885_fh *)fh)->dev;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
 
         cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_DBG_S_REGISTER, reg);
@@ -1422,7 +1422,7 @@ int cx23885_video_irq(struct cx23885_dev *dev, u32 status)
 /* ----------------------------------------------------------- */
 /* exported stuff                                              */
 
-static const struct file_operations video_fops = {
+static const struct v4l2_file_operations video_fops = {
         .owner         = THIS_MODULE,
         .open          = video_open,
         .release       = video_release,
@@ -1430,8 +1430,6 @@ static const struct file_operations video_fops = {
         .poll          = video_poll,
         .mmap          = video_mmap,
         .ioctl         = video_ioctl2,
-        .compat_ioctl  = v4l_compat_ioctl32,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
@@ -1479,13 +1477,11 @@ static struct video_device cx23885_video_template = {
         .current_norm         = V4L2_STD_NTSC_M,
 };
 
-static const struct file_operations radio_fops = {
+static const struct v4l2_file_operations radio_fops = {
         .owner         = THIS_MODULE,
         .open          = video_open,
         .release       = video_release,
         .ioctl         = video_ioctl2,
-        .compat_ioctl  = v4l_compat_ioctl32,
-        .llseek        = no_llseek,
 };
 
 
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index 2ad277189da8..88f2fd32bfe3 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -1120,25 +1120,24 @@ static int cx25840_init(struct v4l2_subdev *sd, u32 val)
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
+        reg->size = 1;
         reg->val = cx25840_read(client, reg->reg & 0x0fff);
         return 0;
 }
 
-static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -1362,7 +1361,7 @@ static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
         return 0;
 }
 
-static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/cx88/cx88-blackbird.c b/drivers/media/video/cx88/cx88-blackbird.c
index e162a70748c5..7f5b8bfd08ac 100644
--- a/drivers/media/video/cx88/cx88-blackbird.c
+++ b/drivers/media/video/cx88/cx88-blackbird.c
@@ -1049,16 +1049,16 @@ static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *id)
 
 /* FIXME: cx88_ioctl_hook not implemented */
 
-static int mpeg_open(struct inode *inode, struct file *file)
+static int mpeg_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct cx8802_dev *dev = NULL;
         struct cx8802_fh *fh;
         struct cx8802_driver *drv = NULL;
         int err;
 
         lock_kernel();
-        dev = cx8802_get_device(inode);
+        dev = cx8802_get_device(minor);
 
         dprintk( 1, "%s\n", __func__);
 
@@ -1114,7 +1114,7 @@ static int mpeg_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int mpeg_release(struct inode *inode, struct file *file)
+static int mpeg_release(struct file *file)
 {
         struct cx8802_fh  *fh  = file->private_data;
         struct cx8802_dev *dev = fh->dev;
@@ -1132,7 +1132,7 @@ static int mpeg_release(struct inode *inode, struct file *file)
         kfree(fh);
 
         /* Make sure we release the hardware */
-        dev = cx8802_get_device(inode);
+        dev = cx8802_get_device(video_devdata(file)->minor);
         if (dev == NULL)
                 return -ENODEV;
 
@@ -1178,7 +1178,7 @@ mpeg_mmap(struct file *file, struct vm_area_struct * vma)
         return videobuf_mmap_mapper(&fh->mpegq, vma);
 }
 
-static const struct file_operations mpeg_fops =
+static const struct v4l2_file_operations mpeg_fops =
 {
         .owner         = THIS_MODULE,
         .open          = mpeg_open,
@@ -1187,7 +1187,6 @@ static const struct file_operations mpeg_fops =
         .poll          = mpeg_poll,
         .mmap          = mpeg_mmap,
         .ioctl         = video_ioctl2,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c
index a04fee235db6..59164fc94f5f 100644
--- a/drivers/media/video/cx88/cx88-mpeg.c
+++ b/drivers/media/video/cx88/cx88-mpeg.c
@@ -578,9 +578,8 @@ static int cx8802_resume_common(struct pci_dev *pci_dev)
 
 #if defined(CONFIG_VIDEO_CX88_BLACKBIRD) || \
     defined(CONFIG_VIDEO_CX88_BLACKBIRD_MODULE)
-struct cx8802_dev * cx8802_get_device(struct inode *inode)
+struct cx8802_dev *cx8802_get_device(int minor)
 {
-        int minor = iminor(inode);
         struct cx8802_dev *dev;
 
         list_for_each_entry(dev, &cx8802_devlist, devlist)
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index b96ce991d968..791e69d804f9 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -757,9 +757,9 @@ static int get_ressource(struct cx8800_fh *fh)
         }
 }
 
-static int video_open(struct inode *inode, struct file *file)
+static int video_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct cx8800_dev *h,*dev = NULL;
         struct cx88_core *core;
         struct cx8800_fh *fh;
@@ -904,7 +904,7 @@ video_poll(struct file *file, struct poll_table_struct *wait)
         return 0;
 }
 
-static int video_release(struct inode *inode, struct file *file)
+static int video_release(struct file *file)
 {
         struct cx8800_fh  *fh  = file->private_data;
         struct cx8800_dev *dev = fh->dev;
@@ -1447,25 +1447,26 @@ static int vidioc_s_frequency (struct file *file, void *priv,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register (struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
         /* cx2388x has a 24-bit register space */
-        reg->val = cx_read(reg->reg&0xffffff);
+        reg->val = cx_read(reg->reg & 0xffffff);
+        reg->size = 4;
         return 0;
 }
 
 static int vidioc_s_register (struct file *file, void *fh,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
-        cx_write(reg->reg&0xffffff, reg->val);
+        cx_write(reg->reg & 0xffffff, reg->val);
         return 0;
 }
 #endif
@@ -1693,7 +1694,7 @@ static irqreturn_t cx8800_irq(int irq, void *dev_id)
 /* ----------------------------------------------------------- */
 /* exported stuff                                              */
 
-static const struct file_operations video_fops =
+static const struct v4l2_file_operations video_fops =
 {
         .owner         = THIS_MODULE,
         .open          = video_open,
@@ -1702,8 +1703,6 @@ static const struct file_operations video_fops =
         .poll          = video_poll,
         .mmap          = video_mmap,
         .ioctl         = video_ioctl2,
-        .compat_ioctl  = v4l_compat_ioctl32,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
@@ -1752,14 +1751,12 @@ static struct video_device cx8800_video_template = {
         .current_norm         = V4L2_STD_NTSC_M,
 };
 
-static const struct file_operations radio_fops =
+static const struct v4l2_file_operations radio_fops =
 {
         .owner         = THIS_MODULE,
         .open          = video_open,
         .release       = video_release,
         .ioctl         = video_ioctl2,
-        .compat_ioctl  = v4l_compat_ioctl32,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index 20649b25f7ba..eb9ce30dc5e6 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -643,7 +643,7 @@ int cx88_audio_thread(void *data);
 
 int cx8802_register_driver(struct cx8802_driver *drv);
 int cx8802_unregister_driver(struct cx8802_driver *drv);
-struct cx8802_dev * cx8802_get_device(struct inode *inode);
+struct cx8802_dev *cx8802_get_device(int minor);
 struct cx8802_driver * cx8802_get_driver(struct cx8802_dev *dev, enum cx88_board_type btype);
 
 /* ----------------------------------------------------------- */
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
index 15c03f0e69ad..94378ccb7505 100644
--- a/drivers/media/video/em28xx/em28xx-audio.c
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -62,9 +62,9 @@ static int em28xx_isoc_audio_deinit(struct em28xx *dev)
 
         dprintk("Stopping isoc\n");
         for (i = 0; i < EM28XX_AUDIO_BUFS; i++) {
-                usb_unlink_urb(dev->adev->urb[i]);
-                usb_free_urb(dev->adev->urb[i]);
-                dev->adev->urb[i] = NULL;
+                usb_unlink_urb(dev->adev.urb[i]);
+                usb_free_urb(dev->adev.urb[i]);
+                dev->adev.urb[i] = NULL;
         }
 
         return 0;
@@ -81,8 +81,8 @@ static void em28xx_audio_isocirq(struct urb *urb)
         unsigned int             stride;
         struct snd_pcm_substream *substream;
         struct snd_pcm_runtime   *runtime;
-        if (dev->adev->capture_pcm_substream) {
-                substream = dev->adev->capture_pcm_substream;
+        if (dev->adev.capture_pcm_substream) {
+                substream = dev->adev.capture_pcm_substream;
                 runtime = substream->runtime;
                 stride = runtime->frame_bits >> 3;
 
@@ -95,7 +95,7 @@ static void em28xx_audio_isocirq(struct urb *urb)
                         if (!length)
                                 continue;
 
-                        oldptr = dev->adev->hwptr_done_capture;
+                        oldptr = dev->adev.hwptr_done_capture;
                         if (oldptr + length >= runtime->buffer_size) {
                                 unsigned int cnt =
                                     runtime->buffer_size - oldptr;
@@ -110,16 +110,16 @@ static void em28xx_audio_isocirq(struct urb *urb)
 
                         snd_pcm_stream_lock(substream);
 
-                        dev->adev->hwptr_done_capture += length;
-                        if (dev->adev->hwptr_done_capture >=
+                        dev->adev.hwptr_done_capture += length;
+                        if (dev->adev.hwptr_done_capture >=
                             runtime->buffer_size)
-                                dev->adev->hwptr_done_capture -=
+                                dev->adev.hwptr_done_capture -=
                                     runtime->buffer_size;
 
-                        dev->adev->capture_transfer_done += length;
-                        if (dev->adev->capture_transfer_done >=
+                        dev->adev.capture_transfer_done += length;
+                        if (dev->adev.capture_transfer_done >=
                             runtime->period_size) {
-                                dev->adev->capture_transfer_done -=
+                                dev->adev.capture_transfer_done -=
                                     runtime->period_size;
                                 period_elapsed = 1;
                         }
@@ -131,7 +131,7 @@ static void em28xx_audio_isocirq(struct urb *urb)
         }
         urb->status = 0;
 
-        if (dev->adev->shutdown)
+        if (dev->adev.shutdown)
                 return;
 
         status = usb_submit_urb(urb, GFP_ATOMIC);
@@ -154,17 +154,17 @@ static int em28xx_init_audio_isoc(struct em28xx *dev)
                 struct urb *urb;
                 int j, k;
 
-                dev->adev->transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
-                if (!dev->adev->transfer_buffer[i])
+                dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
+                if (!dev->adev.transfer_buffer[i])
                         return -ENOMEM;
 
-                memset(dev->adev->transfer_buffer[i], 0x80, sb_size);
+                memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
                 urb = usb_alloc_urb(EM28XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
                 if (!urb) {
                         em28xx_errdev("usb_alloc_urb failed!\n");
                         for (j = 0; j < i; j++) {
-                                usb_free_urb(dev->adev->urb[j]);
-                                kfree(dev->adev->transfer_buffer[j]);
+                                usb_free_urb(dev->adev.urb[j]);
+                                kfree(dev->adev.transfer_buffer[j]);
                         }
                         return -ENOMEM;
                 }
@@ -173,7 +173,7 @@ static int em28xx_init_audio_isoc(struct em28xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvisocpipe(dev->udev, 0x83);
                 urb->transfer_flags = URB_ISO_ASAP;
-                urb->transfer_buffer = dev->adev->transfer_buffer[i];
+                urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->interval = 1;
                 urb->complete = em28xx_audio_isocirq;
                 urb->number_of_packets = EM28XX_NUM_AUDIO_PACKETS;
@@ -185,11 +185,11 @@ static int em28xx_init_audio_isoc(struct em28xx *dev)
                         urb->iso_frame_desc[j].length =
                             EM28XX_AUDIO_MAX_PACKET_SIZE;
                 }
-                dev->adev->urb[i] = urb;
+                dev->adev.urb[i] = urb;
         }
 
         for (i = 0; i < EM28XX_AUDIO_BUFS; i++) {
-                errCode = usb_submit_urb(dev->adev->urb[i], GFP_ATOMIC);
+                errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
                 if (errCode) {
                         em28xx_isoc_audio_deinit(dev);
 
@@ -202,16 +202,16 @@ static int em28xx_init_audio_isoc(struct em28xx *dev)
 
 static int em28xx_cmd(struct em28xx *dev, int cmd, int arg)
 {
-        dprintk("%s transfer\n", (dev->adev->capture_stream == STREAM_ON)?
+        dprintk("%s transfer\n", (dev->adev.capture_stream == STREAM_ON) ?
                                  "stop" : "start");
 
         switch (cmd) {
         case EM28XX_CAPTURE_STREAM_EN:
-                if (dev->adev->capture_stream == STREAM_OFF && arg == 1) {
-                        dev->adev->capture_stream = STREAM_ON;
+                if (dev->adev.capture_stream == STREAM_OFF && arg == 1) {
+                        dev->adev.capture_stream = STREAM_ON;
                         em28xx_init_audio_isoc(dev);
-                } else if (dev->adev->capture_stream == STREAM_ON && arg == 0) {
-                        dev->adev->capture_stream = STREAM_OFF;
+                } else if (dev->adev.capture_stream == STREAM_ON && arg == 0) {
+                        dev->adev.capture_stream = STREAM_OFF;
                         em28xx_isoc_audio_deinit(dev);
                 } else {
                         printk(KERN_ERR "An underrun very likely occurred. "
@@ -289,17 +289,17 @@ static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
                 goto err;
 
         runtime->hw = snd_em28xx_hw_capture;
-        if (dev->alt == 0 && dev->adev->users == 0) {
+        if (dev->alt == 0 && dev->adev.users == 0) {
                 int errCode;
                 dev->alt = 7;
                 errCode = usb_set_interface(dev->udev, 0, 7);
                 dprintk("changing alternate number to 7\n");
         }
 
-        dev->adev->users++;
+        dev->adev.users++;
 
         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
-        dev->adev->capture_pcm_substream = substream;
+        dev->adev.capture_pcm_substream = substream;
         runtime->private_data = dev;
 
         return 0;
@@ -311,7 +311,7 @@ err:
 static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
 {
         struct em28xx *dev = snd_pcm_substream_chip(substream);
-        dev->adev->users--;
+        dev->adev.users--;
 
         dprintk("closing device\n");
 
@@ -320,10 +320,10 @@ static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
         em28xx_audio_analog_set(dev);
         mutex_unlock(&dev->lock);
 
-        if (dev->adev->users == 0 && dev->adev->shutdown == 1) {
-                dprintk("audio users: %d\n", dev->adev->users);
+        if (dev->adev.users == 0 && dev->adev.shutdown == 1) {
+                dprintk("audio users: %d\n", dev->adev.users);
                 dprintk("disabling audio stream!\n");
-                dev->adev->shutdown = 0;
+                dev->adev.shutdown = 0;
                 dprintk("released lock\n");
                 em28xx_cmd(dev, EM28XX_CAPTURE_STREAM_EN, 0);
         }
@@ -356,7 +356,7 @@ static int snd_em28xx_hw_capture_free(struct snd_pcm_substream *substream)
 
         dprintk("Stop capture, if needed\n");
 
-        if (dev->adev->capture_stream == STREAM_ON)
+        if (dev->adev.capture_stream == STREAM_ON)
                 em28xx_cmd(dev, EM28XX_CAPTURE_STREAM_EN, 0);
 
         return 0;
@@ -379,7 +379,7 @@ static int snd_em28xx_capture_trigger(struct snd_pcm_substream *substream,
                 em28xx_cmd(dev, EM28XX_CAPTURE_STREAM_EN, 1);
                 return 0;
         case SNDRV_PCM_TRIGGER_STOP:
-                dev->adev->shutdown = 1;
+                dev->adev.shutdown = 1;
                 return 0;
         default:
                 return -EINVAL;
@@ -393,7 +393,7 @@ static snd_pcm_uframes_t snd_em28xx_capture_pointer(struct snd_pcm_substream
 
         snd_pcm_uframes_t hwptr_done;
         dev = snd_pcm_substream_chip(substream);
-        hwptr_done = dev->adev->hwptr_done_capture;
+        hwptr_done = dev->adev.hwptr_done_capture;
 
         return hwptr_done;
 }
@@ -420,7 +420,7 @@ static struct snd_pcm_ops snd_em28xx_pcm_capture = {
 
 static int em28xx_audio_init(struct em28xx *dev)
 {
-        struct em28xx_audio *adev;
+        struct em28xx_audio *adev = &dev->adev;
         struct snd_pcm      *pcm;
         struct snd_card     *card;
         static int          devnr;
@@ -438,16 +438,9 @@ static int em28xx_audio_init(struct em28xx *dev)
         printk(KERN_INFO "em28xx-audio.c: Copyright (C) 2006 Markus "
                          "Rechberger\n");
 
-        adev = kzalloc(sizeof(*adev), GFP_KERNEL);
-        if (!adev) {
-                printk(KERN_ERR "em28xx-audio.c: out of memory\n");
-                return -1;
-        }
         card = snd_card_new(index[devnr], "Em28xx Audio", THIS_MODULE, 0);
-        if (card == NULL) {
-                kfree(adev);
+        if (card == NULL)
                 return -ENOMEM;
-        }
 
         spin_lock_init(&adev->slock);
         err = snd_pcm_new(card, "Em28xx Audio", 0, 0, 1, &pcm);
@@ -471,7 +464,6 @@ static int em28xx_audio_init(struct em28xx *dev)
         }
         adev->sndcard = card;
         adev->udev = dev->udev;
-        dev->adev = adev;
 
         return 0;
 }
@@ -488,10 +480,9 @@ static int em28xx_audio_fini(struct em28xx *dev)
                 return 0;
         }
 
-        if (dev->adev) {
-                snd_card_free(dev->adev->sndcard);
-                kfree(dev->adev);
-                dev->adev = NULL;
+        if (dev->adev.sndcard) {
+                snd_card_free(dev->adev.sndcard);
+                dev->adev.sndcard = NULL;
         }
 
         return 0;
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index f8504518586a..819cceaa6ef4 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -1000,12 +1000,11 @@ void em28xx_wake_i2c(struct em28xx *dev)
 static LIST_HEAD(em28xx_devlist);
 static DEFINE_MUTEX(em28xx_devlist_mutex);
 
-struct em28xx *em28xx_get_device(struct inode *inode,
+struct em28xx *em28xx_get_device(int minor,
                                  enum v4l2_buf_type *fh_type,
                                  int *has_radio)
 {
         struct em28xx *h, *dev = NULL;
-        int minor = iminor(inode);
 
         *fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         *has_radio = 0;
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
index 65dcb91bdcc2..24e39c56811e 100644
--- a/drivers/media/video/em28xx/em28xx-reg.h
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -160,7 +160,7 @@
 
 /* FIXME: Need to be populated with the other chip ID's */
 enum em28xx_chip_id {
-        CHIP_ID_EM2820 = 18,
+        CHIP_ID_EM2820 = 18,    /* Also used by em2710 */
         CHIP_ID_EM2840 = 20,
         CHIP_ID_EM2750 = 33,
         CHIP_ID_EM2860 = 34,
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 53527536481e..416b691c33c1 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -1154,7 +1154,7 @@ static int em28xx_reg_len(int reg)
 }
 
 static int vidioc_g_chip_ident(struct file *file, void *priv,
-               struct v4l2_chip_ident *chip)
+               struct v4l2_dbg_chip_ident *chip)
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
@@ -1162,20 +1162,20 @@ static int vidioc_g_chip_ident(struct file *file, void *priv,
         chip->ident = V4L2_IDENT_NONE;
         chip->revision = 0;
 
-        em28xx_i2c_call_clients(dev, VIDIOC_G_CHIP_IDENT, chip);
+        em28xx_i2c_call_clients(dev, VIDIOC_DBG_G_CHIP_IDENT, chip);
 
         return 0;
 }
 
 
 static int vidioc_g_register(struct file *file, void *priv,
-                             struct v4l2_register *reg)
+                             struct v4l2_dbg_register *reg)
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
         int ret;
 
-        switch (reg->match_type) {
+        switch (reg->match.type) {
         case V4L2_CHIP_MATCH_AC97:
                 mutex_lock(&dev->lock);
                 ret = em28xx_read_ac97(dev, reg->reg);
@@ -1184,6 +1184,7 @@ static int vidioc_g_register(struct file *file, void *priv,
                         return ret;
 
                 reg->val = ret;
+                reg->size = 1;
                 return 0;
         case V4L2_CHIP_MATCH_I2C_DRIVER:
                 em28xx_i2c_call_clients(dev, VIDIOC_DBG_G_REGISTER, reg);
@@ -1192,12 +1193,13 @@ static int vidioc_g_register(struct file *file, void *priv,
                 /* Not supported yet */
                 return -EINVAL;
         default:
-                if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+                if (!v4l2_chip_match_host(&reg->match))
                         return -EINVAL;
         }
 
         /* Match host */
-        if (em28xx_reg_len(reg->reg) == 1) {
+        reg->size = em28xx_reg_len(reg->reg);
+        if (reg->size == 1) {
                 mutex_lock(&dev->lock);
                 ret = em28xx_read_reg(dev, reg->reg);
                 mutex_unlock(&dev->lock);
@@ -1207,7 +1209,7 @@ static int vidioc_g_register(struct file *file, void *priv,
 
                 reg->val = ret;
         } else {
-                __le64 val = 0;
+                __le16 val = 0;
                 mutex_lock(&dev->lock);
                 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
                                                    reg->reg, (char *)&val, 2);
@@ -1215,21 +1217,21 @@ static int vidioc_g_register(struct file *file, void *priv,
                 if (ret < 0)
                         return ret;
 
-                reg->val = le64_to_cpu(val);
+                reg->val = le16_to_cpu(val);
         }
 
         return 0;
 }
 
 static int vidioc_s_register(struct file *file, void *priv,
-                             struct v4l2_register *reg)
+                             struct v4l2_dbg_register *reg)
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
-        __le64 buf;
+        __le16 buf;
         int    rc;
 
-        switch (reg->match_type) {
+        switch (reg->match.type) {
         case V4L2_CHIP_MATCH_AC97:
                 mutex_lock(&dev->lock);
                 rc = em28xx_write_ac97(dev, reg->reg, reg->val);
@@ -1243,12 +1245,12 @@ static int vidioc_s_register(struct file *file, void *priv,
                 /* Not supported yet */
                 return -EINVAL;
         default:
-                if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+                if (!v4l2_chip_match_host(&reg->match))
                         return -EINVAL;
         }
 
         /* Match host */
-        buf = cpu_to_le64(reg->val);
+        buf = cpu_to_le16(reg->val);
 
         mutex_lock(&dev->lock);
         rc = em28xx_write_regs(dev, reg->reg, (char *)&buf,
@@ -1582,15 +1584,15 @@ static int radio_queryctrl(struct file *file, void *priv,
  * em28xx_v4l2_open()
  * inits the device and starts isoc transfer
  */
-static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
+static int em28xx_v4l2_open(struct file *filp)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(filp)->minor;
         int errCode = 0, radio;
         struct em28xx *dev;
         enum v4l2_buf_type fh_type;
         struct em28xx_fh *fh;
 
-        dev = em28xx_get_device(inode, &fh_type, &radio);
+        dev = em28xx_get_device(minor, &fh_type, &radio);
 
         if (NULL == dev)
                 return -ENODEV;
@@ -1686,7 +1688,7 @@ void em28xx_release_analog_resources(struct em28xx *dev)
  * stops streaming and deallocates all resources allocated by the v4l2
  * calls and ioctls
  */
-static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
+static int em28xx_v4l2_close(struct file *filp)
 {
         struct em28xx_fh *fh  = filp->private_data;
         struct em28xx    *dev = fh->dev;
@@ -1826,7 +1828,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
         return rc;
 }
 
-static const struct file_operations em28xx_v4l_fops = {
+static const struct v4l2_file_operations em28xx_v4l_fops = {
         .owner         = THIS_MODULE,
         .open          = em28xx_v4l2_open,
         .release       = em28xx_v4l2_close,
@@ -1834,8 +1836,6 @@ static const struct file_operations em28xx_v4l_fops = {
         .poll          = em28xx_v4l2_poll,
         .mmap          = em28xx_v4l2_mmap,
         .ioctl         = video_ioctl2,
-        .llseek        = no_llseek,
-        .compat_ioctl  = v4l_compat_ioctl32,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
@@ -1890,13 +1890,11 @@ static const struct video_device em28xx_video_template = {
         .current_norm               = V4L2_STD_PAL,
 };
 
-static const struct file_operations radio_fops = {
+static const struct v4l2_file_operations radio_fops = {
         .owner         = THIS_MODULE,
         .open          = em28xx_v4l2_open,
         .release       = em28xx_v4l2_close,
         .ioctl         = video_ioctl2,
-        .compat_ioctl  = v4l_compat_ioctl32,
-        .llseek        = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index b5eddc26388e..6c6b94aa05b2 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -473,7 +473,7 @@ struct em28xx {
         unsigned long i2c_hash; /* i2c devicelist hash -
                                    for boards with generic ID */
 
-        struct em28xx_audio *adev;
+        struct em28xx_audio adev;
 
         /* states */
         enum em28xx_dev_state state;
@@ -583,7 +583,7 @@ int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio);
 void em28xx_wake_i2c(struct em28xx *dev);
 void em28xx_remove_from_devlist(struct em28xx *dev);
 void em28xx_add_into_devlist(struct em28xx *dev);
-struct em28xx *em28xx_get_device(struct inode *inode,
+struct em28xx *em28xx_get_device(int minor,
                                  enum v4l2_buf_type *fh_type,
                                  int *has_radio);
 int em28xx_register_extension(struct em28xx_ops *dev);
diff --git a/drivers/media/video/et61x251/et61x251_core.c b/drivers/media/video/et61x251/et61x251_core.c
index 83c07112c59d..d1c1e457f0b9 100644
--- a/drivers/media/video/et61x251/et61x251_core.c
+++ b/drivers/media/video/et61x251/et61x251_core.c
@@ -1206,7 +1206,7 @@ static void et61x251_release_resources(struct kref *kref)
 }
 
 
-static int et61x251_open(struct inode* inode, struct file* filp)
+static int et61x251_open(struct file *filp)
 {
         struct et61x251_device* cam;
         int err = 0;
@@ -1291,7 +1291,7 @@ out:
 }
 
 
-static int et61x251_release(struct inode* inode, struct file* filp)
+static int et61x251_release(struct file *filp)
 {
         struct et61x251_device* cam;
 
@@ -2392,8 +2392,8 @@ et61x251_vidioc_s_parm(struct et61x251_device* cam, void __user * arg)
 }
 
 
-static int et61x251_ioctl_v4l2(struct inode* inode, struct file* filp,
-                               unsigned int cmd, void __user * arg)
+static long et61x251_ioctl_v4l2(struct file *filp,
+                               unsigned int cmd, void __user *arg)
 {
         struct et61x251_device *cam = video_drvdata(filp);
 
@@ -2487,11 +2487,11 @@ static int et61x251_ioctl_v4l2(struct inode* inode, struct file* filp,
 }
 
 
-static int et61x251_ioctl(struct inode* inode, struct file* filp,
+static long et61x251_ioctl(struct file *filp,
                          unsigned int cmd, unsigned long arg)
 {
         struct et61x251_device *cam = video_drvdata(filp);
-        int err = 0;
+        long err = 0;
 
         if (mutex_lock_interruptible(&cam->fileop_mutex))
                 return -ERESTARTSYS;
@@ -2511,7 +2511,7 @@ static int et61x251_ioctl(struct inode* inode, struct file* filp,
 
         V4LDBG(3, "et61x251", cmd);
 
-        err = et61x251_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
+        err = et61x251_ioctl_v4l2(filp, cmd, (void __user *)arg);
 
         mutex_unlock(&cam->fileop_mutex);
 
@@ -2519,18 +2519,14 @@ static int et61x251_ioctl(struct inode* inode, struct file* filp,
 }
 
 
-static const struct file_operations et61x251_fops = {
+static const struct v4l2_file_operations et61x251_fops = {
         .owner = THIS_MODULE,
         .open =    et61x251_open,
         .release = et61x251_release,
         .ioctl =   et61x251_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
         .read =    et61x251_read,
         .poll =    et61x251_poll,
         .mmap =    et61x251_mmap,
-        .llseek =  no_llseek,
 };
 
 /*****************************************************************************/
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index 8b9f3bde5740..5e36b9a4ae3e 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -875,7 +875,7 @@ static void gspca_release(struct video_device *vfd)
         kfree(gspca_dev);
 }
 
-static int dev_open(struct inode *inode, struct file *file)
+static int dev_open(struct file *file)
 {
         struct gspca_dev *gspca_dev;
         int ret;
@@ -922,7 +922,7 @@ out:
         return ret;
 }
 
-static int dev_close(struct inode *inode, struct file *file)
+static int dev_close(struct file *file)
 {
         struct gspca_dev *gspca_dev = file->private_data;
 
@@ -1802,17 +1802,13 @@ out:
         return ret;
 }
 
-static struct file_operations dev_fops = {
+static struct v4l2_file_operations dev_fops = {
         .owner = THIS_MODULE,
         .open = dev_open,
         .release = dev_close,
         .read = dev_read,
         .mmap = dev_mmap,
-        .unlocked_ioctl = __video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek = no_llseek,
+        .unlocked_ioctl = video_ioctl2,
         .poll   = dev_poll,
 };
 
diff --git a/drivers/media/video/hexium_gemini.c b/drivers/media/video/hexium_gemini.c
index 352f84d440fb..79393d1772e4 100644
--- a/drivers/media/video/hexium_gemini.c
+++ b/drivers/media/video/hexium_gemini.c
@@ -306,7 +306,7 @@ static int hexium_detach(struct saa7146_dev *dev)
         return 0;
 }
 
-static int hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
+static long hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 {
         struct saa7146_dev *dev = fh->dev;
         struct hexium *hexium = (struct hexium *) dev->ext_priv;
diff --git a/drivers/media/video/hexium_orion.c b/drivers/media/video/hexium_orion.c
index 8d3c1482e7ea..074bec711fe0 100644
--- a/drivers/media/video/hexium_orion.c
+++ b/drivers/media/video/hexium_orion.c
@@ -370,7 +370,7 @@ static int hexium_detach(struct saa7146_dev *dev)
         return 0;
 }
 
-static int hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
+static long hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 {
         struct saa7146_dev *dev = fh->dev;
         struct hexium *hexium = (struct hexium *) dev->ext_priv;
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 08b762951759..e8e5921cdc34 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -902,18 +902,19 @@ static void ivtv_load_and_init_modules(struct ivtv *itv)
         }
 
         if (hw & IVTV_HW_SAA711X) {
-                struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
+                struct v4l2_dbg_chip_ident v;
 
                 /* determine the exact saa711x model */
                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 
+                v.match.type = V4L2_CHIP_MATCH_I2C_DRIVER;
+                strlcpy(v.match.name, "saa7115", sizeof(v.match.name));
                 ivtv_call_hw(itv, IVTV_HW_SAA711X, core, g_chip_ident, &v);
                 if (v.ident == V4L2_IDENT_SAA7114) {
                         itv->hw_flags |= IVTV_HW_SAA7114;
                         /* VBI is not yet supported by the saa7114 driver. */
                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
-                }
-                else {
+                } else {
                         itv->hw_flags |= IVTV_HW_SAA7115;
                 }
                 itv->vbi.raw_decoder_line_size = 1443;
diff --git a/drivers/media/video/ivtv/ivtv-fileops.c b/drivers/media/video/ivtv/ivtv-fileops.c
index 5eb587592e9d..d594bc29f07f 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.c
+++ b/drivers/media/video/ivtv/ivtv-fileops.c
@@ -831,7 +831,7 @@ static void ivtv_stop_decoding(struct ivtv_open_id *id, int flags, u64 pts)
         ivtv_release_stream(s);
 }
 
-int ivtv_v4l2_close(struct inode *inode, struct file *filp)
+int ivtv_v4l2_close(struct file *filp)
 {
         struct ivtv_open_id *id = filp->private_data;
         struct ivtv *itv = id->itv;
@@ -978,7 +978,7 @@ static int ivtv_serialized_open(struct ivtv_stream *s, struct file *filp)
         return 0;
 }
 
-int ivtv_v4l2_open(struct inode *inode, struct file *filp)
+int ivtv_v4l2_open(struct file *filp)
 {
         int res;
         struct ivtv *itv = NULL;
diff --git a/drivers/media/video/ivtv/ivtv-fileops.h b/drivers/media/video/ivtv/ivtv-fileops.h
index df81e790147f..049a2923965d 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.h
+++ b/drivers/media/video/ivtv/ivtv-fileops.h
@@ -22,12 +22,12 @@
 #define IVTV_FILEOPS_H
 
 /* Testing/Debugging */
-int ivtv_v4l2_open(struct inode *inode, struct file *filp);
+int ivtv_v4l2_open(struct file *filp);
 ssize_t ivtv_v4l2_read(struct file *filp, char __user *buf, size_t count,
                       loff_t * pos);
 ssize_t ivtv_v4l2_write(struct file *filp, const char __user *buf, size_t count,
                        loff_t * pos);
-int ivtv_v4l2_close(struct inode *inode, struct file *filp);
+int ivtv_v4l2_close(struct file *filp);
 unsigned int ivtv_v4l2_enc_poll(struct file *filp, poll_table * wait);
 unsigned int ivtv_v4l2_dec_poll(struct file *filp, poll_table * wait);
 int ivtv_start_capture(struct ivtv_open_id *id);
diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
index cd990a4b81a9..f6b3ef6e691b 100644
--- a/drivers/media/video/ivtv/ivtv-ioctl.c
+++ b/drivers/media/video/ivtv/ivtv-ioctl.c
@@ -674,19 +674,19 @@ static int ivtv_s_fmt_vid_out_overlay(struct file *file, void *fh, struct v4l2_f
         return ret;
 }
 
-static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_chip_ident *chip)
+static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip)
 {
         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 
         chip->ident = V4L2_IDENT_NONE;
         chip->revision = 0;
-        if (chip->match_type == V4L2_CHIP_MATCH_HOST) {
-                if (v4l2_chip_match_host(chip->match_type, chip->match_chip))
+        if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
+                if (v4l2_chip_match_host(&chip->match))
                         chip->ident = itv->has_cx23415 ? V4L2_IDENT_CX23415 : V4L2_IDENT_CX23416;
                 return 0;
         }
-        if (chip->match_type != V4L2_CHIP_MATCH_I2C_DRIVER &&
-            chip->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
+        if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
+            chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
         /* TODO: is this correct? */
         return ivtv_call_all_err(itv, core, g_chip_ident, chip);
@@ -695,7 +695,7 @@ static int ivtv_g_chip_ident(struct file *file, void *fh, struct v4l2_chip_ident
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
 {
-        struct v4l2_register *regs = arg;
+        struct v4l2_dbg_register *regs = arg;
         volatile u8 __iomem *reg_start;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -710,6 +710,7 @@ static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
         else
                 return -EINVAL;
 
+        regs->size = 4;
         if (cmd == VIDIOC_DBG_G_REGISTER)
                 regs->val = readl(regs->reg + reg_start);
         else
@@ -717,11 +718,11 @@ static int ivtv_itvc(struct ivtv *itv, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int ivtv_g_register(struct file *file, void *fh, struct v4l2_register *reg)
+static int ivtv_g_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 {
         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 
-        if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (v4l2_chip_match_host(&reg->match))
                 return ivtv_itvc(itv, VIDIOC_DBG_G_REGISTER, reg);
         /* TODO: subdev errors should not be ignored, this should become a
            subdev helper function. */
@@ -729,11 +730,11 @@ static int ivtv_g_register(struct file *file, void *fh, struct v4l2_register *re
         return 0;
 }
 
-static int ivtv_s_register(struct file *file, void *fh, struct v4l2_register *reg)
+static int ivtv_s_register(struct file *file, void *fh, struct v4l2_dbg_register *reg)
 {
         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 
-        if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (v4l2_chip_match_host(&reg->match))
                 return ivtv_itvc(itv, VIDIOC_DBG_S_REGISTER, reg);
         /* TODO: subdev errors should not be ignored, this should become a
            subdev helper function. */
@@ -1725,7 +1726,7 @@ static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int ivtv_default(struct file *file, void *fh, int cmd, void *arg)
+static long ivtv_default(struct file *file, void *fh, int cmd, void *arg)
 {
         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 
@@ -1827,7 +1828,7 @@ static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
 
         if (ivtv_debug & IVTV_DBGFLG_IOCTL)
                 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
-        ret = __video_ioctl2(filp, cmd, arg);
+        ret = video_ioctl2(filp, cmd, arg);
         vfd->debug = 0;
         return ret;
 }
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index f77d764707b2..854a950af78c 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -43,24 +43,22 @@
 #include "ivtv-cards.h"
 #include "ivtv-streams.h"
 
-static const struct file_operations ivtv_v4l2_enc_fops = {
+static const struct v4l2_file_operations ivtv_v4l2_enc_fops = {
         .owner = THIS_MODULE,
         .read = ivtv_v4l2_read,
         .write = ivtv_v4l2_write,
         .open = ivtv_v4l2_open,
         .unlocked_ioctl = ivtv_v4l2_ioctl,
-        .compat_ioctl = v4l_compat_ioctl32,
         .release = ivtv_v4l2_close,
         .poll = ivtv_v4l2_enc_poll,
 };
 
-static const struct file_operations ivtv_v4l2_dec_fops = {
+static const struct v4l2_file_operations ivtv_v4l2_dec_fops = {
         .owner = THIS_MODULE,
         .read = ivtv_v4l2_read,
         .write = ivtv_v4l2_write,
         .open = ivtv_v4l2_open,
         .unlocked_ioctl = ivtv_v4l2_ioctl,
-        .compat_ioctl = v4l_compat_ioctl32,
         .release = ivtv_v4l2_close,
         .poll = ivtv_v4l2_dec_poll,
 };
@@ -78,7 +76,7 @@ static struct {
         int num_offset;
         int dma, pio;
         enum v4l2_buf_type buf_type;
-        const struct file_operations *fops;
+        const struct v4l2_file_operations *fops;
 } ivtv_stream_info[] = {
         {       /* IVTV_ENC_STREAM_TYPE_MPG */
                 "encoder MPG",
diff --git a/drivers/media/video/m52790.c b/drivers/media/video/m52790.c
index 07be14a9fe7b..de397ef57b44 100644
--- a/drivers/media/video/m52790.c
+++ b/drivers/media/video/m52790.c
@@ -80,29 +80,28 @@ static int m52790_s_routing(struct v4l2_subdev *sd, const struct v4l2_routing *r
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int m52790_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int m52790_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct m52790_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         if (reg->reg != 0)
                 return -EINVAL;
+        reg->size = 1;
         reg->val = state->input | state->output;
         return 0;
 }
 
-static int m52790_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int m52790_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct m52790_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -115,7 +114,7 @@ static int m52790_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
 }
 #endif
 
-static int m52790_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int m52790_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index 6418f4a78f2a..b76e33d5c867 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -841,7 +841,7 @@ again:
 /* video4linux integration                                                  */
 /****************************************************************************/
 
-static int meye_open(struct inode *inode, struct file *file)
+static int meye_open(struct file *file)
 {
         int i;
 
@@ -863,7 +863,7 @@ static int meye_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int meye_release(struct inode *inode, struct file *file)
+static int meye_release(struct file *file)
 {
         mchip_hic_stop();
         mchip_dma_free();
@@ -1577,7 +1577,7 @@ static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
         return 0;
 }
 
-static int vidioc_default(struct file *file, void *fh, int cmd, void *arg)
+static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
 {
         switch (cmd) {
         case MEYEIOC_G_PARAMS:
@@ -1684,17 +1684,13 @@ static int meye_mmap(struct file *file, struct vm_area_struct *vma)
         return 0;
 }
 
-static const struct file_operations meye_fops = {
+static const struct v4l2_file_operations meye_fops = {
         .owner          = THIS_MODULE,
         .open           = meye_open,
         .release        = meye_release,
         .mmap           = meye_mmap,
         .ioctl          = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .poll           = meye_poll,
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
diff --git a/drivers/media/video/msp3400-driver.c b/drivers/media/video/msp3400-driver.c
index a622dbb72ed8..4d7a91852117 100644
--- a/drivers/media/video/msp3400-driver.c
+++ b/drivers/media/video/msp3400-driver.c
@@ -483,7 +483,7 @@ static int msp_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 }
 
 #ifdef CONFIG_VIDEO_ALLOW_V4L1
-static int msp_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
+static long msp_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 {
         struct msp_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
@@ -733,7 +733,7 @@ static int msp_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
         return 0;
 }
 
-static int msp_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int msp_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct msp_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/mt9m001.c b/drivers/media/video/mt9m001.c
index 1a1a12453672..c1bf75ef2741 100644
--- a/drivers/media/video/mt9m001.c
+++ b/drivers/media/video/mt9m001.c
@@ -343,14 +343,14 @@ static int mt9m001_try_fmt(struct soc_camera_device *icd,
 }
 
 static int mt9m001_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_chip_ident *id)
+                               struct v4l2_dbg_chip_ident *id)
 {
         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
 
-        if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
+        if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match_chip != mt9m001->client->addr)
+        if (id->match.addr != mt9m001->client->addr)
                 return -ENODEV;
 
         id->ident       = mt9m001->model;
@@ -361,16 +361,17 @@ static int mt9m001_get_chip_id(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int mt9m001_get_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9m001->client->addr)
+        if (reg->match.addr != mt9m001->client->addr)
                 return -ENODEV;
 
+        reg->size = 2;
         reg->val = reg_read(icd, reg->reg);
 
         if (reg->val > 0xffff)
@@ -380,14 +381,14 @@ static int mt9m001_get_register(struct soc_camera_device *icd,
 }
 
 static int mt9m001_set_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9m001->client->addr)
+        if (reg->match.addr != mt9m001->client->addr)
                 return -ENODEV;
 
         if (reg_write(icd, reg->reg, reg->val) < 0)
diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
index c89ea41fe259..5b8e20979cce 100644
--- a/drivers/media/video/mt9m111.c
+++ b/drivers/media/video/mt9m111.c
@@ -514,14 +514,14 @@ static int mt9m111_try_fmt(struct soc_camera_device *icd,
 }
 
 static int mt9m111_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_chip_ident *id)
+                               struct v4l2_dbg_chip_ident *id)
 {
         struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
 
-        if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
+        if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match_chip != mt9m111->client->addr)
+        if (id->match.addr != mt9m111->client->addr)
                 return -ENODEV;
 
         id->ident       = mt9m111->model;
@@ -532,18 +532,19 @@ static int mt9m111_get_chip_id(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int mt9m111_get_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         int val;
 
         struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
                 return -EINVAL;
-        if (reg->match_chip != mt9m111->client->addr)
+        if (reg->match.addr != mt9m111->client->addr)
                 return -ENODEV;
 
         val = mt9m111_reg_read(icd, reg->reg);
+        reg->size = 2;
         reg->val = (u64)val;
 
         if (reg->val > 0xffff)
@@ -553,14 +554,14 @@ static int mt9m111_get_register(struct soc_camera_device *icd,
 }
 
 static int mt9m111_set_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9m111->client->addr)
+        if (reg->match.addr != mt9m111->client->addr)
                 return -ENODEV;
 
         if (mt9m111_reg_write(icd, reg->reg, reg->val) < 0)
diff --git a/drivers/media/video/mt9t031.c b/drivers/media/video/mt9t031.c
index 1a9d53966d06..349d8e365530 100644
--- a/drivers/media/video/mt9t031.c
+++ b/drivers/media/video/mt9t031.c
@@ -326,14 +326,14 @@ static int mt9t031_try_fmt(struct soc_camera_device *icd,
 }
 
 static int mt9t031_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_chip_ident *id)
+                               struct v4l2_dbg_chip_ident *id)
 {
         struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
 
-        if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
+        if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match_chip != mt9t031->client->addr)
+        if (id->match.addr != mt9t031->client->addr)
                 return -ENODEV;
 
         id->ident       = mt9t031->model;
@@ -344,14 +344,14 @@ static int mt9t031_get_chip_id(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int mt9t031_get_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9t031->client->addr)
+        if (reg->match.addr != mt9t031->client->addr)
                 return -ENODEV;
 
         reg->val = reg_read(icd, reg->reg);
@@ -363,14 +363,14 @@ static int mt9t031_get_register(struct soc_camera_device *icd,
 }
 
 static int mt9t031_set_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9t031->client->addr)
+        if (reg->match.addr != mt9t031->client->addr)
                 return -ENODEV;
 
         if (reg_write(icd, reg->reg, reg->val) < 0)
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
index 14a5f9c21ffa..b04c8cb1644d 100644
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@ -422,14 +422,14 @@ static int mt9v022_try_fmt(struct soc_camera_device *icd,
 }
 
 static int mt9v022_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_chip_ident *id)
+                               struct v4l2_dbg_chip_ident *id)
 {
         struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
 
-        if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
+        if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match_chip != mt9v022->client->addr)
+        if (id->match.addr != mt9v022->client->addr)
                 return -ENODEV;
 
         id->ident       = mt9v022->model;
@@ -440,16 +440,17 @@ static int mt9v022_get_chip_id(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int mt9v022_get_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9v022->client->addr)
+        if (reg->match.addr != mt9v022->client->addr)
                 return -ENODEV;
 
+        reg->size = 2;
         reg->val = reg_read(icd, reg->reg);
 
         if (reg->val > 0xffff)
@@ -459,14 +460,14 @@ static int mt9v022_get_register(struct soc_camera_device *icd,
 }
 
 static int mt9v022_set_register(struct soc_camera_device *icd,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
 
-        if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
+        if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
 
-        if (reg->match_chip != mt9v022->client->addr)
+        if (reg->match.addr != mt9v022->client->addr)
                 return -ENODEV;
 
         if (reg_write(icd, reg->reg, reg->val) < 0)
diff --git a/drivers/media/video/mxb.c b/drivers/media/video/mxb.c
index 7f130284b5c7..e3cbe14c349a 100644
--- a/drivers/media/video/mxb.c
+++ b/drivers/media/video/mxb.c
@@ -489,7 +489,7 @@ static int mxb_detach(struct saa7146_dev *dev)
         return 0;
 }
 
-static int mxb_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
+static long mxb_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 {
         struct saa7146_dev *dev = fh->dev;
         struct mxb *mxb = (struct mxb *)dev->ext_priv;
diff --git a/drivers/media/video/omap24xxcam.c b/drivers/media/video/omap24xxcam.c
index 85c3c7c92af1..73eb656acfe3 100644
--- a/drivers/media/video/omap24xxcam.c
+++ b/drivers/media/video/omap24xxcam.c
@@ -1454,9 +1454,9 @@ static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
         return rval;
 }
 
-static int omap24xxcam_open(struct inode *inode, struct file *file)
+static int omap24xxcam_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct omap24xxcam_device *cam = omap24xxcam.priv;
         struct omap24xxcam_fh *fh;
         struct v4l2_format format;
@@ -1511,7 +1511,7 @@ out_try_module_get:
         return -ENODEV;
 }
 
-static int omap24xxcam_release(struct inode *inode, struct file *file)
+static int omap24xxcam_release(struct file *file)
 {
         struct omap24xxcam_fh *fh = file->private_data;
         struct omap24xxcam_device *cam = fh->cam;
@@ -1559,8 +1559,7 @@ static int omap24xxcam_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static struct file_operations omap24xxcam_fops = {
-        .llseek  = no_llseek,
+static struct v4l2_file_operations omap24xxcam_fops = {
         .ioctl   = video_ioctl2,
         .poll    = omap24xxcam_poll,
         .mmap    = omap24xxcam_mmap,
diff --git a/drivers/media/video/ov511.c b/drivers/media/video/ov511.c
index 6ee9b69cc4a9..9af5532db142 100644
--- a/drivers/media/video/ov511.c
+++ b/drivers/media/video/ov511.c
@@ -3915,7 +3915,7 @@ ov51x_dealloc(struct usb_ov511 *ov)
  ***************************************************************************/
 
 static int
-ov51x_v4l1_open(struct inode *inode, struct file *file)
+ov51x_v4l1_open(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
         struct usb_ov511 *ov = video_get_drvdata(vdev);
@@ -3972,7 +3972,7 @@ out:
 }
 
 static int
-ov51x_v4l1_close(struct inode *inode, struct file *file)
+ov51x_v4l1_close(struct file *file)
 {
         struct video_device *vdev = file->private_data;
         struct usb_ov511 *ov = video_get_drvdata(vdev);
@@ -4010,7 +4010,7 @@ ov51x_v4l1_close(struct inode *inode, struct file *file)
 }
 
 /* Do not call this function directly! */
-static int
+static long
 ov51x_v4l1_ioctl_internal(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = file->private_data;
@@ -4449,8 +4449,8 @@ redo:
         return 0;
 }
 
-static int
-ov51x_v4l1_ioctl(struct inode *inode, struct file *file,
+static long
+ov51x_v4l1_ioctl(struct file *file,
                  unsigned int cmd, unsigned long arg)
 {
         struct video_device *vdev = file->private_data;
@@ -4661,17 +4661,13 @@ ov51x_v4l1_mmap(struct file *file, struct vm_area_struct *vma)
         return 0;
 }
 
-static const struct file_operations ov511_fops = {
+static const struct v4l2_file_operations ov511_fops = {
         .owner =        THIS_MODULE,
         .open =         ov51x_v4l1_open,
         .release =      ov51x_v4l1_close,
         .read =         ov51x_v4l1_read,
         .mmap =         ov51x_v4l1_mmap,
         .ioctl =        ov51x_v4l1_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek =       no_llseek,
 };
 
 static struct video_device vdev_template = {
diff --git a/drivers/media/video/ov7670.c b/drivers/media/video/ov7670.c
index ea032f5f2f41..ca26b0c50cf2 100644
--- a/drivers/media/video/ov7670.c
+++ b/drivers/media/video/ov7670.c
@@ -1310,7 +1310,7 @@ static int ov7670_command(struct i2c_client *client, unsigned int cmd,
                 void *arg)
 {
         switch (cmd) {
-        case VIDIOC_G_CHIP_IDENT:
+        case VIDIOC_DBG_G_CHIP_IDENT:
                 return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_OV7670, 0);
 
         case VIDIOC_INT_RESET:
diff --git a/drivers/media/video/ov772x.c b/drivers/media/video/ov772x.c
index 54b736fcc07a..3c9e0ba974e9 100644
--- a/drivers/media/video/ov772x.c
+++ b/drivers/media/video/ov772x.c
@@ -724,7 +724,7 @@ static unsigned long ov772x_query_bus_param(struct soc_camera_device *icd)
 }
 
 static int ov772x_get_chip_id(struct soc_camera_device *icd,
-                              struct v4l2_chip_ident   *id)
+                              struct v4l2_dbg_chip_ident   *id)
 {
         struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
 
@@ -736,11 +736,12 @@ static int ov772x_get_chip_id(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int ov772x_get_register(struct soc_camera_device *icd,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
         struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
         int                 ret;
 
+        reg->size = 1;
         if (reg->reg > 0xff)
                 return -EINVAL;
 
@@ -754,7 +755,7 @@ static int ov772x_get_register(struct soc_camera_device *icd,
 }
 
 static int ov772x_set_register(struct soc_camera_device *icd,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
         struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
 
diff --git a/drivers/media/video/pms.c b/drivers/media/video/pms.c
index 45730fac1570..a1ad38fc49c1 100644
--- a/drivers/media/video/pms.c
+++ b/drivers/media/video/pms.c
@@ -680,7 +680,7 @@ static int pms_capture(struct pms_device *dev, char __user *buf, int rgb555, int
  *      Video4linux interfacing
  */
 
-static int pms_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long pms_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *dev = video_devdata(file);
         struct pms_device *pd=(struct pms_device *)dev;
@@ -862,7 +862,7 @@ static int pms_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int pms_ioctl(struct inode *inode, struct file *file,
+static long pms_ioctl(struct file *file,
                      unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, pms_do_ioctl);
@@ -881,7 +881,7 @@ static ssize_t pms_read(struct file *file, char __user *buf,
         return len;
 }
 
-static int pms_exclusive_open(struct inode *inode, struct file *file)
+static int pms_exclusive_open(struct file *file)
 {
         struct video_device *v = video_devdata(file);
         struct pms_device *pd = (struct pms_device *)v;
@@ -889,7 +889,7 @@ static int pms_exclusive_open(struct inode *inode, struct file *file)
         return test_and_set_bit(0, &pd->in_use) ? -EBUSY : 0;
 }
 
-static int pms_exclusive_release(struct inode *inode, struct file *file)
+static int pms_exclusive_release(struct file *file)
 {
         struct video_device *v = video_devdata(file);
         struct pms_device *pd = (struct pms_device *)v;
@@ -898,16 +898,12 @@ static int pms_exclusive_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations pms_fops = {
+static const struct v4l2_file_operations pms_fops = {
         .owner          = THIS_MODULE,
         .open           = pms_exclusive_open,
         .release        = pms_exclusive_release,
         .ioctl          = pms_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .read           = pms_read,
-        .llseek         = no_llseek,
 };
 
 static struct video_device pms_template=
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index 4358079f1966..8fb92ac78c7b 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -4732,26 +4732,25 @@ static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw)
 
 
 int pvr2_hdw_register_access(struct pvr2_hdw *hdw,
-                             u32 match_type, u32 match_chip, u64 reg_id,
-                             int setFl,u64 *val_ptr)
+                             struct v4l2_dbg_match *match, u64 reg_id,
+                             int setFl, u64 *val_ptr)
 {
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         struct pvr2_i2c_client *cp;
-        struct v4l2_register req;
+        struct v4l2_dbg_register req;
         int stat = 0;
         int okFl = 0;
 
         if (!capable(CAP_SYS_ADMIN)) return -EPERM;
 
-        req.match_type = match_type;
-        req.match_chip = match_chip;
+        req.match = *match;
         req.reg = reg_id;
         if (setFl) req.val = *val_ptr;
         mutex_lock(&hdw->i2c_list_lock); do {
                 list_for_each_entry(cp, &hdw->i2c_clients, list) {
                         if (!v4l2_chip_match_i2c_client(
                                     cp->client,
-                                    req.match_type, req.match_chip)) {
+                                    &req.match)) {
                                 continue;
                         }
                         stat = pvr2_i2c_client_cmd(
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.h b/drivers/media/video/pvrusb2/pvrusb2-hdw.h
index 49482d1f2b28..1b4fec337c6b 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.h
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.h
@@ -242,8 +242,8 @@ void pvr2_hdw_v4l_store_minor_number(struct pvr2_hdw *,
    setFl   - true to set the register, false to read it
    val_ptr - storage location for source / result. */
 int pvr2_hdw_register_access(struct pvr2_hdw *,
-                             u32 match_type, u32 match_chip,u64 reg_id,
-                             int setFl,u64 *val_ptr);
+                             struct v4l2_dbg_match *match, u64 reg_id,
+                             int setFl, u64 *val_ptr);
 
 /* The following entry points are all lower level things you normally don't
    want to worry about. */
diff --git a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
index 52af1c435965..878fd52a73b3 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
@@ -168,13 +168,13 @@ static const char *get_v4l_name(int v4l_type)
  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
  *
  */
-static int pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct pvr2_v4l2_fh *fh = file->private_data;
         struct pvr2_v4l2 *vp = fh->vhead;
         struct pvr2_v4l2_dev *dev_info = fh->dev_info;
         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
-        int ret = -EINVAL;
+        long ret = -EINVAL;
 
         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
@@ -851,11 +851,11 @@ static int pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         case VIDIOC_DBG_G_REGISTER:
         {
                 u64 val;
-                struct v4l2_register *req = (struct v4l2_register *)arg;
+                struct v4l2_dbg_register *req = (struct v4l2_dbg_register *)arg;
                 if (cmd == VIDIOC_DBG_S_REGISTER) val = req->val;
                 ret = pvr2_hdw_register_access(
-                        hdw,req->match_type,req->match_chip,req->reg,
-                        cmd == VIDIOC_DBG_S_REGISTER,&val);
+                        hdw, &req->match, req->reg,
+                        cmd == VIDIOC_DBG_S_REGISTER, &val);
                 if (cmd == VIDIOC_DBG_G_REGISTER) req->val = val;
                 break;
         }
@@ -871,20 +871,20 @@ static int pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         if (ret < 0) {
                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
-                                   "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
+                                   "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
                 } else {
                         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
                                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
-                                           "pvr2_v4l2_do_ioctl failure, ret=%d"
-                                           " command was:",ret);
+                                           "pvr2_v4l2_do_ioctl failure, ret=%ld"
+                                           " command was:", ret);
                                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
                                                 cmd);
                         }
                 }
         } else {
                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
-                           "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
-                           ret,ret);
+                           "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
+                           ret, ret);
         }
         return ret;
 }
@@ -948,7 +948,7 @@ static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 }
 
 
-static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
+static long pvr2_v4l2_ioctl(struct file *file,
                            unsigned int cmd, unsigned long arg)
 {
 
@@ -960,7 +960,7 @@ static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
 }
 
 
-static int pvr2_v4l2_release(struct inode *inode, struct file *file)
+static int pvr2_v4l2_release(struct file *file)
 {
         struct pvr2_v4l2_fh *fhp = file->private_data;
         struct pvr2_v4l2 *vp = fhp->vhead;
@@ -1008,7 +1008,7 @@ static int pvr2_v4l2_release(struct inode *inode, struct file *file)
 }
 
 
-static int pvr2_v4l2_open(struct inode *inode, struct file *file)
+static int pvr2_v4l2_open(struct file *file)
 {
         struct pvr2_v4l2_dev *dip; /* Our own context pointer */
         struct pvr2_v4l2_fh *fhp;
@@ -1235,13 +1235,12 @@ static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
 }
 
 
-static const struct file_operations vdev_fops = {
+static const struct v4l2_file_operations vdev_fops = {
         .owner      = THIS_MODULE,
         .open       = pvr2_v4l2_open,
         .release    = pvr2_v4l2_release,
         .read       = pvr2_v4l2_read,
         .ioctl      = pvr2_v4l2_ioctl,
-        .llseek     = no_llseek,
         .poll       = pvr2_v4l2_poll,
 };
 
diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index c66530210192..f9fbe02e0f69 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -1266,9 +1266,9 @@ int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
 /* copy local variable to arg */
 #define ARG_OUT(ARG_name) /* nothing */
 
-int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
+long pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 {
-        int ret = 0;
+        long ret = 0;
 
         switch(cmd) {
         case VIDIOCPWCRUSER:
diff --git a/drivers/media/video/pwc/pwc-if.c b/drivers/media/video/pwc/pwc-if.c
index 1ce9da167b7e..39fbc970f43d 100644
--- a/drivers/media/video/pwc/pwc-if.c
+++ b/drivers/media/video/pwc/pwc-if.c
@@ -142,16 +142,16 @@ static struct {
 
 /***/
 
-static int pwc_video_open(struct inode *inode, struct file *file);
-static int pwc_video_close(struct inode *inode, struct file *file);
+static int pwc_video_open(struct file *file);
+static int pwc_video_close(struct file *file);
 static ssize_t pwc_video_read(struct file *file, char __user *buf,
                           size_t count, loff_t *ppos);
 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
-static int  pwc_video_ioctl(struct inode *inode, struct file *file,
+static long  pwc_video_ioctl(struct file *file,
                             unsigned int ioctlnr, unsigned long arg);
 static int  pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
 
-static const struct file_operations pwc_fops = {
+static const struct v4l2_file_operations pwc_fops = {
         .owner =        THIS_MODULE,
         .open =         pwc_video_open,
         .release =      pwc_video_close,
@@ -159,10 +159,6 @@ static const struct file_operations pwc_fops = {
         .poll =         pwc_video_poll,
         .mmap =         pwc_video_mmap,
         .ioctl =        pwc_video_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek =       no_llseek,
 };
 static struct video_device pwc_template = {
         .name =         "Philips Webcam",       /* Filled in later */
@@ -1104,7 +1100,7 @@ static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
 /***************************************************************************/
 /* Video4Linux functions */
 
-static int pwc_video_open(struct inode *inode, struct file *file)
+static int pwc_video_open(struct file *file)
 {
         int i, ret;
         struct video_device *vdev = video_devdata(file);
@@ -1224,7 +1220,7 @@ static void pwc_cleanup(struct pwc_device *pdev)
 }
 
 /* Note that all cleanup is done in the reverse order as in _open */
-static int pwc_video_close(struct inode *inode, struct file *file)
+static int pwc_video_close(struct file *file)
 {
         struct video_device *vdev = file->private_data;
         struct pwc_device *pdev;
@@ -1399,12 +1395,12 @@ static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
         return 0;
 }
 
-static int pwc_video_ioctl(struct inode *inode, struct file *file,
+static long pwc_video_ioctl(struct file *file,
                            unsigned int cmd, unsigned long arg)
 {
         struct video_device *vdev = file->private_data;
         struct pwc_device *pdev;
-        int r = -ENODEV;
+        long r = -ENODEV;
 
         if (!vdev)
                 goto out;
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index d7c147328e35..bc0a464295c5 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -337,7 +337,7 @@ static int pwc_vidioc_set_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 
 }
 
-int pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = video_devdata(file);
         struct pwc_device *pdev;
diff --git a/drivers/media/video/pwc/pwc.h b/drivers/media/video/pwc/pwc.h
index c046a2535668..01411fb2337a 100644
--- a/drivers/media/video/pwc/pwc.h
+++ b/drivers/media/video/pwc/pwc.h
@@ -337,10 +337,10 @@ extern int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise);
 extern int pwc_camera_power(struct pwc_device *pdev, int power);
 
 /* Private ioctl()s; see pwc-ioctl.h */
-extern int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg);
+extern long pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg);
 
 /** Functions in pwc-v4l.c */
-extern int pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
+extern long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
 
 /** pwc-uncompress.c */
 /* Expand frame to image, possibly including decompression. Uses read_frame and fill_image */
diff --git a/drivers/media/video/s2255drv.c b/drivers/media/video/s2255drv.c
index 3c3f8cf73108..13f85ad363cd 100644
--- a/drivers/media/video/s2255drv.c
+++ b/drivers/media/video/s2255drv.c
@@ -1502,9 +1502,9 @@ static int vidioc_s_jpegcomp(struct file *file, void *priv,
         dprintk(2, "setting jpeg quality %d\n", jc->quality);
         return 0;
 }
-static int s2255_open(struct inode *inode, struct file *file)
+static int s2255_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct s2255_dev *h, *dev = NULL;
         struct s2255_fh *fh;
         struct list_head *list;
@@ -1711,11 +1711,11 @@ static void s2255_destroy(struct kref *kref)
         mutex_unlock(&dev->open_lock);
 }
 
-static int s2255_close(struct inode *inode, struct file *file)
+static int s2255_close(struct file *file)
 {
         struct s2255_fh *fh = file->private_data;
         struct s2255_dev *dev = fh->dev;
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         if (!dev)
                 return -ENODEV;
 
@@ -1759,15 +1759,13 @@ static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
         return ret;
 }
 
-static const struct file_operations s2255_fops_v4l = {
+static const struct v4l2_file_operations s2255_fops_v4l = {
         .owner = THIS_MODULE,
         .open = s2255_open,
         .release = s2255_close,
         .poll = s2255_poll,
         .ioctl = video_ioctl2,  /* V4L2 ioctl handler */
-        .compat_ioctl = v4l_compat_ioctl32,
         .mmap = s2255_mmap_v4l,
-        .llseek = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
diff --git a/drivers/media/video/saa5246a.c b/drivers/media/video/saa5246a.c
index f159441e9375..e637e440b6d5 100644
--- a/drivers/media/video/saa5246a.c
+++ b/drivers/media/video/saa5246a.c
@@ -804,7 +804,7 @@ static inline int saa5246a_stop_dau(struct saa5246a_device *t,
  *
  *  Returns 0 if successful
  */
-static int do_saa5246a_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long do_saa5246a_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct saa5246a_device *t = video_drvdata(file);
 
@@ -944,11 +944,11 @@ static inline unsigned int vtx_fix_command(unsigned int cmd)
 /*
  *      Handle the locking
  */
-static int saa5246a_ioctl(struct inode *inode, struct file *file,
+static long saa5246a_ioctl(struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
         struct saa5246a_device *t = video_drvdata(file);
-        int err;
+        long err;
 
         cmd = vtx_fix_command(cmd);
         mutex_lock(&t->lock);
@@ -957,7 +957,7 @@ static int saa5246a_ioctl(struct inode *inode, struct file *file,
         return err;
 }
 
-static int saa5246a_open(struct inode *inode, struct file *file)
+static int saa5246a_open(struct file *file)
 {
         struct saa5246a_device *t = video_drvdata(file);
 
@@ -999,7 +999,7 @@ static int saa5246a_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int saa5246a_release(struct inode *inode, struct file *file)
+static int saa5246a_release(struct file *file)
 {
         struct saa5246a_device *t = video_drvdata(file);
 
@@ -1018,12 +1018,11 @@ static int saa5246a_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations saa_fops = {
+static const struct v4l2_file_operations saa_fops = {
         .owner   = THIS_MODULE,
         .open    = saa5246a_open,
         .release = saa5246a_release,
         .ioctl   = saa5246a_ioctl,
-        .llseek  = no_llseek,
 };
 
 static struct video_device saa_template =
diff --git a/drivers/media/video/saa5249.c b/drivers/media/video/saa5249.c
index 6ef3affb97f1..e29765192469 100644
--- a/drivers/media/video/saa5249.c
+++ b/drivers/media/video/saa5249.c
@@ -190,7 +190,7 @@ static int i2c_getdata(struct saa5249_device *t, int count, u8 *buf)
  *      Standard character-device-driver functions
  */
 
-static int do_saa5249_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long do_saa5249_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         static int virtual_mode = false;
         struct saa5249_device *t = video_drvdata(file);
@@ -479,11 +479,11 @@ static inline unsigned int vtx_fix_command(unsigned int cmd)
  *      Handle the locking
  */
 
-static int saa5249_ioctl(struct inode *inode, struct file *file,
+static long saa5249_ioctl(struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
         struct saa5249_device *t = video_drvdata(file);
-        int err;
+        long err;
 
         cmd = vtx_fix_command(cmd);
         mutex_lock(&t->lock);
@@ -492,7 +492,7 @@ static int saa5249_ioctl(struct inode *inode, struct file *file,
         return err;
 }
 
-static int saa5249_open(struct inode *inode, struct file *file)
+static int saa5249_open(struct file *file)
 {
         struct saa5249_device *t = video_drvdata(file);
         int pgbuf;
@@ -529,7 +529,7 @@ static int saa5249_open(struct inode *inode, struct file *file)
 
 
 
-static int saa5249_release(struct inode *inode, struct file *file)
+static int saa5249_release(struct file *file)
 {
         struct saa5249_device *t = video_drvdata(file);
 
@@ -539,15 +539,11 @@ static int saa5249_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations saa_fops = {
+static const struct v4l2_file_operations saa_fops = {
         .owner          = THIS_MODULE,
         .open           = saa5249_open,
         .release        = saa5249_release,
         .ioctl          = saa5249_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static struct video_device saa_template =
diff --git a/drivers/media/video/saa7115.c b/drivers/media/video/saa7115.c
index 22708ecdf1bb..46c796c3fec8 100644
--- a/drivers/media/video/saa7115.c
+++ b/drivers/media/video/saa7115.c
@@ -1371,25 +1371,24 @@ static int saa711x_g_vbi_data(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_dat
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int saa711x_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa711x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = saa711x_read(sd, reg->reg & 0xff);
+        reg->size = 1;
         return 0;
 }
 
-static int saa711x_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa711x_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -1398,7 +1397,7 @@ static int saa711x_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
 }
 #endif
 
-static int saa711x_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int saa711x_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct saa711x_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/saa7127.c b/drivers/media/video/saa7127.c
index bfc85654795e..d6848f7a503b 100644
--- a/drivers/media/video/saa7127.c
+++ b/drivers/media/video/saa7127.c
@@ -623,25 +623,24 @@ static int saa7127_s_vbi_data(struct v4l2_subdev *sd, const struct v4l2_sliced_v
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int saa7127_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa7127_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = saa7127_read(sd, reg->reg & 0xff);
+        reg->size = 1;
         return 0;
 }
 
-static int saa7127_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa7127_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -650,7 +649,7 @@ static int saa7127_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
 }
 #endif
 
-static int saa7127_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int saa7127_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct saa7127_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/saa7134/saa6752hs.c b/drivers/media/video/saa7134/saa6752hs.c
index 1fb6eccdade3..1fee6e84a512 100644
--- a/drivers/media/video/saa7134/saa6752hs.c
+++ b/drivers/media/video/saa7134/saa6752hs.c
@@ -838,7 +838,7 @@ saa6752hs_command(struct i2c_client *client, unsigned int cmd, void *arg)
                 h->standard = *((v4l2_std_id *) arg);
                 break;
 
-        case VIDIOC_G_CHIP_IDENT:
+        case VIDIOC_DBG_G_CHIP_IDENT:
                 return v4l2_chip_ident_i2c_client(client,
                                 arg, h->chip, h->revision);
 
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index a2e3f6729c5b..e2febcd6e529 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -4462,6 +4462,7 @@ struct saa7134_board saa7134_boards[] = {
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
                 .tda9887_conf   = TDA9887_PRESENT,
+                .mpeg           = SAA7134_MPEG_DVB,
                 .inputs         = {{
                         .name = name_tv,
                         .vmux = 3,
@@ -4480,8 +4481,6 @@ struct saa7134_board saa7134_boards[] = {
                         .name = name_radio,
                         .amux = LINE2,
                 },
-                /* no DVB support for now */
-                /* .mpeg           = SAA7134_MPEG_DVB, */
         },
         [SAA7134_BOARD_ASUSTeK_TIGER_3IN1] = {
                 .name           = "Asus Tiger 3in1",
@@ -4643,6 +4642,38 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = 2,
                 },
         },
+        [SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS] = {
+                .name           = "Avermedia AVerTV GO 007 FM Plus",
+                .audio_clock    = 0x00187de7,
+                .tuner_type     = TUNER_PHILIPS_TDA8290,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .gpiomask       = 0x00300003,
+                /* .gpiomask       = 0x8c240003, */
+                .inputs         = { {
+                        .name = name_tv,
+                        .vmux = 1,
+                        .amux = TV,
+                        .tv   = 1,
+                        .gpio = 0x01,
+                }, {
+                        .name = name_svideo,
+                        .vmux = 6,
+                        .amux = LINE1,
+                        .gpio = 0x02,
+                } },
+                .radio = {
+                        .name = name_radio,
+                        .amux = TV,
+                        .gpio = 0x00300001,
+                },
+                .mute = {
+                        .name = name_mute,
+                        .amux = TV,
+                        .gpio = 0x01,
+                },
+        },
 };
 
 const unsigned int saa7134_bcount = ARRAY_SIZE(saa7134_boards);
@@ -5702,6 +5733,13 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .subdevice    = 0x7128,
                 .driver_data  = SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG,
         }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
+                .subvendor    = 0x1461, /* Avermedia Technologies Inc */
+                .subdevice    = 0xf31d,
+                .driver_data  = SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS,
+
+        }, {
                 /* --- boards without eeprom + subsystem ID --- */
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
@@ -5930,6 +5968,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
         case SAA7134_BOARD_REAL_ANGEL_220:
         case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
+        case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
                 dev->has_remote = SAA7134_REMOTE_GPIO;
                 break;
         case SAA7134_BOARD_FLYDVBS_LR300:
@@ -6025,6 +6064,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_BEHOLD_M6:
         case SAA7134_BOARD_BEHOLD_M63:
         case SAA7134_BOARD_BEHOLD_M6_EXTRA:
+        case SAA7134_BOARD_BEHOLD_H6:
                 dev->has_remote = SAA7134_REMOTE_I2C;
                 break;
         case SAA7134_BOARD_AVERMEDIA_A169_B:
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index d9a5652595b5..0776ecf56d27 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -49,6 +49,8 @@
 #include "lnbp21.h"
 #include "tuner-simple.h"
 
+#include "zl10353.h"
+
 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
 MODULE_LICENSE("GPL");
 
@@ -854,6 +856,12 @@ static struct tda1004x_config ads_tech_duo_config = {
         .request_firmware = philips_tda1004x_request_firmware
 };
 
+static struct zl10353_config behold_h6_config = {
+        .demod_address = 0x1e>>1,
+        .no_tuner      = 1,
+        .parallel_ts   = 1,
+};
+
 /* ==================================================================
  * tda10086 based DVB-S cards, helper functions
  */
@@ -1357,6 +1365,16 @@ static int dvb_init(struct saa7134_dev *dev)
                                          &tda827x_cfg_0) < 0)
                         goto dettach_frontend;
                 break;
+        case SAA7134_BOARD_BEHOLD_H6:
+                fe0->dvb.frontend = dvb_attach(zl10353_attach,
+                                                &behold_h6_config,
+                                                &dev->i2c_adap);
+                if (fe0->dvb.frontend) {
+                        dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
+                                   &dev->i2c_adap, 0x61,
+                                   TUNER_PHILIPS_FMD1216ME_MK3);
+                }
+                break;
         default:
                 wprintk("Huh? unknown DVB card?\n");
                 break;
diff --git a/drivers/media/video/saa7134/saa7134-empress.c b/drivers/media/video/saa7134/saa7134-empress.c
index 7f40511bcc04..c9d8beb87a60 100644
--- a/drivers/media/video/saa7134/saa7134-empress.c
+++ b/drivers/media/video/saa7134/saa7134-empress.c
@@ -83,9 +83,9 @@ static int ts_init_encoder(struct saa7134_dev* dev)
 
 /* ------------------------------------------------------------------ */
 
-static int ts_open(struct inode *inode, struct file *file)
+static int ts_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct saa7134_dev *dev;
         int err;
 
@@ -119,7 +119,7 @@ done:
         return err;
 }
 
-static int ts_release(struct inode *inode, struct file *file)
+static int ts_release(struct file *file)
 {
         struct saa7134_dev *dev = file->private_data;
 
@@ -405,7 +405,7 @@ static int empress_querymenu(struct file *file, void *priv,
 }
 
 static int empress_g_chip_ident(struct file *file, void *fh,
-               struct v4l2_chip_ident *chip)
+               struct v4l2_dbg_chip_ident *chip)
 {
         struct saa7134_dev *dev = file->private_data;
 
@@ -413,12 +413,12 @@ static int empress_g_chip_ident(struct file *file, void *fh,
         chip->revision = 0;
         if (dev->mpeg_i2c_client == NULL)
                 return -EINVAL;
-        if (chip->match_type == V4L2_CHIP_MATCH_I2C_DRIVER &&
-            chip->match_chip == I2C_DRIVERID_SAA6752HS)
-                return saa7134_i2c_call_saa6752(dev, VIDIOC_G_CHIP_IDENT, chip);
-        if (chip->match_type == V4L2_CHIP_MATCH_I2C_ADDR &&
-            chip->match_chip == dev->mpeg_i2c_client->addr)
-                return saa7134_i2c_call_saa6752(dev, VIDIOC_G_CHIP_IDENT, chip);
+        if (chip->match.type == V4L2_CHIP_MATCH_I2C_DRIVER &&
+            !strcmp(chip->match.name, "saa6752hs"))
+                return saa7134_i2c_call_saa6752(dev, VIDIOC_DBG_G_CHIP_IDENT, chip);
+        if (chip->match.type == V4L2_CHIP_MATCH_I2C_ADDR &&
+            chip->match.addr == dev->mpeg_i2c_client->addr)
+                return saa7134_i2c_call_saa6752(dev, VIDIOC_DBG_G_CHIP_IDENT, chip);
         return -EINVAL;
 }
 
@@ -437,7 +437,7 @@ static int empress_g_std(struct file *file, void *priv, v4l2_std_id *id)
         return 0;
 }
 
-static const struct file_operations ts_fops =
+static const struct v4l2_file_operations ts_fops =
 {
         .owner    = THIS_MODULE,
         .open     = ts_open,
@@ -446,7 +446,6 @@ static const struct file_operations ts_fops =
         .poll     = ts_poll,
         .mmap     = ts_mmap,
         .ioctl    = video_ioctl2,
-        .llseek   = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops ts_ioctl_ops = {
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index d2124f64e4e2..8a106d36e723 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -449,6 +449,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
         case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
         case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
         case SAA7134_BOARD_AVERMEDIA_M102:
+        case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
                 ir_codes     = ir_codes_avermedia;
                 mask_keycode = 0x0007C8;
                 mask_keydown = 0x000010;
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index 02bb6747a39c..a1f7e351f572 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -1326,9 +1326,9 @@ static int saa7134_resource(struct saa7134_fh *fh)
         return 0;
 }
 
-static int video_open(struct inode *inode, struct file *file)
+static int video_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct saa7134_dev *dev;
         struct saa7134_fh *fh;
         enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@@ -1462,7 +1462,7 @@ err:
         return POLLERR;
 }
 
-static int video_release(struct inode *inode, struct file *file)
+static int video_release(struct file *file)
 {
         struct saa7134_fh  *fh  = file->private_data;
         struct saa7134_dev *dev = fh->dev;
@@ -2247,24 +2247,25 @@ static int saa7134_g_parm(struct file *file, void *fh,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register (struct file *file, void *priv,
-                              struct v4l2_register *reg)
+                              struct v4l2_dbg_register *reg)
 {
         struct saa7134_fh *fh = priv;
         struct saa7134_dev *dev = fh->dev;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
         reg->val = saa_readb(reg->reg);
+        reg->size = 1;
         return 0;
 }
 
 static int vidioc_s_register (struct file *file, void *priv,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct saa7134_fh *fh = priv;
         struct saa7134_dev *dev = fh->dev;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
         saa_writeb(reg->reg&0xffffff, reg->val);
         return 0;
@@ -2377,7 +2378,7 @@ static int radio_queryctrl(struct file *file, void *priv,
         return 0;
 }
 
-static const struct file_operations video_fops =
+static const struct v4l2_file_operations video_fops =
 {
         .owner    = THIS_MODULE,
         .open     = video_open,
@@ -2386,8 +2387,6 @@ static const struct file_operations video_fops =
         .poll     = video_poll,
         .mmap     = video_mmap,
         .ioctl    = video_ioctl2,
-        .compat_ioctl   = v4l_compat_ioctl32,
-        .llseek   = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
@@ -2441,13 +2440,11 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
 #endif
 };
 
-static const struct file_operations radio_fops = {
+static const struct v4l2_file_operations radio_fops = {
         .owner    = THIS_MODULE,
         .open     = video_open,
         .release  = video_release,
         .ioctl    = video_ioctl2,
-        .compat_ioctl   = v4l_compat_ioctl32,
-        .llseek   = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index f6c1fcc72070..14ee265f3374 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -276,6 +276,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_ADS_INSTANT_HDTV_PCI  151
 #define SAA7134_BOARD_ASUSTeK_TIGER         152
 #define SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG 153
+#define SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS 154
 
 #define SAA7134_MAXBOARDS 32
 #define SAA7134_INPUT_MAX 8
diff --git a/drivers/media/video/saa717x.c b/drivers/media/video/saa717x.c
index 9befca65905e..454ad1dd7507 100644
--- a/drivers/media/video/saa717x.c
+++ b/drivers/media/video/saa717x.c
@@ -1171,25 +1171,26 @@ static int saa717x_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int saa717x_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa717x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client, reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = saa717x_read(sd, reg->reg);
+        reg->size = 1;
         return 0;
 }
 
-static int saa717x_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int saa717x_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
         u16 addr = reg->reg & 0xffff;
         u8 val = reg->val & 0xff;
 
-        if (!v4l2_chip_match_i2c_client(client, reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
diff --git a/drivers/media/video/se401.c b/drivers/media/video/se401.c
index d652f25eef0e..5990ab38a124 100644
--- a/drivers/media/video/se401.c
+++ b/drivers/media/video/se401.c
@@ -932,7 +932,7 @@ static void usb_se401_remove_disconnected (struct usb_se401 *se401)
  ***************************************************************************/
 
 
-static int se401_open(struct inode *inode, struct file *file)
+static int se401_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct usb_se401 *se401 = (struct usb_se401 *)dev;
@@ -954,7 +954,7 @@ static int se401_open(struct inode *inode, struct file *file)
         return err;
 }
 
-static int se401_close(struct inode *inode, struct file *file)
+static int se401_close(struct file *file)
 {
         struct video_device *dev = file->private_data;
         struct usb_se401 *se401 = (struct usb_se401 *)dev;
@@ -975,7 +975,7 @@ static int se401_close(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int se401_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long se401_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = file->private_data;
         struct usb_se401 *se401 = (struct usb_se401 *)vdev;
@@ -1138,7 +1138,7 @@ static int se401_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int se401_ioctl(struct inode *inode, struct file *file,
+static long se401_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, se401_do_ioctl);
@@ -1222,17 +1222,13 @@ static int se401_mmap(struct file *file, struct vm_area_struct *vma)
         return 0;
 }
 
-static const struct file_operations se401_fops = {
+static const struct v4l2_file_operations se401_fops = {
         .owner =        THIS_MODULE,
         .open =         se401_open,
         .release =      se401_close,
         .read =         se401_read,
         .mmap =         se401_mmap,
         .ioctl =        se401_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek =       no_llseek,
 };
 static struct video_device se401_template = {
         .name =         "se401 USB camera",
diff --git a/drivers/media/video/sn9c102/sn9c102_core.c b/drivers/media/video/sn9c102/sn9c102_core.c
index 01a8efb8deb1..23edfdc4d4bc 100644
--- a/drivers/media/video/sn9c102/sn9c102_core.c
+++ b/drivers/media/video/sn9c102/sn9c102_core.c
@@ -1746,7 +1746,7 @@ static void sn9c102_release_resources(struct kref *kref)
 }
 
 
-static int sn9c102_open(struct inode* inode, struct file* filp)
+static int sn9c102_open(struct file *filp)
 {
         struct sn9c102_device* cam;
         int err = 0;
@@ -1857,7 +1857,7 @@ out:
 }
 
 
-static int sn9c102_release(struct inode* inode, struct file* filp)
+static int sn9c102_release(struct file *filp)
 {
         struct sn9c102_device* cam;
 
@@ -3092,8 +3092,8 @@ sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
 }
 
 
-static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
-                              unsigned int cmd, void __user * arg)
+static long sn9c102_ioctl_v4l2(struct file *filp,
+                              unsigned int cmd, void __user *arg)
 {
         struct sn9c102_device *cam = video_drvdata(filp);
 
@@ -3196,7 +3196,7 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
 }
 
 
-static int sn9c102_ioctl(struct inode* inode, struct file* filp,
+static long sn9c102_ioctl(struct file *filp,
                          unsigned int cmd, unsigned long arg)
 {
         struct sn9c102_device *cam = video_drvdata(filp);
@@ -3220,7 +3220,7 @@ static int sn9c102_ioctl(struct inode* inode, struct file* filp,
 
         V4LDBG(3, "sn9c102", cmd);
 
-        err = sn9c102_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
+        err = sn9c102_ioctl_v4l2(filp, cmd, (void __user *)arg);
 
         mutex_unlock(&cam->fileop_mutex);
 
@@ -3229,18 +3229,14 @@ static int sn9c102_ioctl(struct inode* inode, struct file* filp,
 
 /*****************************************************************************/
 
-static const struct file_operations sn9c102_fops = {
+static const struct v4l2_file_operations sn9c102_fops = {
         .owner = THIS_MODULE,
         .open = sn9c102_open,
         .release = sn9c102_release,
         .ioctl = sn9c102_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
         .read = sn9c102_read,
         .poll = sn9c102_poll,
         .mmap = sn9c102_mmap,
-        .llseek = no_llseek,
 };
 
 /*****************************************************************************/
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 90077cb4fe66..fcb05f06de8f 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -256,7 +256,7 @@ static void soc_camera_free_user_formats(struct soc_camera_device *icd)
         vfree(icd->user_formats);
 }
 
-static int soc_camera_open(struct inode *inode, struct file *file)
+static int soc_camera_open(struct file *file)
 {
         struct video_device *vdev;
         struct soc_camera_device *icd;
@@ -330,7 +330,7 @@ emgd:
         return ret;
 }
 
-static int soc_camera_close(struct inode *inode, struct file *file)
+static int soc_camera_close(struct file *file)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
@@ -400,7 +400,7 @@ static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
         return ici->ops->poll(file, pt);
 }
 
-static struct file_operations soc_camera_fops = {
+static struct v4l2_file_operations soc_camera_fops = {
         .owner          = THIS_MODULE,
         .open           = soc_camera_open,
         .release        = soc_camera_close,
@@ -408,7 +408,6 @@ static struct file_operations soc_camera_fops = {
         .read           = soc_camera_read,
         .mmap           = soc_camera_mmap,
         .poll           = soc_camera_poll,
-        .llseek         = no_llseek,
 };
 
 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
@@ -700,7 +699,7 @@ static int soc_camera_s_crop(struct file *file, void *fh,
 }
 
 static int soc_camera_g_chip_ident(struct file *file, void *fh,
-                                   struct v4l2_chip_ident *id)
+                                   struct v4l2_dbg_chip_ident *id)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
@@ -713,7 +712,7 @@ static int soc_camera_g_chip_ident(struct file *file, void *fh,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int soc_camera_g_register(struct file *file, void *fh,
-                                 struct v4l2_register *reg)
+                                 struct v4l2_dbg_register *reg)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
@@ -725,7 +724,7 @@ static int soc_camera_g_register(struct file *file, void *fh,
 }
 
 static int soc_camera_s_register(struct file *file, void *fh,
-                                 struct v4l2_register *reg)
+                                 struct v4l2_dbg_register *reg)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
diff --git a/drivers/media/video/stk-webcam.c b/drivers/media/video/stk-webcam.c
index f9516d0f3c11..26378cf390fc 100644
--- a/drivers/media/video/stk-webcam.c
+++ b/drivers/media/video/stk-webcam.c
@@ -664,7 +664,7 @@ static void stk_free_buffers(struct stk_camera *dev)
 
 /* v4l file operations */
 
-static int v4l_stk_open(struct inode *inode, struct file *fp)
+static int v4l_stk_open(struct file *fp)
 {
         struct stk_camera *dev;
         struct video_device *vdev;
@@ -684,7 +684,7 @@ static int v4l_stk_open(struct inode *inode, struct file *fp)
         return 0;
 }
 
-static int v4l_stk_release(struct inode *inode, struct file *fp)
+static int v4l_stk_release(struct file *fp)
 {
         struct stk_camera *dev = fp->private_data;
 
@@ -1281,7 +1281,7 @@ static int stk_vidioc_enum_framesizes(struct file *filp,
         }
 }
 
-static struct file_operations v4l_stk_fops = {
+static struct v4l2_file_operations v4l_stk_fops = {
         .owner = THIS_MODULE,
         .open = v4l_stk_open,
         .release = v4l_stk_release,
@@ -1289,10 +1289,6 @@ static struct file_operations v4l_stk_fops = {
         .poll = v4l_stk_poll,
         .mmap = v4l_stk_mmap,
         .ioctl = video_ioctl2,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek = no_llseek
 };
 
 static const struct v4l2_ioctl_ops v4l_stk_ioctl_ops = {
diff --git a/drivers/media/video/stradis.c b/drivers/media/video/stradis.c
index bbad54f85c83..0eb313082c97 100644
--- a/drivers/media/video/stradis.c
+++ b/drivers/media/video/stradis.c
@@ -1275,7 +1275,7 @@ static void make_clip_tab(struct saa7146 *saa, struct video_clip *cr, int ncr)
                 clip_draw_rectangle(clipmap, 0, 0, 1024, -saa->win.y);
 }
 
-static int saa_ioctl(struct inode *inode, struct file *file,
+static long saa_ioctl(struct file *file,
                      unsigned int cmd, unsigned long argl)
 {
         struct saa7146 *saa = file->private_data;
@@ -1877,7 +1877,7 @@ static ssize_t saa_write(struct file *file, const char __user * buf,
         return count;
 }
 
-static int saa_open(struct inode *inode, struct file *file)
+static int saa_open(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
         struct saa7146 *saa = container_of(vdev, struct saa7146, video_dev);
@@ -1895,7 +1895,7 @@ static int saa_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int saa_release(struct inode *inode, struct file *file)
+static int saa_release(struct file *file)
 {
         struct saa7146 *saa = file->private_data;
         saa->user--;
@@ -1906,16 +1906,12 @@ static int saa_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations saa_fops = {
+static const struct v4l2_file_operations saa_fops = {
         .owner = THIS_MODULE,
         .open = saa_open,
         .release = saa_release,
         .ioctl = saa_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
         .read = saa_read,
-        .llseek = no_llseek,
         .write = saa_write,
         .mmap = saa_mmap,
 };
diff --git a/drivers/media/video/stv680.c b/drivers/media/video/stv680.c
index 42acc92c182d..75f286f7a2e9 100644
--- a/drivers/media/video/stv680.c
+++ b/drivers/media/video/stv680.c
@@ -1080,7 +1080,7 @@ static int stv680_newframe (struct usb_stv *stv680, int framenr)
  * Video4Linux
  *********************************************************************/
 
-static int stv_open (struct inode *inode, struct file *file)
+static int stv_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct usb_stv *stv680 = video_get_drvdata(dev);
@@ -1106,7 +1106,7 @@ static int stv_open (struct inode *inode, struct file *file)
         return err;
 }
 
-static int stv_close (struct inode *inode, struct file *file)
+static int stv_close(struct file *file)
 {
         struct video_device *dev = file->private_data;
         struct usb_stv *stv680 = video_get_drvdata(dev);
@@ -1132,7 +1132,7 @@ static int stv_close (struct inode *inode, struct file *file)
         return 0;
 }
 
-static int stv680_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long stv680_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = file->private_data;
         struct usb_stv *stv680 = video_get_drvdata(vdev);
@@ -1299,7 +1299,7 @@ static int stv680_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int stv680_ioctl(struct inode *inode, struct file *file,
+static long stv680_ioctl(struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, stv680_do_ioctl);
@@ -1391,17 +1391,13 @@ static ssize_t stv680_read (struct file *file, char __user *buf,
         return realcount;
 }                               /* stv680_read */
 
-static const struct file_operations stv680_fops = {
+static const struct v4l2_file_operations stv680_fops = {
         .owner =        THIS_MODULE,
         .open =         stv_open,
         .release =      stv_close,
         .read =         stv680_read,
         .mmap =         stv680_mmap,
         .ioctl =        stv680_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek =       no_llseek,
 };
 static struct video_device stv680_template = {
         .name =         "STV0680 USB camera",
diff --git a/drivers/media/video/tda9840.c b/drivers/media/video/tda9840.c
index 2644e0dc9251..6afb7059502d 100644
--- a/drivers/media/video/tda9840.c
+++ b/drivers/media/video/tda9840.c
@@ -137,7 +137,7 @@ static int tda9840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *t)
         return 0;
 }
 
-static int tda9840_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
+static long tda9840_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
 {
         int byte;
 
diff --git a/drivers/media/video/tea6415c.c b/drivers/media/video/tea6415c.c
index 31dde86f2df4..7519fd1f57ef 100644
--- a/drivers/media/video/tea6415c.c
+++ b/drivers/media/video/tea6415c.c
@@ -122,7 +122,7 @@ static int switch_matrix(struct i2c_client *client, int i, int o)
         return ret;
 }
 
-static int tea6415c_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
+static long tea6415c_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
 {
         if (cmd == TEA6415C_SWITCH) {
                 struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/tea6420.c b/drivers/media/video/tea6420.c
index 38e519f04bde..081e74fa3b2e 100644
--- a/drivers/media/video/tea6420.c
+++ b/drivers/media/video/tea6420.c
@@ -90,7 +90,7 @@ static int tea6420_switch(struct i2c_client *client, int i, int o, int g)
         return 0;
 }
 
-static int tea6420_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
+static long tea6420_ioctl(struct v4l2_subdev *sd, unsigned cmd, void *arg)
 {
         if (cmd == TEA6420_SWITCH) {
                 struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 97d7509d212f..30640fbfd0f9 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -800,7 +800,7 @@ static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
 }
 
 #ifdef CONFIG_VIDEO_ALLOW_V4L1
-static int tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
+static long tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 {
         struct tuner *t = to_tuner(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index d0c794da735b..5aeccb301cea 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -1762,7 +1762,7 @@ static int tvaudio_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *fr
         return 0;
 }
 
-static int tvaudio_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int tvaudio_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index a388a9f0cb18..2cd64ef27b95 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -963,7 +963,7 @@ static int tvp5150_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
 
 
 static int tvp5150_g_chip_ident(struct v4l2_subdev *sd,
-                                struct v4l2_chip_ident *chip)
+                                struct v4l2_dbg_chip_ident *chip)
 {
         int rev;
         struct i2c_client *client = v4l2_get_subdevdata(sd);
@@ -977,25 +977,24 @@ static int tvp5150_g_chip_ident(struct v4l2_subdev *sd,
 
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int tvp5150_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int tvp5150_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = tvp5150_read(sd, reg->reg & 0xff);
+        reg->size = 1;
         return 0;
 }
 
-static int tvp5150_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int tvp5150_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
diff --git a/drivers/media/video/tw9910.c b/drivers/media/video/tw9910.c
index d5cdc4be1a35..52c0357faa5d 100644
--- a/drivers/media/video/tw9910.c
+++ b/drivers/media/video/tw9910.c
@@ -575,7 +575,7 @@ static unsigned long tw9910_query_bus_param(struct soc_camera_device *icd)
 }
 
 static int tw9910_get_chip_id(struct soc_camera_device *icd,
-                              struct v4l2_chip_ident *id)
+                              struct v4l2_dbg_chip_ident *id)
 {
         id->ident = V4L2_IDENT_TW9910;
         id->revision = 0;
@@ -606,7 +606,7 @@ static int tw9910_enum_input(struct soc_camera_device *icd,
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int tw9910_get_register(struct soc_camera_device *icd,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
         struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
         int ret;
@@ -627,7 +627,7 @@ static int tw9910_get_register(struct soc_camera_device *icd,
 }
 
 static int tw9910_set_register(struct soc_camera_device *icd,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
         struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
 
diff --git a/drivers/media/video/upd64031a.c b/drivers/media/video/upd64031a.c
index 7a609a3a6dbe..4f16effb530f 100644
--- a/drivers/media/video/upd64031a.c
+++ b/drivers/media/video/upd64031a.c
@@ -147,7 +147,7 @@ static int upd64031a_s_routing(struct v4l2_subdev *sd, const struct v4l2_routing
         return upd64031a_s_frequency(sd, NULL);
 }
 
-static int upd64031a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int upd64031a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
@@ -162,25 +162,24 @@ static int upd64031a_log_status(struct v4l2_subdev *sd)
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int upd64031a_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int upd64031a_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = upd64031a_read(sd, reg->reg & 0xff);
+        reg->size = 1;
         return 0;
 }
 
-static int upd64031a_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int upd64031a_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
diff --git a/drivers/media/video/upd64083.c b/drivers/media/video/upd64083.c
index 58412cb9c01a..4b712f69d1b7 100644
--- a/drivers/media/video/upd64083.c
+++ b/drivers/media/video/upd64083.c
@@ -120,25 +120,24 @@ static int upd64083_s_routing(struct v4l2_subdev *sd, const struct v4l2_routing
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int upd64083_g_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int upd64083_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
         reg->val = upd64083_read(sd, reg->reg & 0xff);
+        reg->size = 1;
         return 0;
 }
 
-static int upd64083_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg)
+static int upd64083_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (!v4l2_chip_match_i2c_client(client,
-                                reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
                 return -EINVAL;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -147,7 +146,7 @@ static int upd64083_s_register(struct v4l2_subdev *sd, struct v4l2_register *reg
 }
 #endif
 
-static int upd64083_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int upd64083_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/usbvideo/usbvideo.c b/drivers/media/video/usbvideo/usbvideo.c
index 148a1f98c70f..dea8b321fb4a 100644
--- a/drivers/media/video/usbvideo/usbvideo.c
+++ b/drivers/media/video/usbvideo/usbvideo.c
@@ -41,13 +41,13 @@ module_param(video_nr, int, 0);
 static void usbvideo_Disconnect(struct usb_interface *intf);
 static void usbvideo_CameraRelease(struct uvd *uvd);
 
-static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
+static long usbvideo_v4l_ioctl(struct file *file,
                               unsigned int cmd, unsigned long arg);
 static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma);
-static int usbvideo_v4l_open(struct inode *inode, struct file *file);
+static int usbvideo_v4l_open(struct file *file);
 static ssize_t usbvideo_v4l_read(struct file *file, char __user *buf,
                              size_t count, loff_t *ppos);
-static int usbvideo_v4l_close(struct inode *inode, struct file *file);
+static int usbvideo_v4l_close(struct file *file);
 
 static int usbvideo_StartDataPump(struct uvd *uvd);
 static void usbvideo_StopDataPump(struct uvd *uvd);
@@ -942,17 +942,13 @@ static int usbvideo_find_struct(struct usbvideo *cams)
         return rv;
 }
 
-static const struct file_operations usbvideo_fops = {
+static const struct v4l2_file_operations usbvideo_fops = {
         .owner =  THIS_MODULE,
         .open =   usbvideo_v4l_open,
         .release =usbvideo_v4l_close,
         .read =   usbvideo_v4l_read,
         .mmap =   usbvideo_v4l_mmap,
         .ioctl =  usbvideo_v4l_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
-        .llseek = no_llseek,
 };
 static const struct video_device usbvideo_template = {
         .fops =       &usbvideo_fops,
@@ -1113,7 +1109,7 @@ static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma)
  * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
  * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
  */
-static int usbvideo_v4l_open(struct inode *inode, struct file *file)
+static int usbvideo_v4l_open(struct file *file)
 {
         struct video_device *dev = video_devdata(file);
         struct uvd *uvd = (struct uvd *) dev;
@@ -1233,7 +1229,7 @@ static int usbvideo_v4l_open(struct inode *inode, struct file *file)
  * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
  * 24-May-2000 Moved MOD_DEC_USE_COUNT outside of code that can sleep.
  */
-static int usbvideo_v4l_close(struct inode *inode, struct file *file)
+static int usbvideo_v4l_close(struct file *file)
 {
         struct video_device *dev = file->private_data;
         struct uvd *uvd = (struct uvd *) dev;
@@ -1281,7 +1277,7 @@ static int usbvideo_v4l_close(struct inode *inode, struct file *file)
  * History:
  * 22-Jan-2000 Corrected VIDIOCSPICT to reject unsupported settings.
  */
-static int usbvideo_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long usbvideo_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct uvd *uvd = file->private_data;
 
@@ -1501,7 +1497,7 @@ static int usbvideo_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
+static long usbvideo_v4l_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, usbvideo_v4l_do_ioctl);
diff --git a/drivers/media/video/usbvideo/vicam.c b/drivers/media/video/usbvideo/vicam.c
index 4602597ed8d1..2f1106338c08 100644
--- a/drivers/media/video/usbvideo/vicam.c
+++ b/drivers/media/video/usbvideo/vicam.c
@@ -229,12 +229,12 @@ set_camera_power(struct vicam_camera *cam, int state)
         return 0;
 }
 
-static int
-vicam_ioctl(struct inode *inode, struct file *file, unsigned int ioctlnr, unsigned long arg)
+static long
+vicam_ioctl(struct file *file, unsigned int ioctlnr, unsigned long arg)
 {
         void __user *user_arg = (void __user *)arg;
         struct vicam_camera *cam = file->private_data;
-        int retval = 0;
+        long retval = 0;
 
         if (!cam)
                 return -ENODEV;
@@ -470,7 +470,7 @@ vicam_ioctl(struct inode *inode, struct file *file, unsigned int ioctlnr, unsign
 }
 
 static int
-vicam_open(struct inode *inode, struct file *file)
+vicam_open(struct file *file)
 {
         struct vicam_camera *cam = video_drvdata(file);
 
@@ -536,7 +536,7 @@ vicam_open(struct inode *inode, struct file *file)
 }
 
 static int
-vicam_close(struct inode *inode, struct file *file)
+vicam_close(struct file *file)
 {
         struct vicam_camera *cam = file->private_data;
         int open_count;
@@ -783,17 +783,13 @@ vicam_mmap(struct file *file, struct vm_area_struct *vma)
         return 0;
 }
 
-static const struct file_operations vicam_fops = {
+static const struct v4l2_file_operations vicam_fops = {
         .owner          = THIS_MODULE,
         .open           = vicam_open,
         .release        = vicam_close,
         .read           = vicam_read,
         .mmap           = vicam_mmap,
         .ioctl          = vicam_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek         = no_llseek,
 };
 
 static struct video_device vicam_template = {
diff --git a/drivers/media/video/usbvision/usbvision-video.c b/drivers/media/video/usbvision/usbvision-video.c
index 85661b1848fe..2be5e47ed081 100644
--- a/drivers/media/video/usbvision/usbvision-video.c
+++ b/drivers/media/video/usbvision/usbvision-video.c
@@ -355,7 +355,7 @@ static void usbvision_remove_sysfs(struct video_device *vdev)
  * then allocates buffers needed for video processing.
  *
  */
-static int usbvision_v4l2_open(struct inode *inode, struct file *file)
+static int usbvision_v4l2_open(struct file *file)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
         int errCode = 0;
@@ -432,7 +432,7 @@ static int usbvision_v4l2_open(struct inode *inode, struct file *file)
  * allocated in usbvision_v4l2_open().
  *
  */
-static int usbvision_v4l2_close(struct inode *inode, struct file *file)
+static int usbvision_v4l2_close(struct file *file)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
 
@@ -477,12 +477,12 @@ static int usbvision_v4l2_close(struct inode *inode, struct file *file)
  */
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register (struct file *file, void *priv,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
         int errCode;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
         /* NT100x has a 8-bit register space */
         errCode = usbvision_read_reg(usbvision, reg->reg&0xff);
@@ -492,16 +492,17 @@ static int vidioc_g_register (struct file *file, void *priv,
                 return errCode;
         }
         reg->val = errCode;
+        reg->size = 1;
         return 0;
 }
 
 static int vidioc_s_register (struct file *file, void *priv,
-                                struct v4l2_register *reg)
+                                struct v4l2_dbg_register *reg)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
         int errCode;
 
-        if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
+        if (!v4l2_chip_match_host(&reg->match))
                 return -EINVAL;
         /* NT100x has a 8-bit register space */
         errCode = usbvision_write_reg(usbvision, reg->reg&0xff, reg->val);
@@ -1178,7 +1179,7 @@ static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
  * Here comes the stuff for radio on usbvision based devices
  *
  */
-static int usbvision_radio_open(struct inode *inode, struct file *file)
+static int usbvision_radio_open(struct file *file)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
         int errCode = 0;
@@ -1228,7 +1229,7 @@ out:
 }
 
 
-static int usbvision_radio_close(struct inode *inode, struct file *file)
+static int usbvision_radio_close(struct file *file)
 {
         struct usb_usbvision *usbvision = video_drvdata(file);
         int errCode = 0;
@@ -1266,26 +1267,26 @@ static int usbvision_radio_close(struct inode *inode, struct file *file)
  * Here comes the stuff for vbi on usbvision based devices
  *
  */
-static int usbvision_vbi_open(struct inode *inode, struct file *file)
+static int usbvision_vbi_open(struct file *file)
 {
         /* TODO */
         return -ENODEV;
 }
 
-static int usbvision_vbi_close(struct inode *inode, struct file *file)
+static int usbvision_vbi_close(struct file *file)
 {
         /* TODO */
         return -ENODEV;
 }
 
-static int usbvision_do_vbi_ioctl(struct file *file,
+static long usbvision_do_vbi_ioctl(struct file *file,
                                  unsigned int cmd, void *arg)
 {
         /* TODO */
         return -ENOIOCTLCMD;
 }
 
-static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
+static long usbvision_vbi_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, usbvision_do_vbi_ioctl);
@@ -1297,16 +1298,14 @@ static int usbvision_vbi_ioctl(struct inode *inode, struct file *file,
 //
 
 // Video template
-static const struct file_operations usbvision_fops = {
+static const struct v4l2_file_operations usbvision_fops = {
         .owner             = THIS_MODULE,
         .open           = usbvision_v4l2_open,
         .release        = usbvision_v4l2_close,
         .read           = usbvision_v4l2_read,
         .mmap           = usbvision_v4l2_mmap,
         .ioctl          = video_ioctl2,
-        .llseek         = no_llseek,
 /*      .poll          = video_poll, */
-        .compat_ioctl  = v4l_compat_ioctl32,
 };
 
 static const struct v4l2_ioctl_ops usbvision_ioctl_ops = {
@@ -1355,13 +1354,11 @@ static struct video_device usbvision_video_template = {
 
 
 // Radio template
-static const struct file_operations usbvision_radio_fops = {
+static const struct v4l2_file_operations usbvision_radio_fops = {
         .owner             = THIS_MODULE,
         .open           = usbvision_radio_open,
         .release        = usbvision_radio_close,
         .ioctl          = video_ioctl2,
-        .llseek         = no_llseek,
-        .compat_ioctl  = v4l_compat_ioctl32,
 };
 
 static const struct v4l2_ioctl_ops usbvision_radio_ioctl_ops = {
@@ -1392,13 +1389,11 @@ static struct video_device usbvision_radio_template = {
 };
 
 // vbi template
-static const struct file_operations usbvision_vbi_fops = {
+static const struct v4l2_file_operations usbvision_vbi_fops = {
         .owner             = THIS_MODULE,
         .open           = usbvision_vbi_open,
         .release        = usbvision_vbi_close,
         .ioctl          = usbvision_vbi_ioctl,
-        .llseek         = no_llseek,
-        .compat_ioctl  = v4l_compat_ioctl32,
 };
 
 static struct video_device usbvision_vbi_template=
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index afcc6934559e..fa150fff2c10 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -406,7 +406,7 @@ static int uvc_has_privileges(struct uvc_fh *handle)
  * V4L2 file operations
  */
 
-static int uvc_v4l2_open(struct inode *inode, struct file *file)
+static int uvc_v4l2_open(struct file *file)
 {
         struct uvc_video_device *video;
         struct uvc_fh *handle;
@@ -444,7 +444,7 @@ done:
         return ret;
 }
 
-static int uvc_v4l2_release(struct inode *inode, struct file *file)
+static int uvc_v4l2_release(struct file *file)
 {
         struct uvc_video_device *video = video_drvdata(file);
         struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
@@ -472,12 +472,12 @@ static int uvc_v4l2_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_video_device *video = video_get_drvdata(vdev);
         struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
-        int ret = 0;
+        long ret = 0;
 
         switch (cmd) {
         /* Query capabilities */
@@ -996,7 +996,7 @@ static int uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return ret;
 }
 
-static int uvc_v4l2_ioctl(struct inode *inode, struct file *file,
+static long uvc_v4l2_ioctl(struct file *file,
                      unsigned int cmd, unsigned long arg)
 {
         if (uvc_trace_param & UVC_TRACE_IOCTL) {
@@ -1097,13 +1097,11 @@ static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
         return uvc_queue_poll(&video->queue, file, wait);
 }
 
-struct file_operations uvc_fops = {
+const struct v4l2_file_operations uvc_fops = {
         .owner          = THIS_MODULE,
         .open           = uvc_v4l2_open,
         .release        = uvc_v4l2_release,
         .ioctl          = uvc_v4l2_ioctl,
-        .compat_ioctl   = v4l_compat_ioctl32,
-        .llseek         = no_llseek,
         .read           = uvc_v4l2_read,
         .mmap           = uvc_v4l2_mmap,
         .poll           = uvc_v4l2_poll,
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index 896b791ece15..bcf4361dc1bc 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -753,7 +753,7 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 }
 
 /* V4L2 interface */
-extern struct file_operations uvc_fops;
+extern const struct v4l2_file_operations uvc_fops;
 
 /* Video */
 extern int uvc_video_init(struct uvc_video_device *video);
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
index f13c0a9d684f..d450cab20be4 100644
--- a/drivers/media/video/v4l1-compat.c
+++ b/drivers/media/video/v4l1-compat.c
@@ -267,12 +267,12 @@ done:
 
 /* ----------------------------------------------------------------- */
 
-static noinline int v4l1_compat_get_capabilities(
+static noinline long v4l1_compat_get_capabilities(
                                         struct video_capability *cap,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_framebuffer fbuf;
         struct v4l2_capability *cap2;
 
@@ -286,13 +286,13 @@ static noinline int v4l1_compat_get_capabilities(
 
         err = drv(file, VIDIOC_QUERYCAP, cap2);
         if (err < 0) {
-                dprintk("VIDIOCGCAP / VIDIOC_QUERYCAP: %d\n", err);
+                dprintk("VIDIOCGCAP / VIDIOC_QUERYCAP: %ld\n", err);
                 goto done;
         }
         if (cap2->capabilities & V4L2_CAP_VIDEO_OVERLAY) {
                 err = drv(file, VIDIOC_G_FBUF, &fbuf);
                 if (err < 0) {
-                        dprintk("VIDIOCGCAP / VIDIOC_G_FBUF: %d\n", err);
+                        dprintk("VIDIOCGCAP / VIDIOC_G_FBUF: %ld\n", err);
                         memset(&fbuf, 0, sizeof(fbuf));
                 }
                 err = 0;
@@ -324,12 +324,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_get_frame_buffer(
+static noinline long v4l1_compat_get_frame_buffer(
                                         struct video_buffer *buffer,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_framebuffer fbuf;
 
         memset(buffer, 0, sizeof(*buffer));
@@ -337,7 +337,7 @@ static noinline int v4l1_compat_get_frame_buffer(
 
         err = drv(file, VIDIOC_G_FBUF, &fbuf);
         if (err < 0) {
-                dprintk("VIDIOCGFBUF / VIDIOC_G_FBUF: %d\n", err);
+                dprintk("VIDIOCGFBUF / VIDIOC_G_FBUF: %ld\n", err);
                 goto done;
         }
         buffer->base   = fbuf.base;
@@ -378,12 +378,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_frame_buffer(
+static noinline long v4l1_compat_set_frame_buffer(
                                         struct video_buffer *buffer,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_framebuffer fbuf;
 
         memset(&fbuf, 0, sizeof(fbuf));
@@ -410,16 +410,16 @@ static noinline int v4l1_compat_set_frame_buffer(
         fbuf.fmt.bytesperline = buffer->bytesperline;
         err = drv(file, VIDIOC_S_FBUF, &fbuf);
         if (err < 0)
-                dprintk("VIDIOCSFBUF / VIDIOC_S_FBUF: %d\n", err);
+                dprintk("VIDIOCSFBUF / VIDIOC_S_FBUF: %ld\n", err);
         return err;
 }
 
-static noinline int v4l1_compat_get_win_cap_dimensions(
+static noinline long v4l1_compat_get_win_cap_dimensions(
                                         struct video_window *win,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_format *fmt;
 
         fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
@@ -432,7 +432,7 @@ static noinline int v4l1_compat_get_win_cap_dimensions(
         fmt->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
         err = drv(file, VIDIOC_G_FMT, fmt);
         if (err < 0)
-                dprintk("VIDIOCGWIN / VIDIOC_G_WIN: %d\n", err);
+                dprintk("VIDIOCGWIN / VIDIOC_G_WIN: %ld\n", err);
         if (err == 0) {
                 win->x         = fmt->fmt.win.w.left;
                 win->y         = fmt->fmt.win.w.top;
@@ -447,7 +447,7 @@ static noinline int v4l1_compat_get_win_cap_dimensions(
         fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         err = drv(file, VIDIOC_G_FMT, fmt);
         if (err < 0) {
-                dprintk("VIDIOCGWIN / VIDIOC_G_FMT: %d\n", err);
+                dprintk("VIDIOCGWIN / VIDIOC_G_FMT: %ld\n", err);
                 goto done;
         }
         win->x         = 0;
@@ -462,12 +462,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_win_cap_dimensions(
+static noinline long v4l1_compat_set_win_cap_dimensions(
                                         struct video_window *win,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err, err1, err2;
+        long err, err1, err2;
         struct v4l2_format *fmt;
 
         fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
@@ -479,7 +479,7 @@ static noinline int v4l1_compat_set_win_cap_dimensions(
         drv(file, VIDIOC_STREAMOFF, &fmt->type);
         err1 = drv(file, VIDIOC_G_FMT, fmt);
         if (err1 < 0)
-                dprintk("VIDIOCSWIN / VIDIOC_G_FMT: %d\n", err1);
+                dprintk("VIDIOCSWIN / VIDIOC_G_FMT: %ld\n", err1);
         if (err1 == 0) {
                 fmt->fmt.pix.width  = win->width;
                 fmt->fmt.pix.height = win->height;
@@ -487,7 +487,7 @@ static noinline int v4l1_compat_set_win_cap_dimensions(
                 fmt->fmt.pix.bytesperline = 0;
                 err = drv(file, VIDIOC_S_FMT, fmt);
                 if (err < 0)
-                        dprintk("VIDIOCSWIN / VIDIOC_S_FMT #1: %d\n",
+                        dprintk("VIDIOCSWIN / VIDIOC_S_FMT #1: %ld\n",
                                 err);
                 win->width  = fmt->fmt.pix.width;
                 win->height = fmt->fmt.pix.height;
@@ -504,7 +504,7 @@ static noinline int v4l1_compat_set_win_cap_dimensions(
         fmt->fmt.win.clipcount = win->clipcount;
         err2 = drv(file, VIDIOC_S_FMT, fmt);
         if (err2 < 0)
-                dprintk("VIDIOCSWIN / VIDIOC_S_FMT #2: %d\n", err2);
+                dprintk("VIDIOCSWIN / VIDIOC_S_FMT #2: %ld\n", err2);
 
         if (err1 != 0 && err2 != 0)
                 err = err1;
@@ -514,12 +514,12 @@ static noinline int v4l1_compat_set_win_cap_dimensions(
         return err;
 }
 
-static noinline int v4l1_compat_turn_preview_on_off(
+static noinline long v4l1_compat_turn_preview_on_off(
                                         int *on,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         enum v4l2_buf_type captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
         if (0 == *on) {
@@ -530,16 +530,16 @@ static noinline int v4l1_compat_turn_preview_on_off(
         }
         err = drv(file, VIDIOC_OVERLAY, on);
         if (err < 0)
-                dprintk("VIDIOCCAPTURE / VIDIOC_PREVIEW: %d\n", err);
+                dprintk("VIDIOCCAPTURE / VIDIOC_PREVIEW: %ld\n", err);
         return err;
 }
 
-static noinline int v4l1_compat_get_input_info(
+static noinline long v4l1_compat_get_input_info(
                                         struct video_channel *chan,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_input       input2;
         v4l2_std_id             sid;
 
@@ -548,7 +548,7 @@ static noinline int v4l1_compat_get_input_info(
         err = drv(file, VIDIOC_ENUMINPUT, &input2);
         if (err < 0) {
                 dprintk("VIDIOCGCHAN / VIDIOC_ENUMINPUT: "
-                        "channel=%d err=%d\n", chan->channel, err);
+                        "channel=%d err=%ld\n", chan->channel, err);
                 goto done;
         }
         chan->channel = input2.index;
@@ -569,7 +569,7 @@ static noinline int v4l1_compat_get_input_info(
         chan->norm = 0;
         err = drv(file, VIDIOC_G_STD, &sid);
         if (err < 0)
-                dprintk("VIDIOCGCHAN / VIDIOC_G_STD: %d\n", err);
+                dprintk("VIDIOCGCHAN / VIDIOC_G_STD: %ld\n", err);
         if (err == 0) {
                 if (sid & V4L2_STD_PAL)
                         chan->norm = VIDEO_MODE_PAL;
@@ -582,17 +582,17 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_input(
+static noinline long v4l1_compat_set_input(
                                         struct video_channel *chan,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         v4l2_std_id sid = 0;
 
         err = drv(file, VIDIOC_S_INPUT, &chan->channel);
         if (err < 0)
-                dprintk("VIDIOCSCHAN / VIDIOC_S_INPUT: %d\n", err);
+                dprintk("VIDIOCSCHAN / VIDIOC_S_INPUT: %ld\n", err);
         switch (chan->norm) {
         case VIDEO_MODE_PAL:
                 sid = V4L2_STD_PAL;
@@ -607,17 +607,17 @@ static noinline int v4l1_compat_set_input(
         if (0 != sid) {
                 err = drv(file, VIDIOC_S_STD, &sid);
                 if (err < 0)
-                        dprintk("VIDIOCSCHAN / VIDIOC_S_STD: %d\n", err);
+                        dprintk("VIDIOCSCHAN / VIDIOC_S_STD: %ld\n", err);
         }
         return err;
 }
 
-static noinline int v4l1_compat_get_picture(
+static noinline long v4l1_compat_get_picture(
                                         struct video_picture *pict,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_format *fmt;
 
         fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
@@ -640,7 +640,7 @@ static noinline int v4l1_compat_get_picture(
         fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         err = drv(file, VIDIOC_G_FMT, fmt);
         if (err < 0) {
-                dprintk("VIDIOCGPICT / VIDIOC_G_FMT: %d\n", err);
+                dprintk("VIDIOCGPICT / VIDIOC_G_FMT: %ld\n", err);
                 goto done;
         }
 
@@ -654,12 +654,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_picture(
+static noinline long v4l1_compat_set_picture(
                                         struct video_picture *pict,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_framebuffer fbuf;
         int mem_err = 0, ovl_err = 0;
         struct v4l2_format *fmt;
@@ -694,7 +694,7 @@ static noinline int v4l1_compat_set_picture(
            support memory capture.  Trying to set the memory capture
            parameters would be pointless.  */
         if (err < 0) {
-                dprintk("VIDIOCSPICT / VIDIOC_G_FMT: %d\n", err);
+                dprintk("VIDIOCSPICT / VIDIOC_G_FMT: %ld\n", err);
                 mem_err = -1000;  /* didn't even try */
         } else if (fmt->fmt.pix.pixelformat !=
                  palette_to_pixelformat(pict->palette)) {
@@ -711,7 +711,7 @@ static noinline int v4l1_compat_set_picture(
            support overlay.  Trying to set the overlay parameters
            would be quite pointless.  */
         if (err < 0) {
-                dprintk("VIDIOCSPICT / VIDIOC_G_FBUF: %d\n", err);
+                dprintk("VIDIOCSPICT / VIDIOC_G_FBUF: %ld\n", err);
                 ovl_err = -1000;  /* didn't even try */
         } else if (fbuf.fmt.pixelformat !=
                  palette_to_pixelformat(pict->palette)) {
@@ -736,12 +736,13 @@ static noinline int v4l1_compat_set_picture(
         return err;
 }
 
-static noinline int v4l1_compat_get_tuner(
+static noinline long v4l1_compat_get_tuner(
                                         struct video_tuner *tun,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err, i;
+        long err;
+        int i;
         struct v4l2_tuner       tun2;
         struct v4l2_standard    std2;
         v4l2_std_id             sid;
@@ -749,7 +750,7 @@ static noinline int v4l1_compat_get_tuner(
         memset(&tun2, 0, sizeof(tun2));
         err = drv(file, VIDIOC_G_TUNER, &tun2);
         if (err < 0) {
-                dprintk("VIDIOCGTUNER / VIDIOC_G_TUNER: %d\n", err);
+                dprintk("VIDIOCGTUNER / VIDIOC_G_TUNER: %ld\n", err);
                 goto done;
         }
         memcpy(tun->name, tun2.name,
@@ -775,7 +776,7 @@ static noinline int v4l1_compat_get_tuner(
 
         err = drv(file, VIDIOC_G_STD, &sid);
         if (err < 0)
-                dprintk("VIDIOCGTUNER / VIDIOC_G_STD: %d\n", err);
+                dprintk("VIDIOCGTUNER / VIDIOC_G_STD: %ld\n", err);
         if (err == 0) {
                 if (sid & V4L2_STD_PAL)
                         tun->mode = VIDEO_MODE_PAL;
@@ -794,12 +795,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_select_tuner(
+static noinline long v4l1_compat_select_tuner(
                                         struct video_tuner *tun,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_tuner       t;/*84 bytes on x86_64*/
         memset(&t, 0, sizeof(t));
 
@@ -807,34 +808,34 @@ static noinline int v4l1_compat_select_tuner(
 
         err = drv(file, VIDIOC_S_INPUT, &t);
         if (err < 0)
-                dprintk("VIDIOCSTUNER / VIDIOC_S_INPUT: %d\n", err);
+                dprintk("VIDIOCSTUNER / VIDIOC_S_INPUT: %ld\n", err);
         return err;
 }
 
-static noinline int v4l1_compat_get_frequency(
+static noinline long v4l1_compat_get_frequency(
                                         unsigned long *freq,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_frequency   freq2;
         memset(&freq2, 0, sizeof(freq2));
 
         freq2.tuner = 0;
         err = drv(file, VIDIOC_G_FREQUENCY, &freq2);
         if (err < 0)
-                dprintk("VIDIOCGFREQ / VIDIOC_G_FREQUENCY: %d\n", err);
+                dprintk("VIDIOCGFREQ / VIDIOC_G_FREQUENCY: %ld\n", err);
         if (0 == err)
                 *freq = freq2.frequency;
         return err;
 }
 
-static noinline int v4l1_compat_set_frequency(
+static noinline long v4l1_compat_set_frequency(
                                         unsigned long *freq,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_frequency   freq2;
         memset(&freq2, 0, sizeof(freq2));
 
@@ -842,16 +843,17 @@ static noinline int v4l1_compat_set_frequency(
         freq2.frequency = *freq;
         err = drv(file, VIDIOC_S_FREQUENCY, &freq2);
         if (err < 0)
-                dprintk("VIDIOCSFREQ / VIDIOC_S_FREQUENCY: %d\n", err);
+                dprintk("VIDIOCSFREQ / VIDIOC_S_FREQUENCY: %ld\n", err);
         return err;
 }
 
-static noinline int v4l1_compat_get_audio(
+static noinline long v4l1_compat_get_audio(
                                         struct video_audio *aud,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err, i;
+        long err;
+        int i;
         struct v4l2_queryctrl   qctrl2;
         struct v4l2_audio       aud2;
         struct v4l2_tuner       tun2;
@@ -859,7 +861,7 @@ static noinline int v4l1_compat_get_audio(
 
         err = drv(file, VIDIOC_G_AUDIO, &aud2);
         if (err < 0) {
-                dprintk("VIDIOCGAUDIO / VIDIOC_G_AUDIO: %d\n", err);
+                dprintk("VIDIOCGAUDIO / VIDIOC_G_AUDIO: %ld\n", err);
                 goto done;
         }
         memcpy(aud->name, aud2.name,
@@ -903,7 +905,7 @@ static noinline int v4l1_compat_get_audio(
         memset(&tun2, 0, sizeof(tun2));
         err = drv(file, VIDIOC_G_TUNER, &tun2);
         if (err < 0) {
-                dprintk("VIDIOCGAUDIO / VIDIOC_G_TUNER: %d\n", err);
+                dprintk("VIDIOCGAUDIO / VIDIOC_G_TUNER: %ld\n", err);
                 err = 0;
                 goto done;
         }
@@ -918,12 +920,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_audio(
+static noinline long v4l1_compat_set_audio(
                                         struct video_audio *aud,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_audio       aud2;
         struct v4l2_tuner       tun2;
 
@@ -933,7 +935,7 @@ static noinline int v4l1_compat_set_audio(
         aud2.index = aud->audio;
         err = drv(file, VIDIOC_S_AUDIO, &aud2);
         if (err < 0) {
-                dprintk("VIDIOCSAUDIO / VIDIOC_S_AUDIO: %d\n", err);
+                dprintk("VIDIOCSAUDIO / VIDIOC_S_AUDIO: %ld\n", err);
                 goto done;
         }
 
@@ -950,7 +952,7 @@ static noinline int v4l1_compat_set_audio(
 
         err = drv(file, VIDIOC_G_TUNER, &tun2);
         if (err < 0)
-                dprintk("VIDIOCSAUDIO / VIDIOC_G_TUNER: %d\n", err);
+                dprintk("VIDIOCSAUDIO / VIDIOC_G_TUNER: %ld\n", err);
         if (err == 0) {
                 switch (aud->mode) {
                 default:
@@ -967,19 +969,19 @@ static noinline int v4l1_compat_set_audio(
                 }
                 err = drv(file, VIDIOC_S_TUNER, &tun2);
                 if (err < 0)
-                        dprintk("VIDIOCSAUDIO / VIDIOC_S_TUNER: %d\n", err);
+                        dprintk("VIDIOCSAUDIO / VIDIOC_S_TUNER: %ld\n", err);
         }
         err = 0;
 done:
         return err;
 }
 
-static noinline int v4l1_compat_capture_frame(
+static noinline long v4l1_compat_capture_frame(
                                         struct video_mmap *mm,
                                         struct file *file,
                                         v4l2_kioctl drv)
 {
-        int err;
+        long err;
         enum v4l2_buf_type      captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         struct v4l2_buffer      buf;
         struct v4l2_format      *fmt;
@@ -994,7 +996,7 @@ static noinline int v4l1_compat_capture_frame(
         fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         err = drv(file, VIDIOC_G_FMT, fmt);
         if (err < 0) {
-                dprintk("VIDIOCMCAPTURE / VIDIOC_G_FMT: %d\n", err);
+                dprintk("VIDIOCMCAPTURE / VIDIOC_G_FMT: %ld\n", err);
                 goto done;
         }
         if (mm->width   != fmt->fmt.pix.width  ||
@@ -1010,7 +1012,7 @@ static noinline int v4l1_compat_capture_frame(
                 fmt->fmt.pix.bytesperline = 0;
                 err = drv(file, VIDIOC_S_FMT, fmt);
                 if (err < 0) {
-                        dprintk("VIDIOCMCAPTURE / VIDIOC_S_FMT: %d\n", err);
+                        dprintk("VIDIOCMCAPTURE / VIDIOC_S_FMT: %ld\n", err);
                         goto done;
                 }
         }
@@ -1018,28 +1020,28 @@ static noinline int v4l1_compat_capture_frame(
         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         err = drv(file, VIDIOC_QUERYBUF, &buf);
         if (err < 0) {
-                dprintk("VIDIOCMCAPTURE / VIDIOC_QUERYBUF: %d\n", err);
+                dprintk("VIDIOCMCAPTURE / VIDIOC_QUERYBUF: %ld\n", err);
                 goto done;
         }
         err = drv(file, VIDIOC_QBUF, &buf);
         if (err < 0) {
-                dprintk("VIDIOCMCAPTURE / VIDIOC_QBUF: %d\n", err);
+                dprintk("VIDIOCMCAPTURE / VIDIOC_QBUF: %ld\n", err);
                 goto done;
         }
         err = drv(file, VIDIOC_STREAMON, &captype);
         if (err < 0)
-                dprintk("VIDIOCMCAPTURE / VIDIOC_STREAMON: %d\n", err);
+                dprintk("VIDIOCMCAPTURE / VIDIOC_STREAMON: %ld\n", err);
 done:
         kfree(fmt);
         return err;
 }
 
-static noinline int v4l1_compat_sync(
+static noinline long v4l1_compat_sync(
                                 int *i,
                                 struct file *file,
                                 v4l2_kioctl drv)
 {
-        int err;
+        long err;
         enum v4l2_buf_type captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         struct v4l2_buffer buf;
         struct poll_wqueues *pwq;
@@ -1050,7 +1052,7 @@ static noinline int v4l1_compat_sync(
         err = drv(file, VIDIOC_QUERYBUF, &buf);
         if (err < 0) {
                 /*  No such buffer */
-                dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %d\n", err);
+                dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %ld\n", err);
                 goto done;
         }
         if (!(buf.flags & V4L2_BUF_FLAG_MAPPED)) {
@@ -1062,7 +1064,7 @@ static noinline int v4l1_compat_sync(
         /* make sure capture actually runs so we don't block forever */
         err = drv(file, VIDIOC_STREAMON, &captype);
         if (err < 0) {
-                dprintk("VIDIOCSYNC / VIDIOC_STREAMON: %d\n", err);
+                dprintk("VIDIOCSYNC / VIDIOC_STREAMON: %ld\n", err);
                 goto done;
         }
 
@@ -1076,7 +1078,7 @@ static noinline int v4l1_compat_sync(
                         break;
                 err = drv(file, VIDIOC_QUERYBUF, &buf);
                 if (err < 0)
-                        dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %d\n", err);
+                        dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %ld\n", err);
         }
         kfree(pwq);
         if (!(buf.flags & V4L2_BUF_FLAG_DONE)) /* not done */
@@ -1084,18 +1086,18 @@ static noinline int v4l1_compat_sync(
         do {
                 err = drv(file, VIDIOC_DQBUF, &buf);
                 if (err < 0)
-                        dprintk("VIDIOCSYNC / VIDIOC_DQBUF: %d\n", err);
+                        dprintk("VIDIOCSYNC / VIDIOC_DQBUF: %ld\n", err);
         } while (err == 0 && buf.index != *i);
 done:
         return err;
 }
 
-static noinline int v4l1_compat_get_vbi_format(
+static noinline long v4l1_compat_get_vbi_format(
                                 struct vbi_format *fmt,
                                 struct file *file,
                                 v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_format *fmt2;
 
         fmt2 = kzalloc(sizeof(*fmt2), GFP_KERNEL);
@@ -1107,7 +1109,7 @@ static noinline int v4l1_compat_get_vbi_format(
 
         err = drv(file, VIDIOC_G_FMT, fmt2);
         if (err < 0) {
-                dprintk("VIDIOCGVBIFMT / VIDIOC_G_FMT: %d\n", err);
+                dprintk("VIDIOCGVBIFMT / VIDIOC_G_FMT: %ld\n", err);
                 goto done;
         }
         if (fmt2->fmt.vbi.sample_format != V4L2_PIX_FMT_GREY) {
@@ -1128,12 +1130,12 @@ done:
         return err;
 }
 
-static noinline int v4l1_compat_set_vbi_format(
+static noinline long v4l1_compat_set_vbi_format(
                                 struct vbi_format *fmt,
                                 struct file *file,
                                 v4l2_kioctl drv)
 {
-        int err;
+        long err;
         struct v4l2_format      *fmt2 = NULL;
 
         if (VIDEO_PALETTE_RAW != fmt->sample_format) {
@@ -1157,7 +1159,7 @@ static noinline int v4l1_compat_set_vbi_format(
         fmt2->fmt.vbi.flags            = fmt->flags;
         err = drv(file, VIDIOC_TRY_FMT, fmt2);
         if (err < 0) {
-                dprintk("VIDIOCSVBIFMT / VIDIOC_TRY_FMT: %d\n", err);
+                dprintk("VIDIOCSVBIFMT / VIDIOC_TRY_FMT: %ld\n", err);
                 goto done;
         }
 
@@ -1174,7 +1176,7 @@ static noinline int v4l1_compat_set_vbi_format(
         }
         err = drv(file, VIDIOC_S_FMT, fmt2);
         if (err < 0)
-                dprintk("VIDIOCSVBIFMT / VIDIOC_S_FMT: %d\n", err);
+                dprintk("VIDIOCSVBIFMT / VIDIOC_S_FMT: %ld\n", err);
 done:
         kfree(fmt2);
         return err;
@@ -1183,13 +1185,13 @@ done:
 /*
  *      This function is exported.
  */
-int
+long
 v4l_compat_translate_ioctl(struct file          *file,
                            int                  cmd,
                            void                 *arg,
                            v4l2_kioctl          drv)
 {
-        int err;
+        long err;
 
         switch (cmd) {
         case VIDIOCGCAP:        /* capability */
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index c676b0b0f708..b8f2be8d5c0e 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -797,11 +797,11 @@ u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 }
 EXPORT_SYMBOL(v4l2_ctrl_next);
 
-int v4l2_chip_match_host(u32 match_type, u32 match_chip)
+int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
 {
-        switch (match_type) {
+        switch (match->type) {
         case V4L2_CHIP_MATCH_HOST:
-                return match_chip == 0;
+                return match->addr == 0;
         default:
                 return 0;
         }
@@ -809,23 +809,34 @@ int v4l2_chip_match_host(u32 match_type, u32 match_chip)
 EXPORT_SYMBOL(v4l2_chip_match_host);
 
 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
-int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
+int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
 {
-        switch (match_type) {
+        int len;
+
+        if (c == NULL || match == NULL)
+                return 0;
+
+        switch (match->type) {
         case V4L2_CHIP_MATCH_I2C_DRIVER:
-                return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
+                if (c->driver == NULL || c->driver->driver.name == NULL)
+                        return 0;
+                len = strlen(c->driver->driver.name);
+                /* legacy drivers have a ' suffix, don't try to match that */
+                if (len && c->driver->driver.name[len - 1] == '\'')
+                        len--;
+                return len && !strncmp(c->driver->driver.name, match->name, len);
         case V4L2_CHIP_MATCH_I2C_ADDR:
-                return (c != NULL && c->addr == match_chip);
+                return c->addr == match->addr;
         default:
                 return 0;
         }
 }
 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
 
-int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
+int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
                 u32 ident, u32 revision)
 {
-        if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip))
+        if (!v4l2_chip_match_i2c_client(c, &chip->match))
                 return 0;
         if (chip->ident == V4L2_IDENT_NONE) {
                 chip->ident = ident;
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index d0e1bd3ace6a..110376be5d2b 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -222,9 +222,9 @@ static int get_microcode32(struct video_code *kp, struct video_code32 __user *up
 
 #endif
 
-static int native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        long ret = -ENOIOCTLCMD;
 
         if (file->f_op->unlocked_ioctl)
                 ret = file->f_op->unlocked_ioctl(file, cmd, arg);
@@ -705,7 +705,7 @@ static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext
 #define VIDIOC_G_OUTPUT32       _IOR ('V', 46, s32)
 #define VIDIOC_S_OUTPUT32       _IOWR('V', 47, s32)
 
-static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         union {
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
@@ -726,7 +726,7 @@ static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg
         } karg;
         void __user *up = compat_ptr(arg);
         int compatible_arg = 1;
-        int err = 0;
+        long err = 0;
 
         /* First, convert the command. */
         switch (cmd) {
@@ -937,9 +937,9 @@ static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg
         return err;
 }
 
-long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
+long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        long ret = -ENOIOCTLCMD;
 
         if (!file->f_op->ioctl && !file->f_op->unlocked_ioctl)
                 return ret;
@@ -1046,7 +1046,8 @@ long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
         case VIDIOC_TRY_ENCODER_CMD:
         case VIDIOC_DBG_S_REGISTER:
         case VIDIOC_DBG_G_REGISTER:
-        case VIDIOC_G_CHIP_IDENT:
+        case VIDIOC_DBG_G_CHIP_IDENT:
+        case VIDIOC_G_CHIP_IDENT_OLD:
         case VIDIOC_S_HW_FREQ_SEEK:
                 ret = do_video_ioctl(file, cmd, arg);
                 break;
@@ -1065,18 +1066,14 @@ long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
                 break;
 #endif
         default:
-                v4l_print_ioctl("compat_ioctl32", cmd);
-                printk(KERN_CONT "\n");
+                printk(KERN_WARNING "compat_ioctl32: "
+                        "unknown ioctl '%c', dir=%d, #%d (0x%08x)\n",
+                        _IOC_TYPE(cmd), _IOC_DIR(cmd), _IOC_NR(cmd), cmd);
                 break;
         }
         return ret;
 }
-#else
-long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
-{
-        return -ENOIOCTLCMD;
-}
+EXPORT_SYMBOL_GPL(v4l2_compat_ioctl32);
 #endif
-EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index 7ad6711ee327..13f87c22e78d 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -31,6 +31,7 @@
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
 
 #define VIDEO_NUM_DEVICES       256
 #define VIDEO_NAME              "video4linux"
@@ -182,7 +183,7 @@ static int v4l2_ioctl(struct inode *inode, struct file *filp,
                 return -ENOTTY;
         /* Allow ioctl to continue even if the device was unregistered.
            Things like dequeueing buffers might still be useful. */
-        return vdev->fops->ioctl(inode, filp, cmd, arg);
+        return vdev->fops->ioctl(filp, cmd, arg);
 }
 
 static long v4l2_unlocked_ioctl(struct file *filp,
@@ -197,20 +198,6 @@ static long v4l2_unlocked_ioctl(struct file *filp,
         return vdev->fops->unlocked_ioctl(filp, cmd, arg);
 }
 
-#ifdef CONFIG_COMPAT
-static long v4l2_compat_ioctl(struct file *filp,
-                unsigned int cmd, unsigned long arg)
-{
-        struct video_device *vdev = video_devdata(filp);
-
-        if (!vdev->fops->compat_ioctl)
-                return -ENOIOCTLCMD;
-        /* Allow ioctl to continue even if the device was unregistered.
-           Things like dequeueing buffers might still be useful. */
-        return vdev->fops->compat_ioctl(filp, cmd, arg);
-}
-#endif
-
 static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
 {
         struct video_device *vdev = video_devdata(filp);
@@ -239,7 +226,7 @@ static int v4l2_open(struct inode *inode, struct file *filp)
         /* and increase the device refcount */
         video_get(vdev);
         mutex_unlock(&videodev_lock);
-        ret = vdev->fops->open(inode, filp);
+        ret = vdev->fops->open(filp);
         /* decrease the refcount in case of an error */
         if (ret)
                 video_put(vdev);
@@ -250,7 +237,7 @@ static int v4l2_open(struct inode *inode, struct file *filp)
 static int v4l2_release(struct inode *inode, struct file *filp)
 {
         struct video_device *vdev = video_devdata(filp);
-        int ret = vdev->fops->release(inode, filp);
+        int ret = vdev->fops->release(filp);
 
         /* decrease the refcount unconditionally since the release()
            return value is ignored. */
@@ -266,7 +253,7 @@ static const struct file_operations v4l2_unlocked_fops = {
         .mmap = v4l2_mmap,
         .unlocked_ioctl = v4l2_unlocked_ioctl,
 #ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l2_compat_ioctl,
+        .compat_ioctl = v4l2_compat_ioctl32,
 #endif
         .release = v4l2_release,
         .poll = v4l2_poll,
@@ -281,7 +268,7 @@ static const struct file_operations v4l2_fops = {
         .mmap = v4l2_mmap,
         .ioctl = v4l2_ioctl,
 #ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l2_compat_ioctl,
+        .compat_ioctl = v4l2_compat_ioctl32,
 #endif
         .release = v4l2_release,
         .poll = v4l2_poll,
diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index b063381f4b3b..52d687b165e0 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -266,7 +266,7 @@ static const char *v4l2_ioctls[] = {
         [_IOC_NR(VIDIOC_DBG_S_REGISTER)]   = "VIDIOC_DBG_S_REGISTER",
         [_IOC_NR(VIDIOC_DBG_G_REGISTER)]   = "VIDIOC_DBG_G_REGISTER",
 
-        [_IOC_NR(VIDIOC_G_CHIP_IDENT)]     = "VIDIOC_G_CHIP_IDENT",
+        [_IOC_NR(VIDIOC_DBG_G_CHIP_IDENT)] = "VIDIOC_DBG_G_CHIP_IDENT",
         [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)]   = "VIDIOC_S_HW_FREQ_SEEK",
 #endif
 };
@@ -392,14 +392,14 @@ video_fix_command(unsigned int cmd)
 /*
  * Obsolete usercopy function - Should be removed soon
  */
-int
+long
 video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
                 v4l2_kioctl func)
 {
         char    sbuf[128];
         void    *mbuf = NULL;
         void    *parg = NULL;
-        int     err  = -EINVAL;
+        long    err  = -EINVAL;
         int     is_ext_ctrl;
         size_t  ctrls_size = 0;
         void __user *user_ptr = NULL;
@@ -623,13 +623,13 @@ static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
         return -EINVAL;
 }
 
-static int __video_do_ioctl(struct file *file,
+static long __video_do_ioctl(struct file *file,
                 unsigned int cmd, void *arg)
 {
         struct video_device *vfd = video_devdata(file);
         const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
         void *fh = file->private_data;
-        int ret = -EINVAL;
+        long ret = -EINVAL;
 
         if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
                                 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
@@ -1720,7 +1720,7 @@ static int __video_do_ioctl(struct file *file,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         case VIDIOC_DBG_G_REGISTER:
         {
-                struct v4l2_register *p = arg;
+                struct v4l2_dbg_register *p = arg;
 
                 if (!capable(CAP_SYS_ADMIN))
                         ret = -EPERM;
@@ -1730,7 +1730,7 @@ static int __video_do_ioctl(struct file *file,
         }
         case VIDIOC_DBG_S_REGISTER:
         {
-                struct v4l2_register *p = arg;
+                struct v4l2_dbg_register *p = arg;
 
                 if (!capable(CAP_SYS_ADMIN))
                         ret = -EPERM;
@@ -1739,9 +1739,9 @@ static int __video_do_ioctl(struct file *file,
                 break;
         }
 #endif
-        case VIDIOC_G_CHIP_IDENT:
+        case VIDIOC_DBG_G_CHIP_IDENT:
         {
-                struct v4l2_chip_ident *p = arg;
+                struct v4l2_dbg_chip_ident *p = arg;
 
                 if (!ops->vidioc_g_chip_ident)
                         break;
@@ -1750,6 +1750,11 @@ static int __video_do_ioctl(struct file *file,
                         dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
                 break;
         }
+        case VIDIOC_G_CHIP_IDENT_OLD:
+                printk(KERN_ERR "VIDIOC_G_CHIP_IDENT has been deprecated and will disappear in 2.6.30.\n");
+                printk(KERN_ERR "It is a debugging ioctl and must not be used in applications!\n");
+                return -EINVAL;
+
         case VIDIOC_S_HW_FREQ_SEEK:
         {
                 struct v4l2_hw_freq_seek *p = arg;
@@ -1845,20 +1850,20 @@ static int __video_do_ioctl(struct file *file,
         if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
                 if (ret < 0) {
                         v4l_print_ioctl(vfd->name, cmd);
-                        printk(KERN_CONT " error %d\n", ret);
+                        printk(KERN_CONT " error %ld\n", ret);
                 }
         }
 
         return ret;
 }
 
-long __video_ioctl2(struct file *file,
+long video_ioctl2(struct file *file,
                unsigned int cmd, unsigned long arg)
 {
         char    sbuf[128];
         void    *mbuf = NULL;
         void    *parg = NULL;
-        int     err  = -EINVAL;
+        long    err  = -EINVAL;
         int     is_ext_ctrl;
         size_t  ctrls_size = 0;
         void __user *user_ptr = NULL;
@@ -1944,11 +1949,4 @@ out:
         kfree(mbuf);
         return err;
 }
-EXPORT_SYMBOL(__video_ioctl2);
-
-int video_ioctl2(struct inode *inode, struct file *file,
-               unsigned int cmd, unsigned long arg)
-{
-        return __video_ioctl2(file, cmd, arg);
-}
 EXPORT_SYMBOL(video_ioctl2);
diff --git a/drivers/media/video/v4l2-subdev.c b/drivers/media/video/v4l2-subdev.c
index e3612f29d0df..fbe9cc0d433a 100644
--- a/drivers/media/video/v4l2-subdev.c
+++ b/drivers/media/video/v4l2-subdev.c
@@ -37,7 +37,7 @@ int v4l2_subdev_command(struct v4l2_subdev *sd, unsigned cmd, void *arg)
                 return v4l2_subdev_call(sd, core, queryctrl, arg);
         case VIDIOC_LOG_STATUS:
                 return v4l2_subdev_call(sd, core, log_status);
-        case VIDIOC_G_CHIP_IDENT:
+        case VIDIOC_DBG_G_CHIP_IDENT:
                 return v4l2_subdev_call(sd, core, g_chip_ident, arg);
         case VIDIOC_INT_S_STANDBY:
                 return v4l2_subdev_call(sd, core, s_standby, arg ? (*(u32 *)arg) : 0);
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index a72a361daade..88bf845a3d56 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -4019,7 +4019,7 @@ out:
 
 /* File operations */
 
-static int vino_open(struct inode *inode, struct file *file)
+static int vino_open(struct file *file)
 {
         struct vino_channel_settings *vcs = video_drvdata(file);
         int ret = 0;
@@ -4050,7 +4050,7 @@ static int vino_open(struct inode *inode, struct file *file)
         return ret;
 }
 
-static int vino_close(struct inode *inode, struct file *file)
+static int vino_close(struct file *file)
 {
         struct vino_channel_settings *vcs = video_drvdata(file);
         dprintk("close():\n");
@@ -4237,7 +4237,7 @@ error:
         return ret;
 }
 
-static int vino_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long vino_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct vino_channel_settings *vcs = video_drvdata(file);
 
@@ -4343,11 +4343,11 @@ static int vino_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int vino_ioctl(struct inode *inode, struct file *file,
+static long vino_ioctl(struct file *file,
                       unsigned int cmd, unsigned long arg)
 {
         struct vino_channel_settings *vcs = video_drvdata(file);
-        int ret;
+        long ret;
 
         if (mutex_lock_interruptible(&vcs->mutex))
                 return -EINTR;
@@ -4364,14 +4364,13 @@ static int vino_ioctl(struct inode *inode, struct file *file,
 /* __initdata */
 static int vino_init_stage;
 
-static const struct file_operations vino_fops = {
+static const struct v4l2_file_operations vino_fops = {
         .owner          = THIS_MODULE,
         .open           = vino_open,
         .release        = vino_close,
         .ioctl          = vino_ioctl,
         .mmap           = vino_mmap,
         .poll           = vino_poll,
-        .llseek         = no_llseek,
 };
 
 static struct video_device v4l_device_template = {
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index e15e48f04be7..81d5aa5cf331 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -1024,9 +1024,9 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
         File operations for the device
    ------------------------------------------------------------------*/
 
-static int vivi_open(struct inode *inode, struct file *file)
+static int vivi_open(struct file *file)
 {
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
         struct vivi_dev *dev;
         struct vivi_fh *fh = NULL;
         int i;
@@ -1127,13 +1127,13 @@ vivi_poll(struct file *file, struct poll_table_struct *wait)
         return videobuf_poll_stream(file, q, wait);
 }
 
-static int vivi_close(struct inode *inode, struct file *file)
+static int vivi_close(struct file *file)
 {
         struct vivi_fh         *fh = file->private_data;
         struct vivi_dev *dev       = fh->dev;
         struct vivi_dmaqueue *vidq = &dev->vidq;
 
-        int minor = iminor(inode);
+        int minor = video_devdata(file)->minor;
 
         vivi_stop_thread(vidq);
         videobuf_stop(&fh->vb_vidq);
@@ -1195,16 +1195,14 @@ static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
         return ret;
 }
 
-static const struct file_operations vivi_fops = {
+static const struct v4l2_file_operations vivi_fops = {
         .owner          = THIS_MODULE,
         .open           = vivi_open,
         .release        = vivi_close,
         .read           = vivi_read,
         .poll           = vivi_poll,
         .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
-        .compat_ioctl   = v4l_compat_ioctl32,
         .mmap           = vivi_mmap,
-        .llseek         = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
diff --git a/drivers/media/video/vp27smpx.c b/drivers/media/video/vp27smpx.c
index f72b859486ad..5d73f66d9f55 100644
--- a/drivers/media/video/vp27smpx.c
+++ b/drivers/media/video/vp27smpx.c
@@ -113,7 +113,7 @@ static int vp27smpx_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
         return 0;
 }
 
-static int vp27smpx_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int vp27smpx_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/w9966.c b/drivers/media/video/w9966.c
index 56c570c267ea..038ff32b01b8 100644
--- a/drivers/media/video/w9966.c
+++ b/drivers/media/video/w9966.c
@@ -180,19 +180,19 @@ static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);
 static int w9966_i2c_rbyte(struct w9966_dev* cam);
 #endif
 
-static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
+static long w9966_v4l_ioctl(struct file *file,
                            unsigned int cmd, unsigned long arg);
 static ssize_t w9966_v4l_read(struct file *file, char __user *buf,
                               size_t count, loff_t *ppos);
 
-static int w9966_exclusive_open(struct inode *inode, struct file *file)
+static int w9966_exclusive_open(struct file *file)
 {
         struct w9966_dev *cam = video_drvdata(file);
 
         return test_and_set_bit(0, &cam->in_use) ? -EBUSY : 0;
 }
 
-static int w9966_exclusive_release(struct inode *inode, struct file *file)
+static int w9966_exclusive_release(struct file *file)
 {
         struct w9966_dev *cam = video_drvdata(file);
 
@@ -200,16 +200,12 @@ static int w9966_exclusive_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static const struct file_operations w9966_fops = {
+static const struct v4l2_file_operations w9966_fops = {
         .owner          = THIS_MODULE,
         .open           = w9966_exclusive_open,
         .release        = w9966_exclusive_release,
         .ioctl          = w9966_v4l_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
         .read           = w9966_v4l_read,
-        .llseek         = no_llseek,
 };
 static struct video_device w9966_template = {
         .name           = W9966_DRIVERNAME,
@@ -727,7 +723,7 @@ static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
  *      Video4linux interfacing
  */
 
-static int w9966_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long w9966_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct w9966_dev *cam = video_drvdata(file);
 
@@ -877,7 +873,7 @@ static int w9966_v4l_do_ioctl(struct file *file, unsigned int cmd, void *arg)
         return 0;
 }
 
-static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
+static long w9966_v4l_ioctl(struct file *file,
                            unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, w9966_v4l_do_ioctl);
diff --git a/drivers/media/video/w9968cf.c b/drivers/media/video/w9968cf.c
index 4dfb43bd1846..a3997b7d4366 100644
--- a/drivers/media/video/w9968cf.c
+++ b/drivers/media/video/w9968cf.c
@@ -399,13 +399,13 @@ MODULE_PARM_DESC(specific_debug,
  ****************************************************************************/
 
 /* Video4linux interface */
-static const struct file_operations w9968cf_fops;
-static int w9968cf_open(struct inode*, struct file*);
-static int w9968cf_release(struct inode*, struct file*);
-static int w9968cf_mmap(struct file*, struct vm_area_struct*);
-static int w9968cf_ioctl(struct inode*, struct file*, unsigned, unsigned long);
-static ssize_t w9968cf_read(struct file*, char __user *, size_t, loff_t*);
-static int w9968cf_v4l_ioctl(struct inode*, struct file*, unsigned int,
+static const struct v4l2_file_operations w9968cf_fops;
+static int w9968cf_open(struct file *);
+static int w9968cf_release(struct file *);
+static int w9968cf_mmap(struct file *, struct vm_area_struct *);
+static long w9968cf_ioctl(struct file *, unsigned, unsigned long);
+static ssize_t w9968cf_read(struct file *, char __user *, size_t, loff_t *);
+static long w9968cf_v4l_ioctl(struct file *, unsigned int,
                              void __user *);
 
 /* USB-specific */
@@ -2662,7 +2662,7 @@ static void w9968cf_release_resources(struct w9968cf_device* cam)
  * Video4Linux interface                                                    *
  ****************************************************************************/
 
-static int w9968cf_open(struct inode* inode, struct file* filp)
+static int w9968cf_open(struct file *filp)
 {
         struct w9968cf_device* cam;
         int err;
@@ -2748,7 +2748,7 @@ deallocate_memory:
 }
 
 
-static int w9968cf_release(struct inode* inode, struct file* filp)
+static int w9968cf_release(struct file *filp)
 {
         struct w9968cf_device* cam;
 
@@ -2885,12 +2885,12 @@ static int w9968cf_mmap(struct file* filp, struct vm_area_struct *vma)
 }
 
 
-static int
-w9968cf_ioctl(struct inode* inode, struct file* filp,
+static long
+w9968cf_ioctl(struct file *filp,
               unsigned int cmd, unsigned long arg)
 {
         struct w9968cf_device* cam;
-        int err;
+        long err;
 
         cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 
@@ -2909,15 +2909,15 @@ w9968cf_ioctl(struct inode* inode, struct file* filp,
                 return -EIO;
         }
 
-        err = w9968cf_v4l_ioctl(inode, filp, cmd, (void __user *)arg);
+        err = w9968cf_v4l_ioctl(filp, cmd, (void __user *)arg);
 
         mutex_unlock(&cam->fileop_mutex);
         return err;
 }
 
 
-static int w9968cf_v4l_ioctl(struct inode* inode, struct file* filp,
-                             unsigned int cmd, void __user * arg)
+static long w9968cf_v4l_ioctl(struct file *filp,
+                             unsigned int cmd, void __user *arg)
 {
         struct w9968cf_device* cam;
         const char* v4l1_ioctls[] = {
@@ -3456,17 +3456,13 @@ ioctl_fail:
 }
 
 
-static const struct file_operations w9968cf_fops = {
+static const struct v4l2_file_operations w9968cf_fops = {
         .owner =   THIS_MODULE,
         .open =    w9968cf_open,
         .release = w9968cf_release,
         .read =    w9968cf_read,
         .ioctl =   w9968cf_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
         .mmap =    w9968cf_mmap,
-        .llseek =  no_llseek,
 };
 
 
diff --git a/drivers/media/video/wm8739.c b/drivers/media/video/wm8739.c
index 12a31e7a5f6d..f2864d5cd180 100644
--- a/drivers/media/video/wm8739.c
+++ b/drivers/media/video/wm8739.c
@@ -233,7 +233,7 @@ static int wm8739_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
         return -EINVAL;
 }
 
-static int wm8739_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int wm8739_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/wm8775.c b/drivers/media/video/wm8775.c
index d0220b0ec0bc..53fcd42843e0 100644
--- a/drivers/media/video/wm8775.c
+++ b/drivers/media/video/wm8775.c
@@ -130,7 +130,7 @@ static int wm8775_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
         return 0;
 }
 
-static int wm8775_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip)
+static int wm8775_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
diff --git a/drivers/media/video/zc0301/zc0301_core.c b/drivers/media/video/zc0301/zc0301_core.c
index 9d00e6056491..96971044fc78 100644
--- a/drivers/media/video/zc0301/zc0301_core.c
+++ b/drivers/media/video/zc0301/zc0301_core.c
@@ -649,7 +649,7 @@ static void zc0301_release_resources(struct kref *kref)
 }
 
 
-static int zc0301_open(struct inode* inode, struct file* filp)
+static int zc0301_open(struct file *filp)
 {
         struct zc0301_device* cam;
         int err = 0;
@@ -733,7 +733,7 @@ out:
 }
 
 
-static int zc0301_release(struct inode* inode, struct file* filp)
+static int zc0301_release(struct file *filp)
 {
         struct zc0301_device* cam;
 
@@ -1793,8 +1793,8 @@ zc0301_vidioc_s_parm(struct zc0301_device* cam, void __user * arg)
 }
 
 
-static int zc0301_ioctl_v4l2(struct inode* inode, struct file* filp,
-                             unsigned int cmd, void __user * arg)
+static long zc0301_ioctl_v4l2(struct file *filp,
+                             unsigned int cmd, void __user *arg)
 {
         struct zc0301_device *cam = video_drvdata(filp);
 
@@ -1888,7 +1888,7 @@ static int zc0301_ioctl_v4l2(struct inode* inode, struct file* filp,
 }
 
 
-static int zc0301_ioctl(struct inode* inode, struct file* filp,
+static long zc0301_ioctl(struct file *filp,
                         unsigned int cmd, unsigned long arg)
 {
         struct zc0301_device *cam = video_drvdata(filp);
@@ -1912,7 +1912,7 @@ static int zc0301_ioctl(struct inode* inode, struct file* filp,
 
         V4LDBG(3, "zc0301", cmd);
 
-        err = zc0301_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
+        err = zc0301_ioctl_v4l2(filp, cmd, (void __user *)arg);
 
         mutex_unlock(&cam->fileop_mutex);
 
@@ -1920,18 +1920,14 @@ static int zc0301_ioctl(struct inode* inode, struct file* filp,
 }
 
 
-static const struct file_operations zc0301_fops = {
+static const struct v4l2_file_operations zc0301_fops = {
         .owner =   THIS_MODULE,
         .open =    zc0301_open,
         .release = zc0301_release,
         .ioctl =   zc0301_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl = v4l_compat_ioctl32,
-#endif
         .read =    zc0301_read,
         .poll =    zc0301_poll,
         .mmap =    zc0301_mmap,
-        .llseek =  no_llseek,
 };
 
 /*****************************************************************************/
diff --git a/drivers/media/video/zoran/zoran_driver.c b/drivers/media/video/zoran/zoran_driver.c
index 00b97d97aeaa..b58b9dda715c 100644
--- a/drivers/media/video/zoran/zoran_driver.c
+++ b/drivers/media/video/zoran/zoran_driver.c
@@ -1197,10 +1197,9 @@ zoran_close_end_session (struct file *file)
  */
 
 static int
-zoran_open (struct inode *inode,
-            struct file  *file)
+zoran_open(struct file  *file)
 {
-        unsigned int minor = iminor(inode);
+        unsigned int minor = video_devdata(file)->minor;
         struct zoran *zr = NULL;
         struct zoran_fh *fh;
         int i, res, first_open = 0, have_module_locks = 0;
@@ -1340,8 +1339,7 @@ open_unlock_and_return:
 }
 
 static int
-zoran_close (struct inode *inode,
-             struct file  *file)
+zoran_close(struct file  *file)
 {
         struct zoran_fh *fh = file->private_data;
         struct zoran *zr = fh->zr;
@@ -1940,7 +1938,7 @@ zoran_set_input (struct zoran *zr,
  *   ioctl routine
  */
 
-static int zoran_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static long zoran_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
         struct zoran_fh *fh = file->private_data;
         struct zoran *zr = fh->zr;
@@ -4191,11 +4189,10 @@ static int zoran_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 }
 
 
-static int
-zoran_ioctl (struct inode *inode,
-             struct file  *file,
-             unsigned int  cmd,
-             unsigned long arg)
+static long
+zoran_ioctl(struct file  *file,
+            unsigned int  cmd,
+            unsigned long arg)
 {
         return video_usercopy(file, cmd, arg, zoran_do_ioctl);
 }
@@ -4620,15 +4617,11 @@ zoran_mmap (struct file           *file,
         return 0;
 }
 
-static const struct file_operations zoran_fops = {
+static const struct v4l2_file_operations zoran_fops = {
         .owner = THIS_MODULE,
         .open = zoran_open,
         .release = zoran_close,
         .ioctl = zoran_ioctl,
-#ifdef CONFIG_COMPAT
-        .compat_ioctl   = v4l_compat_ioctl32,
-#endif
-        .llseek = no_llseek,
         .read = zoran_read,
         .write = zoran_write,
         .mmap = zoran_mmap,
diff --git a/drivers/media/video/zr364xx.c b/drivers/media/video/zr364xx.c
index a1d81ed44c7c..93023560f324 100644
--- a/drivers/media/video/zr364xx.c
+++ b/drivers/media/video/zr364xx.c
@@ -634,7 +634,7 @@ static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
 
 
 /* open the camera */
-static int zr364xx_open(struct inode *inode, struct file *file)
+static int zr364xx_open(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam = video_get_drvdata(vdev);
@@ -688,7 +688,7 @@ out:
 
 
 /* release the camera */
-static int zr364xx_release(struct inode *inode, struct file *file)
+static int zr364xx_release(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
         struct zr364xx_camera *cam;
@@ -761,14 +761,13 @@ static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 
-static const struct file_operations zr364xx_fops = {
+static const struct v4l2_file_operations zr364xx_fops = {
         .owner = THIS_MODULE,
         .open = zr364xx_open,
         .release = zr364xx_release,
         .read = zr364xx_read,
         .mmap = zr364xx_mmap,
         .ioctl = video_ioctl2,
-        .llseek = no_llseek,
 };
 
 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
@@ -894,7 +893,6 @@ static void zr364xx_disconnect(struct usb_interface *intf)
 {
         struct zr364xx_camera *cam = usb_get_intfdata(intf);
         usb_set_intfdata(intf, NULL);
-        dev_set_drvdata(&intf->dev, NULL);
         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
         if (cam->vdev)
                 video_unregister_device(cam->vdev);
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 3d067c35185d..45b1f430685f 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -145,7 +145,7 @@ struct mmc_blk_request {
 static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
 {
         int err;
-        u32 blocks;
+        __be32 blocks;
 
         struct mmc_request mrq;
         struct mmc_command cmd;
@@ -204,9 +204,24 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
         if (cmd.error || data.error)
                 return (u32)-1;
 
-        blocks = ntohl(blocks);
+        return ntohl(blocks);
+}
+
+static u32 get_card_status(struct mmc_card *card, struct request *req)
+{
+        struct mmc_command cmd;
+        int err;
 
-        return blocks;
+        memset(&cmd, 0, sizeof(struct mmc_command));
+        cmd.opcode = MMC_SEND_STATUS;
+        if (!mmc_host_is_spi(card->host))
+                cmd.arg = card->rca << 16;
+        cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
+        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        if (err)
+                printk(KERN_ERR "%s: error %d sending status comand",
+                       req->rq_disk->disk_name, err);
+        return cmd.resp[0];
 }
 
 static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
@@ -214,13 +229,13 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
         struct mmc_blk_request brq;
-        int ret = 1;
+        int ret = 1, disable_multi = 0;
 
         mmc_claim_host(card->host);
 
         do {
                 struct mmc_command cmd;
-                u32 readcmd, writecmd;
+                u32 readcmd, writecmd, status = 0;
 
                 memset(&brq, 0, sizeof(struct mmc_blk_request));
                 brq.mrq.cmd = &brq.cmd;
@@ -236,6 +251,14 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
                 brq.data.blocks = req->nr_sectors;
 
+                /*
+                 * After a read error, we redo the request one sector at a time
+                 * in order to accurately determine which sectors can be read
+                 * successfully.
+                 */
+                if (disable_multi && brq.data.blocks > 1)
+                        brq.data.blocks = 1;
+
                 if (brq.data.blocks > 1) {
                         /* SPI multiblock writes terminate using a special
                          * token, not a STOP_TRANSMISSION request.
@@ -264,6 +287,25 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 brq.data.sg = mq->sg;
                 brq.data.sg_len = mmc_queue_map_sg(mq);
 
+                /*
+                 * Adjust the sg list so it is the same size as the
+                 * request.
+                 */
+                if (brq.data.blocks != req->nr_sectors) {
+                        int i, data_size = brq.data.blocks << 9;
+                        struct scatterlist *sg;
+
+                        for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) {
+                                data_size -= sg->length;
+                                if (data_size <= 0) {
+                                        sg->length += data_size;
+                                        i++;
+                                        break;
+                                }
+                        }
+                        brq.data.sg_len = i;
+                }
+
                 mmc_queue_bounce_pre(mq);
 
                 mmc_wait_for_req(card->host, &brq.mrq);
@@ -275,19 +317,40 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                  * until later as we need to wait for the card to leave
                  * programming mode even when things go wrong.
                  */
+                if (brq.cmd.error || brq.data.error || brq.stop.error) {
+                        if (brq.data.blocks > 1 && rq_data_dir(req) == READ) {
+                                /* Redo read one sector at a time */
+                                printk(KERN_WARNING "%s: retrying using single "
+                                       "block read\n", req->rq_disk->disk_name);
+                                disable_multi = 1;
+                                continue;
+                        }
+                        status = get_card_status(card, req);
+                }
+
                 if (brq.cmd.error) {
-                        printk(KERN_ERR "%s: error %d sending read/write command\n",
-                               req->rq_disk->disk_name, brq.cmd.error);
+                        printk(KERN_ERR "%s: error %d sending read/write "
+                               "command, response %#x, card status %#x\n",
+                               req->rq_disk->disk_name, brq.cmd.error,
+                               brq.cmd.resp[0], status);
                 }
 
                 if (brq.data.error) {
-                        printk(KERN_ERR "%s: error %d transferring data\n",
-                               req->rq_disk->disk_name, brq.data.error);
+                        if (brq.data.error == -ETIMEDOUT && brq.mrq.stop)
+                                /* 'Stop' response contains card status */
+                                status = brq.mrq.stop->resp[0];
+                        printk(KERN_ERR "%s: error %d transferring data,"
+                               " sector %u, nr %u, card status %#x\n",
+                               req->rq_disk->disk_name, brq.data.error,
+                               (unsigned)req->sector,
+                               (unsigned)req->nr_sectors, status);
                 }
 
                 if (brq.stop.error) {
-                        printk(KERN_ERR "%s: error %d sending stop command\n",
-                               req->rq_disk->disk_name, brq.stop.error);
+                        printk(KERN_ERR "%s: error %d sending stop command, "
+                               "response %#x, card status %#x\n",
+                               req->rq_disk->disk_name, brq.stop.error,
+                               brq.stop.resp[0], status);
                 }
 
                 if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
@@ -320,8 +383,20 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 #endif
                 }
 
-                if (brq.cmd.error || brq.data.error || brq.stop.error)
+                if (brq.cmd.error || brq.stop.error || brq.data.error) {
+                        if (rq_data_dir(req) == READ) {
+                                /*
+                                 * After an error, we redo I/O one sector at a
+                                 * time, so we only reach here after trying to
+                                 * read a single sector.
+                                 */
+                                spin_lock_irq(&md->lock);
+                                ret = __blk_end_request(req, -EIO, brq.data.blksz);
+                                spin_unlock_irq(&md->lock);
+                                continue;
+                        }
                         goto cmd_err;
+                }
 
                 /*
                  * A block was successfully transferred.
@@ -343,25 +418,20 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
          * If the card is not SD, we can still ok written sectors
          * as reported by the controller (which might be less than
          * the real number of written sectors, but never more).
-         *
-         * For reads we just fail the entire chunk as that should
-         * be safe in all cases.
          */
-        if (rq_data_dir(req) != READ) {
-                if (mmc_card_sd(card)) {
-                        u32 blocks;
+        if (mmc_card_sd(card)) {
+                u32 blocks;
 
-                        blocks = mmc_sd_num_wr_blocks(card);
-                        if (blocks != (u32)-1) {
-                                spin_lock_irq(&md->lock);
-                                ret = __blk_end_request(req, 0, blocks << 9);
-                                spin_unlock_irq(&md->lock);
-                        }
-                } else {
+                blocks = mmc_sd_num_wr_blocks(card);
+                if (blocks != (u32)-1) {
                         spin_lock_irq(&md->lock);
-                        ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
+                        ret = __blk_end_request(req, 0, blocks << 9);
                         spin_unlock_irq(&md->lock);
                 }
+        } else {
+                spin_lock_irq(&md->lock);
+                ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
+                spin_unlock_irq(&md->lock);
         }
 
         mmc_release_host(card->host);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index f7284b905eb3..df6ce4a06cf3 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -20,6 +20,7 @@
 #include <linux/err.h>
 #include <linux/leds.h>
 #include <linux/scatterlist.h>
+#include <linux/log2.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -448,6 +449,80 @@ void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
         mmc_set_ios(host);
 }
 
+/**
+ * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
+ * @vdd:        voltage (mV)
+ * @low_bits:   prefer low bits in boundary cases
+ *
+ * This function returns the OCR bit number according to the provided @vdd
+ * value. If conversion is not possible a negative errno value returned.
+ *
+ * Depending on the @low_bits flag the function prefers low or high OCR bits
+ * on boundary voltages. For example,
+ * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
+ * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
+ *
+ * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
+ */
+static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
+{
+        const int max_bit = ilog2(MMC_VDD_35_36);
+        int bit;
+
+        if (vdd < 1650 || vdd > 3600)
+                return -EINVAL;
+
+        if (vdd >= 1650 && vdd <= 1950)
+                return ilog2(MMC_VDD_165_195);
+
+        if (low_bits)
+                vdd -= 1;
+
+        /* Base 2000 mV, step 100 mV, bit's base 8. */
+        bit = (vdd - 2000) / 100 + 8;
+        if (bit > max_bit)
+                return max_bit;
+        return bit;
+}
+
+/**
+ * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
+ * @vdd_min:    minimum voltage value (mV)
+ * @vdd_max:    maximum voltage value (mV)
+ *
+ * This function returns the OCR mask bits according to the provided @vdd_min
+ * and @vdd_max values. If conversion is not possible the function returns 0.
+ *
+ * Notes wrt boundary cases:
+ * This function sets the OCR bits for all boundary voltages, for example
+ * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
+ * MMC_VDD_34_35 mask.
+ */
+u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
+{
+        u32 mask = 0;
+
+        if (vdd_max < vdd_min)
+                return 0;
+
+        /* Prefer high bits for the boundary vdd_max values. */
+        vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
+        if (vdd_max < 0)
+                return 0;
+
+        /* Prefer low bits for the boundary vdd_min values. */
+        vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
+        if (vdd_min < 0)
+                return 0;
+
+        /* Fill the mask, from max bit to min bit. */
+        while (vdd_max >= vdd_min)
+                mask |= 1 << vdd_max--;
+
+        return mask;
+}
+EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
+
 /*
  * Mask off any voltages we don't support and select
  * the lowest voltage
@@ -467,6 +542,8 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
                 host->ios.vdd = bit;
                 mmc_set_ios(host);
         } else {
+                pr_warning("%s: host doesn't support card's voltages\n",
+                                mmc_hostname(host));
                 ocr = 0;
         }
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index fdd7c760be8c..c232d11a7ed4 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -434,13 +434,24 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
          * Activate wide bus (if supported).
          */
         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
-                (host->caps & MMC_CAP_4_BIT_DATA)) {
+            (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
+                unsigned ext_csd_bit, bus_width;
+
+                if (host->caps & MMC_CAP_8_BIT_DATA) {
+                        ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
+                        bus_width = MMC_BUS_WIDTH_8;
+                } else {
+                        ext_csd_bit = EXT_CSD_BUS_WIDTH_4;
+                        bus_width = MMC_BUS_WIDTH_4;
+                }
+
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4);
+                                 EXT_CSD_BUS_WIDTH, ext_csd_bit);
+
                 if (err)
                         goto free_card;
 
-                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+                mmc_set_bus_width(card->host, bus_width);
         }
 
         if (!oldcard)
@@ -624,4 +635,3 @@ err:
 
         return err;
 }
-
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index c794cc5ce442..f4853288bbb1 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -19,6 +19,9 @@ obj-$(CONFIG_MMC_AT91)		+= at91_mci.o
 obj-$(CONFIG_MMC_ATMELMCI)      += atmel-mci.o
 obj-$(CONFIG_MMC_TIFM_SD)       += tifm_sd.o
 obj-$(CONFIG_MMC_SPI)           += mmc_spi.o
+ifeq ($(CONFIG_OF),y)
+obj-$(CONFIG_MMC_SPI)           += of_mmc_spi.o
+endif
 obj-$(CONFIG_MMC_S3C)           += s3cmci.o
 obj-$(CONFIG_MMC_SDRICOH_CS)    += sdricoh_cs.o
 obj-$(CONFIG_MMC_TMIO)          += tmio_mmc.o
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 1f8b5b36222c..e556d42cc45a 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -1088,6 +1088,8 @@ static int __init at91_mci_probe(struct platform_device *pdev)
                 goto fail0;
         }
 
+        setup_timer(&host->timer, at91_timeout_timer, (unsigned long)host);
+
         platform_set_drvdata(pdev, mmc);
 
         /*
@@ -1101,8 +1103,6 @@ static int __init at91_mci_probe(struct platform_device *pdev)
 
         mmc_add_host(mmc);
 
-        setup_timer(&host->timer, at91_timeout_timer, (unsigned long)host);
-
         /*
          * monitor card insertion/removal if we can
          */
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index ad00e1632317..87e211df68ac 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1285,7 +1285,7 @@ static int mmc_spi_probe(struct spi_device *spi)
         /* Platform data is used to hook up things like card sensing
          * and power switching gpios.
          */
-        host->pdata = spi->dev.platform_data;
+        host->pdata = mmc_spi_get_pdata(spi);
         if (host->pdata)
                 mmc->ocr_avail = host->pdata->ocr_mask;
         if (!mmc->ocr_avail) {
@@ -1368,6 +1368,7 @@ fail_glue_init:
 
 fail_nobuf1:
         mmc_free_host(mmc);
+        mmc_spi_put_pdata(spi);
         dev_set_drvdata(&spi->dev, NULL);
 
 nomem:
@@ -1402,6 +1403,7 @@ static int __devexit mmc_spi_remove(struct spi_device *spi)
 
                 spi->max_speed_hz = mmc->f_max;
                 mmc_free_host(mmc);
+                mmc_spi_put_pdata(spi);
                 dev_set_drvdata(&spi->dev, NULL);
         }
         return 0;
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
new file mode 100644
index 000000000000..fb2921f8099d
--- /dev/null
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -0,0 +1,149 @@
+/*
+ * OpenFirmware bindings for the MMC-over-SPI driver
+ *
+ * Copyright (c) MontaVista Software, Inc. 2008.
+ *
+ * Author: Anton Vorontsov <avorontsov@ru.mvista.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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/gpio.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/mmc_spi.h>
+#include <linux/mmc/core.h>
+#include <linux/mmc/host.h>
+
+enum {
+        CD_GPIO = 0,
+        WP_GPIO,
+        NUM_GPIOS,
+};
+
+struct of_mmc_spi {
+        int gpios[NUM_GPIOS];
+        bool alow_gpios[NUM_GPIOS];
+        struct mmc_spi_platform_data pdata;
+};
+
+static struct of_mmc_spi *to_of_mmc_spi(struct device *dev)
+{
+        return container_of(dev->platform_data, struct of_mmc_spi, pdata);
+}
+
+static int of_mmc_spi_read_gpio(struct device *dev, int gpio_num)
+{
+        struct of_mmc_spi *oms = to_of_mmc_spi(dev);
+        bool active_low = oms->alow_gpios[gpio_num];
+        bool value = gpio_get_value(oms->gpios[gpio_num]);
+
+        return active_low ^ value;
+}
+
+static int of_mmc_spi_get_cd(struct device *dev)
+{
+        return of_mmc_spi_read_gpio(dev, CD_GPIO);
+}
+
+static int of_mmc_spi_get_ro(struct device *dev)
+{
+        return of_mmc_spi_read_gpio(dev, WP_GPIO);
+}
+
+struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
+{
+        struct device *dev = &spi->dev;
+        struct device_node *np = dev_archdata_get_node(&dev->archdata);
+        struct of_mmc_spi *oms;
+        const u32 *voltage_ranges;
+        int num_ranges;
+        int i;
+        int ret = -EINVAL;
+
+        if (dev->platform_data || !np)
+                return dev->platform_data;
+
+        oms = kzalloc(sizeof(*oms), GFP_KERNEL);
+        if (!oms)
+                return NULL;
+
+        voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges);
+        num_ranges = num_ranges / sizeof(*voltage_ranges) / 2;
+        if (!voltage_ranges || !num_ranges) {
+                dev_err(dev, "OF: voltage-ranges unspecified\n");
+                goto err_ocr;
+        }
+
+        for (i = 0; i < num_ranges; i++) {
+                const int j = i * 2;
+                u32 mask;
+
+                mask = mmc_vddrange_to_ocrmask(voltage_ranges[j],
+                                               voltage_ranges[j + 1]);
+                if (!mask) {
+                        ret = -EINVAL;
+                        dev_err(dev, "OF: voltage-range #%d is invalid\n", i);
+                        goto err_ocr;
+                }
+                oms->pdata.ocr_mask |= mask;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(oms->gpios); i++) {
+                enum of_gpio_flags gpio_flags;
+
+                oms->gpios[i] = of_get_gpio_flags(np, i, &gpio_flags);
+                if (!gpio_is_valid(oms->gpios[i]))
+                        continue;
+
+                ret = gpio_request(oms->gpios[i], dev->bus_id);
+                if (ret < 0) {
+                        oms->gpios[i] = -EINVAL;
+                        continue;
+                }
+
+                if (gpio_flags & OF_GPIO_ACTIVE_LOW)
+                        oms->alow_gpios[i] = true;
+        }
+
+        if (gpio_is_valid(oms->gpios[CD_GPIO]))
+                oms->pdata.get_cd = of_mmc_spi_get_cd;
+        if (gpio_is_valid(oms->gpios[WP_GPIO]))
+                oms->pdata.get_ro = of_mmc_spi_get_ro;
+
+        /* We don't support interrupts yet, let's poll. */
+        oms->pdata.caps |= MMC_CAP_NEEDS_POLL;
+
+        dev->platform_data = &oms->pdata;
+        return dev->platform_data;
+err_ocr:
+        kfree(oms);
+        return NULL;
+}
+EXPORT_SYMBOL(mmc_spi_get_pdata);
+
+void mmc_spi_put_pdata(struct spi_device *spi)
+{
+        struct device *dev = &spi->dev;
+        struct device_node *np = dev_archdata_get_node(&dev->archdata);
+        struct of_mmc_spi *oms = to_of_mmc_spi(dev);
+        int i;
+
+        if (!dev->platform_data || !np)
+                return;
+
+        for (i = 0; i < ARRAY_SIZE(oms->gpios); i++) {
+                if (gpio_is_valid(oms->gpios[i]))
+                        gpio_free(oms->gpios[i]);
+        }
+        kfree(oms);
+        dev->platform_data = NULL;
+}
+EXPORT_SYMBOL(mmc_spi_put_pdata);
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index f88cc7406354..3c5483b75da4 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -283,7 +283,7 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
                 return 0;
 
         DCSR(host->dma) = 0;
-        dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_len,
+        dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
                      host->dma_dir);
 
         if (stat & STAT_READ_TIME_OUT)
diff --git a/drivers/mmc/host/ricoh_mmc.c b/drivers/mmc/host/ricoh_mmc.c
index a16d7609e4ee..be9e7b32b34e 100644
--- a/drivers/mmc/host/ricoh_mmc.c
+++ b/drivers/mmc/host/ricoh_mmc.c
@@ -11,9 +11,10 @@
 
 /*
  * This is a conceptually ridiculous driver, but it is required by the way
- * the Ricoh multi-function R5C832 works. This chip implements firewire
- * and four different memory card controllers. Two of those controllers are
- * an SDHCI controller and a proprietary MMC controller. The linux SDHCI
+ * the Ricoh multi-function chips (R5CXXX) work. These chips implement
+ * the four main memory card controllers (SD, MMC, MS, xD) and one or both
+ * of cardbus or firewire. It happens that they implement SD and MMC
+ * support as separate controllers (and PCI functions). The linux SDHCI
  * driver supports MMC cards but the chip detects MMC cards in hardware
  * and directs them to the MMC controller - so the SDHCI driver never sees
  * them. To get around this, we must disable the useless MMC controller.
@@ -21,8 +22,10 @@
  * a detection event occurs immediately, even if the MMC card is already
  * in the reader.
  *
- * The relevant registers live on the firewire function, so this is unavoidably
- * ugly. Such is life.
+ * It seems to be the case that the relevant PCI registers to deactivate the
+ * MMC controller live on PCI function 0, which might be the cardbus controller
+ * or the firewire controller, depending on the particular chip in question. As
+ * such, it makes what this driver has to do unavoidably ugly. Such is life.
  */
 
 #include <linux/pci.h>
@@ -143,6 +146,7 @@ static int __devinit ricoh_mmc_probe(struct pci_dev *pdev,
                 pci_get_device(PCI_VENDOR_ID_RICOH,
                         PCI_DEVICE_ID_RICOH_RL5C476, fw_dev))) {
                 if (PCI_SLOT(pdev->devfn) == PCI_SLOT(fw_dev->devfn) &&
+                    PCI_FUNC(fw_dev->devfn) == 0 &&
                     pdev->bus == fw_dev->bus) {
                         if (ricoh_mmc_disable(fw_dev) != 0)
                                 return -ENODEV;
@@ -160,6 +164,7 @@ static int __devinit ricoh_mmc_probe(struct pci_dev *pdev,
             (fw_dev = pci_get_device(PCI_VENDOR_ID_RICOH,
                                         PCI_DEVICE_ID_RICOH_R5C832, fw_dev))) {
                 if (PCI_SLOT(pdev->devfn) == PCI_SLOT(fw_dev->devfn) &&
+                    PCI_FUNC(fw_dev->devfn) == 0 &&
                     pdev->bus == fw_dev->bus) {
                         if (ricoh_mmc_disable(fw_dev) != 0)
                                 return -ENODEV;
@@ -172,7 +177,7 @@ static int __devinit ricoh_mmc_probe(struct pci_dev *pdev,
 
         if (!ctrlfound) {
                 printk(KERN_WARNING DRIVER_NAME
-                       ": Main firewire function not found. Cannot disable controller.\n");
+                       ": Main Ricoh function not found. Cannot disable controller.\n");
                 return -ENODEV;
         }
 
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 9bd7026b0021..f07255cb17ee 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -545,7 +545,7 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
         }
 
         addr = pci_resource_start(pdev, bar);
-        host->ioaddr = ioremap_nocache(addr, pci_resource_len(pdev, bar));
+        host->ioaddr = pci_ioremap_bar(pdev, bar);
         if (!host->ioaddr) {
                 dev_err(&pdev->dev, "failed to remap registers\n");
                 goto release;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 4d010a984bed..6b2d1f99af67 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -30,6 +30,11 @@
 #define DBG(f, x...) \
         pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
 
+#if defined(CONFIG_LEDS_CLASS) || (defined(CONFIG_LEDS_CLASS_MODULE) && \
+        defined(CONFIG_MMC_SDHCI_MODULE))
+#define SDHCI_USE_LEDS_CLASS
+#endif
+
 static unsigned int debug_quirks = 0;
 
 static void sdhci_prepare_data(struct sdhci_host *, struct mmc_data *);
@@ -149,7 +154,7 @@ static void sdhci_deactivate_led(struct sdhci_host *host)
         writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
 }
 
-#ifdef CONFIG_LEDS_CLASS
+#ifdef SDHCI_USE_LEDS_CLASS
 static void sdhci_led_control(struct led_classdev *led,
         enum led_brightness brightness)
 {
@@ -994,7 +999,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         WARN_ON(host->mrq != NULL);
 
-#ifndef CONFIG_LEDS_CLASS
+#ifndef SDHCI_USE_LEDS_CLASS
         sdhci_activate_led(host);
 #endif
 
@@ -1201,7 +1206,7 @@ static void sdhci_tasklet_finish(unsigned long param)
         host->cmd = NULL;
         host->data = NULL;
 
-#ifndef CONFIG_LEDS_CLASS
+#ifndef SDHCI_USE_LEDS_CLASS
         sdhci_deactivate_led(host);
 #endif
 
@@ -1717,7 +1722,7 @@ int sdhci_add_host(struct sdhci_host *host)
         sdhci_dumpregs(host);
 #endif
 
-#ifdef CONFIG_LEDS_CLASS
+#ifdef SDHCI_USE_LEDS_CLASS
         host->led.name = mmc_hostname(mmc);
         host->led.brightness = LED_OFF;
         host->led.default_trigger = mmc_hostname(mmc);
@@ -1739,7 +1744,7 @@ int sdhci_add_host(struct sdhci_host *host)
 
         return 0;
 
-#ifdef CONFIG_LEDS_CLASS
+#ifdef SDHCI_USE_LEDS_CLASS
 reset:
         sdhci_reset(host, SDHCI_RESET_ALL);
         free_irq(host->irq, host);
@@ -1775,7 +1780,7 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
 
         mmc_remove_host(host->mmc);
 
-#ifdef CONFIG_LEDS_CLASS
+#ifdef SDHCI_USE_LEDS_CLASS
         led_classdev_unregister(&host->led);
 #endif
 
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 31f4b1528e76..3efba2363941 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -220,7 +220,7 @@ struct sdhci_host {
         struct mmc_host         *mmc;           /* MMC structure */
         u64                     dma_mask;       /* custom DMA mask */
 
-#ifdef CONFIG_LEDS_CLASS
+#if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
         struct led_classdev     led;            /* LED control */
 #endif
 
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index 1df44d966bdb..cb41e9c3ac07 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -82,6 +82,8 @@ static struct pcmcia_device_id pcmcia_ids[] = {
         /* vendor and device strings followed by their crc32 hashes */
         PCMCIA_DEVICE_PROD_ID12("RICOH", "Bay1Controller", 0xd9f522ed,
                                 0xc3901202),
+        PCMCIA_DEVICE_PROD_ID12("RICOH", "Bay Controller", 0xd9f522ed,
+                                0xace80909),
         PCMCIA_DEVICE_NULL,
 };
 
@@ -463,7 +465,7 @@ static int sdricoh_init_mmc(struct pci_dev *pci_dev,
 
 err:
         if (iobase)
-                iounmap(iobase);
+                pci_iounmap(pci_dev, iobase);
         if (mmc)
                 mmc_free_host(mmc);
 
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 95430b81ec11..6a7a61904833 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -224,7 +224,7 @@ static inline void tmio_mmc_data_irq(struct tmio_mmc_host *host)
 {
         void __iomem *ctl = host->ctl;
         struct mmc_data *data = host->data;
-        struct mmc_command *stop = data->stop;
+        struct mmc_command *stop;
 
         host->data = NULL;
 
@@ -232,6 +232,7 @@ static inline void tmio_mmc_data_irq(struct tmio_mmc_host *host)
                 pr_debug("Spurious data end IRQ\n");
                 return;
         }
+        stop = data->stop;
 
         /* FIXME - return correct transfer count on errors */
         if (!data->error)
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index c7630a228310..ba0bd3d5775b 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -815,19 +815,20 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         if (err)
                 goto out_free;
 
+        err = -ENOMEM;
         ubi->peb_buf1 = vmalloc(ubi->peb_size);
         if (!ubi->peb_buf1)
                 goto out_free;
 
         ubi->peb_buf2 = vmalloc(ubi->peb_size);
         if (!ubi->peb_buf2)
-                 goto out_free;
+                goto out_free;
 
 #ifdef CONFIG_MTD_UBI_DEBUG
         mutex_init(&ubi->dbg_buf_mutex);
         ubi->dbg_peb_buf = vmalloc(ubi->peb_size);
         if (!ubi->dbg_peb_buf)
-                 goto out_free;
+                goto out_free;
 #endif
 
         err = attach_by_scanning(ubi);
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index b30a0b83d7f1..98cf31ed0814 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -721,7 +721,8 @@ static int rename_volumes(struct ubi_device *ubi,
                  * It seems we need to remove volume with name @re->new_name,
                  * if it exists.
                  */
-                desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, UBI_EXCLUSIVE);
+                desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name,
+                                          UBI_EXCLUSIVE);
                 if (IS_ERR(desc)) {
                         err = PTR_ERR(desc);
                         if (err == -ENODEV)
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 78e914d23ece..13777e5beac9 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -27,11 +27,11 @@
 #define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
 
 #define ubi_assert(expr)  do {                                               \
-        if (unlikely(!(expr))) {                                             \
-                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
-                       __func__, __LINE__, current->pid);                    \
-                ubi_dbg_dump_stack();                                        \
-        }                                                                    \
+        if (unlikely(!(expr))) {                                             \
+                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
+                       __func__, __LINE__, current->pid);                    \
+                ubi_dbg_dump_stack();                                        \
+        }                                                                    \
 } while (0)
 
 #define dbg_msg(fmt, ...)                                    \
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index d8966bae0e0b..048a606cebde 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -504,12 +504,9 @@ static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
         if (!vid_hdr)
                 return -ENOMEM;
 
-        mutex_lock(&ubi->buf_mutex);
-
 retry:
         new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
         if (new_pnum < 0) {
-                mutex_unlock(&ubi->buf_mutex);
                 ubi_free_vid_hdr(ubi, vid_hdr);
                 return new_pnum;
         }
@@ -529,20 +526,23 @@ retry:
                 goto write_error;
 
         data_size = offset + len;
+        mutex_lock(&ubi->buf_mutex);
         memset(ubi->peb_buf1 + offset, 0xFF, len);
 
         /* Read everything before the area where the write failure happened */
         if (offset > 0) {
                 err = ubi_io_read_data(ubi, ubi->peb_buf1, pnum, 0, offset);
                 if (err && err != UBI_IO_BITFLIPS)
-                        goto out_put;
+                        goto out_unlock;
         }
 
         memcpy(ubi->peb_buf1 + offset, buf, len);
 
         err = ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size);
-        if (err)
+        if (err) {
+                mutex_unlock(&ubi->buf_mutex);
                 goto write_error;
+        }
 
         mutex_unlock(&ubi->buf_mutex);
         ubi_free_vid_hdr(ubi, vid_hdr);
@@ -553,8 +553,9 @@ retry:
         ubi_msg("data was successfully recovered");
         return 0;
 
-out_put:
+out_unlock:
         mutex_unlock(&ubi->buf_mutex);
+out_put:
         ubi_wl_put_peb(ubi, new_pnum, 1);
         ubi_free_vid_hdr(ubi, vid_hdr);
         return err;
@@ -567,7 +568,6 @@ write_error:
         ubi_warn("failed to write to PEB %d", new_pnum);
         ubi_wl_put_peb(ubi, new_pnum, 1);
         if (++tries > UBI_IO_RETRIES) {
-                mutex_unlock(&ubi->buf_mutex);
                 ubi_free_vid_hdr(ubi, vid_hdr);
                 return err;
         }
@@ -949,10 +949,14 @@ write_error:
  * This function copies logical eraseblock from physical eraseblock @from to
  * physical eraseblock @to. The @vid_hdr buffer may be changed by this
  * function. Returns:
- *   o %0  in case of success;
- *   o %1 if the operation was canceled and should be tried later (e.g.,
- *     because a bit-flip was detected at the target PEB);
- *   o %2 if the volume is being deleted and this LEB should not be moved.
+ *   o %0 in case of success;
+ *   o %1 if the operation was canceled because the volume is being deleted
+ *        or because the PEB was put meanwhile;
+ *   o %2 if the operation was canceled because there was a write error to the
+ *        target PEB;
+ *   o %-EAGAIN if the operation was canceled because a bit-flip was detected
+ *     in the target PEB;
+ *   o a negative error code in case of failure.
  */
 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                      struct ubi_vid_hdr *vid_hdr)
@@ -978,7 +982,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
         /*
          * Note, we may race with volume deletion, which means that the volume
          * this logical eraseblock belongs to might be being deleted. Since the
-         * volume deletion unmaps all the volume's logical eraseblocks, it will
+         * volume deletion un-maps all the volume's logical eraseblocks, it will
          * be locked in 'ubi_wl_put_peb()' and wait for the WL worker to finish.
          */
         vol = ubi->volumes[idx];
@@ -986,7 +990,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                 /* No need to do further work, cancel */
                 dbg_eba("volume %d is being removed, cancel", vol_id);
                 spin_unlock(&ubi->volumes_lock);
-                return 2;
+                return 1;
         }
         spin_unlock(&ubi->volumes_lock);
 
@@ -1023,7 +1027,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
 
         /*
          * OK, now the LEB is locked and we can safely start moving it. Since
-         * this function utilizes thie @ubi->peb1_buf buffer which is shared
+         * this function utilizes the @ubi->peb1_buf buffer which is shared
          * with some other functions, so lock the buffer by taking the
          * @ubi->buf_mutex.
          */
@@ -1068,8 +1072,11 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 
         err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
-        if (err)
+        if (err) {
+                if (err == -EIO)
+                        err = 2;
                 goto out_unlock_buf;
+        }
 
         cond_resched();
 
@@ -1079,14 +1086,17 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                 if (err != UBI_IO_BITFLIPS)
                         ubi_warn("cannot read VID header back from PEB %d", to);
                 else
-                        err = 1;
+                        err = -EAGAIN;
                 goto out_unlock_buf;
         }
 
         if (data_size > 0) {
                 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
-                if (err)
+                if (err) {
+                        if (err == -EIO)
+                                err = 2;
                         goto out_unlock_buf;
+                }
 
                 cond_resched();
 
@@ -1101,15 +1111,16 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
                                 ubi_warn("cannot read data back from PEB %d",
                                          to);
                         else
-                                err = 1;
+                                err = -EAGAIN;
                         goto out_unlock_buf;
                 }
 
                 cond_resched();
 
                 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
-                        ubi_warn("read data back from PEB %d - it is different",
-                                 to);
+                        ubi_warn("read data back from PEB %d and it is "
+                                 "different", to);
+                        err = -EINVAL;
                         goto out_unlock_buf;
                 }
         }
diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 2fb64be44f1b..a74118c05745 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -637,8 +637,6 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
 
         dbg_io("read EC header from PEB %d", pnum);
         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
-        if (UBI_IO_DEBUG)
-                verbose = 1;
 
         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
         if (err) {
@@ -685,6 +683,9 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                         if (verbose)
                                 ubi_warn("no EC header found at PEB %d, "
                                          "only 0xFF bytes", pnum);
+                        else if (UBI_IO_DEBUG)
+                                dbg_msg("no EC header found at PEB %d, "
+                                        "only 0xFF bytes", pnum);
                         return UBI_IO_PEB_EMPTY;
                 }
 
@@ -696,7 +697,9 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad magic number at PEB %d: %08x instead of "
                                  "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
                         ubi_dbg_dump_ec_hdr(ec_hdr);
-                }
+                } else if (UBI_IO_DEBUG)
+                        dbg_msg("bad magic number at PEB %d: %08x instead of "
+                                "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
                 return UBI_IO_BAD_EC_HDR;
         }
 
@@ -708,7 +711,9 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad EC header CRC at PEB %d, calculated "
                                  "%#08x, read %#08x", pnum, crc, hdr_crc);
                         ubi_dbg_dump_ec_hdr(ec_hdr);
-                }
+                } else if (UBI_IO_DEBUG)
+                        dbg_msg("bad EC header CRC at PEB %d, calculated "
+                                "%#08x, read %#08x", pnum, crc, hdr_crc);
                 return UBI_IO_BAD_EC_HDR;
         }
 
@@ -912,8 +917,6 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
 
         dbg_io("read VID header from PEB %d", pnum);
         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
-        if (UBI_IO_DEBUG)
-                verbose = 1;
 
         p = (char *)vid_hdr - ubi->vid_hdr_shift;
         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
@@ -960,6 +963,9 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                         if (verbose)
                                 ubi_warn("no VID header found at PEB %d, "
                                          "only 0xFF bytes", pnum);
+                        else if (UBI_IO_DEBUG)
+                                dbg_msg("no VID header found at PEB %d, "
+                                        "only 0xFF bytes", pnum);
                         return UBI_IO_PEB_FREE;
                 }
 
@@ -971,7 +977,9 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad magic number at PEB %d: %08x instead of "
                                  "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
                         ubi_dbg_dump_vid_hdr(vid_hdr);
-                }
+                } else if (UBI_IO_DEBUG)
+                        dbg_msg("bad magic number at PEB %d: %08x instead of "
+                                "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
                 return UBI_IO_BAD_VID_HDR;
         }
 
@@ -983,7 +991,9 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                         ubi_warn("bad CRC at PEB %d, calculated %#08x, "
                                  "read %#08x", pnum, crc, hdr_crc);
                         ubi_dbg_dump_vid_hdr(vid_hdr);
-                }
+                } else if (UBI_IO_DEBUG)
+                        dbg_msg("bad CRC at PEB %d, calculated %#08x, "
+                                "read %#08x", pnum, crc, hdr_crc);
                 return UBI_IO_BAD_VID_HDR;
         }
 
@@ -1024,7 +1034,7 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
 
         err = paranoid_check_peb_ec_hdr(ubi, pnum);
         if (err)
-                return err > 0 ? -EINVAL: err;
+                return err > 0 ? -EINVAL : err;
 
         vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
         vid_hdr->version = UBI_VERSION;
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 1c3fa18c26a7..4a8ec485c91d 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -74,6 +74,13 @@
 #define UBI_IO_RETRIES 3
 
 /*
+ * Length of the protection queue. The length is effectively equivalent to the
+ * number of (global) erase cycles PEBs are protected from the wear-leveling
+ * worker.
+ */
+#define UBI_PROT_QUEUE_LEN 10
+
+/*
  * Error codes returned by the I/O sub-system.
  *
  * UBI_IO_PEB_EMPTY: the physical eraseblock is empty, i.e. it contains only
@@ -95,7 +102,8 @@ enum {
 
 /**
  * struct ubi_wl_entry - wear-leveling entry.
- * @rb: link in the corresponding RB-tree
+ * @u.rb: link in the corresponding (free/used) RB-tree
+ * @u.list: link in the protection queue
  * @ec: erase counter
  * @pnum: physical eraseblock number
  *
@@ -104,7 +112,10 @@ enum {
  * RB-trees. See WL sub-system for details.
  */
 struct ubi_wl_entry {
-        struct rb_node rb;
+        union {
+                struct rb_node rb;
+                struct list_head list;
+        } u;
         int ec;
         int pnum;
 };
@@ -288,7 +299,7 @@ struct ubi_wl_entry;
  * @beb_rsvd_level: normal level of PEBs reserved for bad PEB handling
  *
  * @autoresize_vol_id: ID of the volume which has to be auto-resized at the end
- *                     of UBI ititializetion
+ *                     of UBI initialization
  * @vtbl_slots: how many slots are available in the volume table
  * @vtbl_size: size of the volume table in bytes
  * @vtbl: in-RAM volume table copy
@@ -306,18 +317,17 @@ struct ubi_wl_entry;
  * @used: RB-tree of used physical eraseblocks
  * @free: RB-tree of free physical eraseblocks
  * @scrub: RB-tree of physical eraseblocks which need scrubbing
- * @prot: protection trees
- * @prot.pnum: protection tree indexed by physical eraseblock numbers
- * @prot.aec: protection tree indexed by absolute erase counter value
- * @wl_lock: protects the @used, @free, @prot, @lookuptbl, @abs_ec, @move_from,
- *           @move_to, @move_to_put @erase_pending, @wl_scheduled, and @works
- *           fields
+ * @pq: protection queue (contain physical eraseblocks which are temporarily
+ *      protected from the wear-leveling worker)
+ * @pq_head: protection queue head
+ * @wl_lock: protects the @used, @free, @pq, @pq_head, @lookuptbl, @move_from,
+ *           @move_to, @move_to_put @erase_pending, @wl_scheduled and @works
+ *           fields
  * @move_mutex: serializes eraseblock moves
- * @work_sem: sycnhronizes the WL worker with use tasks
+ * @work_sem: synchronizes the WL worker with use tasks
  * @wl_scheduled: non-zero if the wear-leveling was scheduled
  * @lookuptbl: a table to quickly find a &struct ubi_wl_entry object for any
  *             physical eraseblock
- * @abs_ec: absolute erase counter
  * @move_from: physical eraseblock from where the data is being moved
  * @move_to: physical eraseblock where the data is being moved to
  * @move_to_put: if the "to" PEB was put
@@ -351,11 +361,11 @@ struct ubi_wl_entry;
  *
  * @peb_buf1: a buffer of PEB size used for different purposes
  * @peb_buf2: another buffer of PEB size used for different purposes
- * @buf_mutex: proptects @peb_buf1 and @peb_buf2
+ * @buf_mutex: protects @peb_buf1 and @peb_buf2
  * @ckvol_mutex: serializes static volume checking when opening
- * @mult_mutex: serializes operations on multiple volumes, like re-nameing
+ * @mult_mutex: serializes operations on multiple volumes, like re-naming
  * @dbg_peb_buf: buffer of PEB size used for debugging
- * @dbg_buf_mutex: proptects @dbg_peb_buf
+ * @dbg_buf_mutex: protects @dbg_peb_buf
  */
 struct ubi_device {
         struct cdev cdev;
@@ -392,16 +402,13 @@ struct ubi_device {
         struct rb_root used;
         struct rb_root free;
         struct rb_root scrub;
-        struct {
-                struct rb_root pnum;
-                struct rb_root aec;
-        } prot;
+        struct list_head pq[UBI_PROT_QUEUE_LEN];
+        int pq_head;
         spinlock_t wl_lock;
         struct mutex move_mutex;
         struct rw_semaphore work_sem;
         int wl_scheduled;
         struct ubi_wl_entry **lookuptbl;
-        unsigned long long abs_ec;
         struct ubi_wl_entry *move_from;
         struct ubi_wl_entry *move_to;
         int move_to_put;
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index dcb6dac1dc54..14901cb82c18 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -22,7 +22,7 @@
  * UBI wear-leveling sub-system.
  *
  * This sub-system is responsible for wear-leveling. It works in terms of
- * physical* eraseblocks and erase counters and knows nothing about logical
+ * physical eraseblocks and erase counters and knows nothing about logical
  * eraseblocks, volumes, etc. From this sub-system's perspective all physical
  * eraseblocks are of two types - used and free. Used physical eraseblocks are
  * those that were "get" by the 'ubi_wl_get_peb()' function, and free physical
@@ -55,8 +55,39 @@
  *
  * As it was said, for the UBI sub-system all physical eraseblocks are either
  * "free" or "used". Free eraseblock are kept in the @wl->free RB-tree, while
- * used eraseblocks are kept in a set of different RB-trees: @wl->used,
- * @wl->prot.pnum, @wl->prot.aec, and @wl->scrub.
+ * used eraseblocks are kept in @wl->used or @wl->scrub RB-trees, or
+ * (temporarily) in the @wl->pq queue.
+ *
+ * When the WL sub-system returns a physical eraseblock, the physical
+ * eraseblock is protected from being moved for some "time". For this reason,
+ * the physical eraseblock is not directly moved from the @wl->free tree to the
+ * @wl->used tree. There is a protection queue in between where this
+ * physical eraseblock is temporarily stored (@wl->pq).
+ *
+ * All this protection stuff is needed because:
+ *  o we don't want to move physical eraseblocks just after we have given them
+ *    to the user; instead, we first want to let users fill them up with data;
+ *
+ *  o there is a chance that the user will put the physical eraseblock very
+ *    soon, so it makes sense not to move it for some time, but wait; this is
+ *    especially important in case of "short term" physical eraseblocks.
+ *
+ * Physical eraseblocks stay protected only for limited time. But the "time" is
+ * measured in erase cycles in this case. This is implemented with help of the
+ * protection queue. Eraseblocks are put to the tail of this queue when they
+ * are returned by the 'ubi_wl_get_peb()', and eraseblocks are removed from the
+ * head of the queue on each erase operation (for any eraseblock). So the
+ * length of the queue defines how may (global) erase cycles PEBs are protected.
+ *
+ * To put it differently, each physical eraseblock has 2 main states: free and
+ * used. The former state corresponds to the @wl->free tree. The latter state
+ * is split up on several sub-states:
+ * o the WL movement is allowed (@wl->used tree);
+ * o the WL movement is temporarily prohibited (@wl->pq queue);
+ * o scrubbing is needed (@wl->scrub tree).
+ *
+ * Depending on the sub-state, wear-leveling entries of the used physical
+ * eraseblocks may be kept in one of those structures.
  *
  * Note, in this implementation, we keep a small in-RAM object for each physical
  * eraseblock. This is surely not a scalable solution. But it appears to be good
@@ -70,9 +101,6 @@
  * target PEB, we pick a PEB with the highest EC if our PEB is "old" and we
  * pick target PEB with an average EC if our PEB is not very "old". This is a
  * room for future re-works of the WL sub-system.
- *
- * Note: the stuff with protection trees looks too complex and is difficult to
- * understand. Should be fixed.
  */
 
 #include <linux/slab.h>
@@ -85,14 +113,6 @@
 #define WL_RESERVED_PEBS 1
 
 /*
- * How many erase cycles are short term, unknown, and long term physical
- * eraseblocks protected.
- */
-#define ST_PROTECTION 16
-#define U_PROTECTION  10
-#define LT_PROTECTION 4
-
-/*
  * Maximum difference between two erase counters. If this threshold is
  * exceeded, the WL sub-system starts moving data from used physical
  * eraseblocks with low erase counter to free physical eraseblocks with high
@@ -120,64 +140,9 @@
 #define WL_MAX_FAILURES 32
 
 /**
- * struct ubi_wl_prot_entry - PEB protection entry.
- * @rb_pnum: link in the @wl->prot.pnum RB-tree
- * @rb_aec: link in the @wl->prot.aec RB-tree
- * @abs_ec: the absolute erase counter value when the protection ends
- * @e: the wear-leveling entry of the physical eraseblock under protection
- *
- * When the WL sub-system returns a physical eraseblock, the physical
- * eraseblock is protected from being moved for some "time". For this reason,
- * the physical eraseblock is not directly moved from the @wl->free tree to the
- * @wl->used tree. There is one more tree in between where this physical
- * eraseblock is temporarily stored (@wl->prot).
- *
- * All this protection stuff is needed because:
- *  o we don't want to move physical eraseblocks just after we have given them
- *    to the user; instead, we first want to let users fill them up with data;
- *
- *  o there is a chance that the user will put the physical eraseblock very
- *    soon, so it makes sense not to move it for some time, but wait; this is
- *    especially important in case of "short term" physical eraseblocks.
- *
- * Physical eraseblocks stay protected only for limited time. But the "time" is
- * measured in erase cycles in this case. This is implemented with help of the
- * absolute erase counter (@wl->abs_ec). When it reaches certain value, the
- * physical eraseblocks are moved from the protection trees (@wl->prot.*) to
- * the @wl->used tree.
- *
- * Protected physical eraseblocks are searched by physical eraseblock number
- * (when they are put) and by the absolute erase counter (to check if it is
- * time to move them to the @wl->used tree). So there are actually 2 RB-trees
- * storing the protected physical eraseblocks: @wl->prot.pnum and
- * @wl->prot.aec. They are referred to as the "protection" trees. The
- * first one is indexed by the physical eraseblock number. The second one is
- * indexed by the absolute erase counter. Both trees store
- * &struct ubi_wl_prot_entry objects.
- *
- * Each physical eraseblock has 2 main states: free and used. The former state
- * corresponds to the @wl->free tree. The latter state is split up on several
- * sub-states:
- * o the WL movement is allowed (@wl->used tree);
- * o the WL movement is temporarily prohibited (@wl->prot.pnum and
- * @wl->prot.aec trees);
- * o scrubbing is needed (@wl->scrub tree).
- *
- * Depending on the sub-state, wear-leveling entries of the used physical
- * eraseblocks may be kept in one of those trees.
- */
-struct ubi_wl_prot_entry {
-        struct rb_node rb_pnum;
-        struct rb_node rb_aec;
-        unsigned long long abs_ec;
-        struct ubi_wl_entry *e;
-};
-
-/**
  * struct ubi_work - UBI work description data structure.
  * @list: a link in the list of pending works
  * @func: worker function
- * @priv: private data of the worker function
  * @e: physical eraseblock to erase
  * @torture: if the physical eraseblock has to be tortured
  *
@@ -198,9 +163,11 @@ struct ubi_work {
 static int paranoid_check_ec(struct ubi_device *ubi, int pnum, int ec);
 static int paranoid_check_in_wl_tree(struct ubi_wl_entry *e,
                                      struct rb_root *root);
+static int paranoid_check_in_pq(struct ubi_device *ubi, struct ubi_wl_entry *e);
 #else
 #define paranoid_check_ec(ubi, pnum, ec) 0
 #define paranoid_check_in_wl_tree(e, root)
+#define paranoid_check_in_pq(ubi, e) 0
 #endif
 
 /**
@@ -220,7 +187,7 @@ static void wl_tree_add(struct ubi_wl_entry *e, struct rb_root *root)
                 struct ubi_wl_entry *e1;
 
                 parent = *p;
-                e1 = rb_entry(parent, struct ubi_wl_entry, rb);
+                e1 = rb_entry(parent, struct ubi_wl_entry, u.rb);
 
                 if (e->ec < e1->ec)
                         p = &(*p)->rb_left;
@@ -235,8 +202,8 @@ static void wl_tree_add(struct ubi_wl_entry *e, struct rb_root *root)
                 }
         }
 
-        rb_link_node(&e->rb, parent, p);
-        rb_insert_color(&e->rb, root);
+        rb_link_node(&e->u.rb, parent, p);
+        rb_insert_color(&e->u.rb, root);
 }
 
 /**
@@ -331,7 +298,7 @@ static int in_wl_tree(struct ubi_wl_entry *e, struct rb_root *root)
         while (p) {
                 struct ubi_wl_entry *e1;
 
-                e1 = rb_entry(p, struct ubi_wl_entry, rb);
+                e1 = rb_entry(p, struct ubi_wl_entry, u.rb);
 
                 if (e->pnum == e1->pnum) {
                         ubi_assert(e == e1);
@@ -355,50 +322,24 @@ static int in_wl_tree(struct ubi_wl_entry *e, struct rb_root *root)
 }
 
 /**
- * prot_tree_add - add physical eraseblock to protection trees.
+ * prot_queue_add - add physical eraseblock to the protection queue.
  * @ubi: UBI device description object
  * @e: the physical eraseblock to add
- * @pe: protection entry object to use
- * @abs_ec: absolute erase counter value when this physical eraseblock has
- * to be removed from the protection trees.
  *
- * @wl->lock has to be locked.
+ * This function adds @e to the tail of the protection queue @ubi->pq, where
+ * @e will stay for %UBI_PROT_QUEUE_LEN erase operations and will be
+ * temporarily protected from the wear-leveling worker. Note, @wl->lock has to
+ * be locked.
  */
-static void prot_tree_add(struct ubi_device *ubi, struct ubi_wl_entry *e,
-                          struct ubi_wl_prot_entry *pe, int abs_ec)
+static void prot_queue_add(struct ubi_device *ubi, struct ubi_wl_entry *e)
 {
-        struct rb_node **p, *parent = NULL;
-        struct ubi_wl_prot_entry *pe1;
-
-        pe->e = e;
-        pe->abs_ec = ubi->abs_ec + abs_ec;
-
-        p = &ubi->prot.pnum.rb_node;
-        while (*p) {
-                parent = *p;
-                pe1 = rb_entry(parent, struct ubi_wl_prot_entry, rb_pnum);
-
-                if (e->pnum < pe1->e->pnum)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&pe->rb_pnum, parent, p);
-        rb_insert_color(&pe->rb_pnum, &ubi->prot.pnum);
-
-        p = &ubi->prot.aec.rb_node;
-        parent = NULL;
-        while (*p) {
-                parent = *p;
-                pe1 = rb_entry(parent, struct ubi_wl_prot_entry, rb_aec);
+        int pq_tail = ubi->pq_head - 1;
 
-                if (pe->abs_ec < pe1->abs_ec)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&pe->rb_aec, parent, p);
-        rb_insert_color(&pe->rb_aec, &ubi->prot.aec);
+        if (pq_tail < 0)
+                pq_tail = UBI_PROT_QUEUE_LEN - 1;
+        ubi_assert(pq_tail >= 0 && pq_tail < UBI_PROT_QUEUE_LEN);
+        list_add_tail(&e->u.list, &ubi->pq[pq_tail]);
+        dbg_wl("added PEB %d EC %d to the protection queue", e->pnum, e->ec);
 }
 
 /**
@@ -414,14 +355,14 @@ static struct ubi_wl_entry *find_wl_entry(struct rb_root *root, int max)
         struct rb_node *p;
         struct ubi_wl_entry *e;
 
-        e = rb_entry(rb_first(root), struct ubi_wl_entry, rb);
+        e = rb_entry(rb_first(root), struct ubi_wl_entry, u.rb);
         max += e->ec;
 
         p = root->rb_node;
         while (p) {
                 struct ubi_wl_entry *e1;
 
-                e1 = rb_entry(p, struct ubi_wl_entry, rb);
+                e1 = rb_entry(p, struct ubi_wl_entry, u.rb);
                 if (e1->ec >= max)
                         p = p->rb_left;
                 else {
@@ -443,17 +384,12 @@ static struct ubi_wl_entry *find_wl_entry(struct rb_root *root, int max)
  */
 int ubi_wl_get_peb(struct ubi_device *ubi, int dtype)
 {
-        int err, protect, medium_ec;
+        int err, medium_ec;
         struct ubi_wl_entry *e, *first, *last;
-        struct ubi_wl_prot_entry *pe;
 
         ubi_assert(dtype == UBI_LONGTERM || dtype == UBI_SHORTTERM ||
                    dtype == UBI_UNKNOWN);
 
-        pe = kmalloc(sizeof(struct ubi_wl_prot_entry), GFP_NOFS);
-        if (!pe)
-                return -ENOMEM;
-
 retry:
         spin_lock(&ubi->wl_lock);
         if (!ubi->free.rb_node) {
@@ -461,16 +397,13 @@ retry:
                         ubi_assert(list_empty(&ubi->works));
                         ubi_err("no free eraseblocks");
                         spin_unlock(&ubi->wl_lock);
-                        kfree(pe);
                         return -ENOSPC;
                 }
                 spin_unlock(&ubi->wl_lock);
 
                 err = produce_free_peb(ubi);
-                if (err < 0) {
-                        kfree(pe);
+                if (err < 0)
                         return err;
-                }
                 goto retry;
         }
 
@@ -483,7 +416,6 @@ retry:
                  * %WL_FREE_MAX_DIFF.
                  */
                 e = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
-                protect = LT_PROTECTION;
                 break;
         case UBI_UNKNOWN:
                 /*
@@ -492,81 +424,63 @@ retry:
                  * eraseblock with erase counter greater or equivalent than the
                  * lowest erase counter plus %WL_FREE_MAX_DIFF.
                  */
-                first = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry, rb);
-                last = rb_entry(rb_last(&ubi->free), struct ubi_wl_entry, rb);
+                first = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry,
+                                        u.rb);
+                last = rb_entry(rb_last(&ubi->free), struct ubi_wl_entry, u.rb);
 
                 if (last->ec - first->ec < WL_FREE_MAX_DIFF)
                         e = rb_entry(ubi->free.rb_node,
-                                        struct ubi_wl_entry, rb);
+                                        struct ubi_wl_entry, u.rb);
                 else {
                         medium_ec = (first->ec + WL_FREE_MAX_DIFF)/2;
                         e = find_wl_entry(&ubi->free, medium_ec);
                 }
-                protect = U_PROTECTION;
                 break;
         case UBI_SHORTTERM:
                 /*
                  * For short term data we pick a physical eraseblock with the
                  * lowest erase counter as we expect it will be erased soon.
                  */
-                e = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry, rb);
-                protect = ST_PROTECTION;
+                e = rb_entry(rb_first(&ubi->free), struct ubi_wl_entry, u.rb);
                 break;
         default:
-                protect = 0;
-                e = NULL;
                 BUG();
         }
 
+        paranoid_check_in_wl_tree(e, &ubi->free);
+
         /*
-         * Move the physical eraseblock to the protection trees where it will
+         * Move the physical eraseblock to the protection queue where it will
          * be protected from being moved for some time.
          */
-        paranoid_check_in_wl_tree(e, &ubi->free);
-        rb_erase(&e->rb, &ubi->free);
-        prot_tree_add(ubi, e, pe, protect);
-
-        dbg_wl("PEB %d EC %d, protection %d", e->pnum, e->ec, protect);
+        rb_erase(&e->u.rb, &ubi->free);
+        dbg_wl("PEB %d EC %d", e->pnum, e->ec);
+        prot_queue_add(ubi, e);
         spin_unlock(&ubi->wl_lock);
-
         return e->pnum;
 }
 
 /**
- * prot_tree_del - remove a physical eraseblock from the protection trees
+ * prot_queue_del - remove a physical eraseblock from the protection queue.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock to remove
  *
- * This function returns PEB @pnum from the protection trees and returns zero
- * in case of success and %-ENODEV if the PEB was not found in the protection
- * trees.
+ * This function deletes PEB @pnum from the protection queue and returns zero
+ * in case of success and %-ENODEV if the PEB was not found.
  */
-static int prot_tree_del(struct ubi_device *ubi, int pnum)
+static int prot_queue_del(struct ubi_device *ubi, int pnum)
 {
-        struct rb_node *p;
-        struct ubi_wl_prot_entry *pe = NULL;
-
-        p = ubi->prot.pnum.rb_node;
-        while (p) {
-
-                pe = rb_entry(p, struct ubi_wl_prot_entry, rb_pnum);
-
-                if (pnum == pe->e->pnum)
-                        goto found;
+        struct ubi_wl_entry *e;
 
-                if (pnum < pe->e->pnum)
-                        p = p->rb_left;
-                else
-                        p = p->rb_right;
-        }
+        e = ubi->lookuptbl[pnum];
+        if (!e)
+                return -ENODEV;
 
-        return -ENODEV;
+        if (paranoid_check_in_pq(ubi, e))
+                return -ENODEV;
 
-found:
-        ubi_assert(pe->e->pnum == pnum);
-        rb_erase(&pe->rb_aec, &ubi->prot.aec);
-        rb_erase(&pe->rb_pnum, &ubi->prot.pnum);
-        kfree(pe);
+        list_del(&e->u.list);
+        dbg_wl("deleted PEB %d from the protection queue", e->pnum);
         return 0;
 }
 
@@ -632,47 +546,47 @@ out_free:
 }
 
 /**
- * check_protection_over - check if it is time to stop protecting some PEBs.
+ * serve_prot_queue - check if it is time to stop protecting PEBs.
  * @ubi: UBI device description object
  *
- * This function is called after each erase operation, when the absolute erase
- * counter is incremented, to check if some physical eraseblock  have not to be
- * protected any longer. These physical eraseblocks are moved from the
- * protection trees to the used tree.
+ * This function is called after each erase operation and removes PEBs from the
+ * tail of the protection queue. These PEBs have been protected for long enough
+ * and should be moved to the used tree.
  */
-static void check_protection_over(struct ubi_device *ubi)
+static void serve_prot_queue(struct ubi_device *ubi)
 {
-        struct ubi_wl_prot_entry *pe;
+        struct ubi_wl_entry *e, *tmp;
+        int count;
 
         /*
          * There may be several protected physical eraseblock to remove,
          * process them all.
          */
-        while (1) {
-                spin_lock(&ubi->wl_lock);
-                if (!ubi->prot.aec.rb_node) {
-                        spin_unlock(&ubi->wl_lock);
-                        break;
-                }
-
-                pe = rb_entry(rb_first(&ubi->prot.aec),
-                              struct ubi_wl_prot_entry, rb_aec);
+repeat:
+        count = 0;
+        spin_lock(&ubi->wl_lock);
+        list_for_each_entry_safe(e, tmp, &ubi->pq[ubi->pq_head], u.list) {
+                dbg_wl("PEB %d EC %d protection over, move to used tree",
+                        e->pnum, e->ec);
 
-                if (pe->abs_ec > ubi->abs_ec) {
+                list_del(&e->u.list);
+                wl_tree_add(e, &ubi->used);
+                if (count++ > 32) {
+                        /*
+                         * Let's be nice and avoid holding the spinlock for
+                         * too long.
+                         */
                         spin_unlock(&ubi->wl_lock);
-                        break;
+                        cond_resched();
+                        goto repeat;
                 }
-
-                dbg_wl("PEB %d protection over, abs_ec %llu, PEB abs_ec %llu",
-                       pe->e->pnum, ubi->abs_ec, pe->abs_ec);
-                rb_erase(&pe->rb_aec, &ubi->prot.aec);
-                rb_erase(&pe->rb_pnum, &ubi->prot.pnum);
-                wl_tree_add(pe->e, &ubi->used);
-                spin_unlock(&ubi->wl_lock);
-
-                kfree(pe);
-                cond_resched();
         }
+
+        ubi->pq_head += 1;
+        if (ubi->pq_head == UBI_PROT_QUEUE_LEN)
+                ubi->pq_head = 0;
+        ubi_assert(ubi->pq_head >= 0 && ubi->pq_head < UBI_PROT_QUEUE_LEN);
+        spin_unlock(&ubi->wl_lock);
 }
 
 /**
@@ -680,8 +594,8 @@ static void check_protection_over(struct ubi_device *ubi)
  * @ubi: UBI device description object
  * @wrk: the work to schedule
  *
- * This function enqueues a work defined by @wrk to the tail of the pending
- * works list.
+ * This function adds a work defined by @wrk to the tail of the pending works
+ * list.
  */
 static void schedule_ubi_work(struct ubi_device *ubi, struct ubi_work *wrk)
 {
@@ -739,13 +653,11 @@ static int schedule_erase(struct ubi_device *ubi, struct ubi_wl_entry *e,
 static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                                 int cancel)
 {
-        int err, put = 0, scrubbing = 0, protect = 0;
-        struct ubi_wl_prot_entry *uninitialized_var(pe);
+        int err, scrubbing = 0, torture = 0;
         struct ubi_wl_entry *e1, *e2;
         struct ubi_vid_hdr *vid_hdr;
 
         kfree(wrk);
-
         if (cancel)
                 return 0;
 
@@ -781,7 +693,7 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                  * highly worn-out free physical eraseblock. If the erase
                  * counters differ much enough, start wear-leveling.
                  */
-                e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, rb);
+                e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
                 e2 = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
 
                 if (!(e2->ec - e1->ec >= UBI_WL_THRESHOLD)) {
@@ -790,21 +702,21 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                         goto out_cancel;
                 }
                 paranoid_check_in_wl_tree(e1, &ubi->used);
-                rb_erase(&e1->rb, &ubi->used);
+                rb_erase(&e1->u.rb, &ubi->used);
                 dbg_wl("move PEB %d EC %d to PEB %d EC %d",
                        e1->pnum, e1->ec, e2->pnum, e2->ec);
         } else {
                 /* Perform scrubbing */
                 scrubbing = 1;
-                e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, rb);
+                e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, u.rb);
                 e2 = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
                 paranoid_check_in_wl_tree(e1, &ubi->scrub);
-                rb_erase(&e1->rb, &ubi->scrub);
+                rb_erase(&e1->u.rb, &ubi->scrub);
                 dbg_wl("scrub PEB %d to PEB %d", e1->pnum, e2->pnum);
         }
 
         paranoid_check_in_wl_tree(e2, &ubi->free);
-        rb_erase(&e2->rb, &ubi->free);
+        rb_erase(&e2->u.rb, &ubi->free);
         ubi->move_from = e1;
         ubi->move_to = e2;
         spin_unlock(&ubi->wl_lock);
@@ -844,46 +756,67 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
 
         err = ubi_eba_copy_leb(ubi, e1->pnum, e2->pnum, vid_hdr);
         if (err) {
-
+                if (err == -EAGAIN)
+                        goto out_not_moved;
                 if (err < 0)
                         goto out_error;
-                if (err == 1)
+                if (err == 2) {
+                        /* Target PEB write error, torture it */
+                        torture = 1;
                         goto out_not_moved;
+                }
 
                 /*
-                 * For some reason the LEB was not moved - it might be because
-                 * the volume is being deleted. We should prevent this PEB from
-                 * being selected for wear-levelling movement for some "time",
-                 * so put it to the protection tree.
+                 * The LEB has not been moved because the volume is being
+                 * deleted or the PEB has been put meanwhile. We should prevent
+                 * this PEB from being selected for wear-leveling movement
+                 * again, so put it to the protection queue.
                  */
 
-                dbg_wl("cancelled moving PEB %d", e1->pnum);
-                pe = kmalloc(sizeof(struct ubi_wl_prot_entry), GFP_NOFS);
-                if (!pe) {
-                        err = -ENOMEM;
-                        goto out_error;
-                }
+                dbg_wl("canceled moving PEB %d", e1->pnum);
+                ubi_assert(err == 1);
+
+                ubi_free_vid_hdr(ubi, vid_hdr);
+                vid_hdr = NULL;
+
+                spin_lock(&ubi->wl_lock);
+                prot_queue_add(ubi, e1);
+                ubi_assert(!ubi->move_to_put);
+                ubi->move_from = ubi->move_to = NULL;
+                ubi->wl_scheduled = 0;
+                spin_unlock(&ubi->wl_lock);
 
-                protect = 1;
+                e1 = NULL;
+                err = schedule_erase(ubi, e2, 0);
+                if (err)
+                        goto out_error;
+                mutex_unlock(&ubi->move_mutex);
+                return 0;
         }
 
+        /* The PEB has been successfully moved */
         ubi_free_vid_hdr(ubi, vid_hdr);
-        if (scrubbing && !protect)
+        vid_hdr = NULL;
+        if (scrubbing)
                 ubi_msg("scrubbed PEB %d, data moved to PEB %d",
                         e1->pnum, e2->pnum);
 
         spin_lock(&ubi->wl_lock);
-        if (protect)
-                prot_tree_add(ubi, e1, pe, protect);
-        if (!ubi->move_to_put)
+        if (!ubi->move_to_put) {
                 wl_tree_add(e2, &ubi->used);
-        else
-                put = 1;
+                e2 = NULL;
+        }
         ubi->move_from = ubi->move_to = NULL;
         ubi->move_to_put = ubi->wl_scheduled = 0;
         spin_unlock(&ubi->wl_lock);
 
-        if (put) {
+        err = schedule_erase(ubi, e1, 0);
+        if (err) {
+                e1 = NULL;
+                goto out_error;
+        }
+
+        if (e2) {
                 /*
                  * Well, the target PEB was put meanwhile, schedule it for
                  * erasure.
@@ -894,13 +827,6 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
                         goto out_error;
         }
 
-        if (!protect) {
-                err = schedule_erase(ubi, e1, 0);
-                if (err)
-                        goto out_error;
-        }
-
-
         dbg_wl("done");
         mutex_unlock(&ubi->move_mutex);
         return 0;
@@ -908,20 +834,24 @@ static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk,
         /*
          * For some reasons the LEB was not moved, might be an error, might be
          * something else. @e1 was not changed, so return it back. @e2 might
-         * be changed, schedule it for erasure.
+         * have been changed, schedule it for erasure.
          */
 out_not_moved:
+        dbg_wl("canceled moving PEB %d", e1->pnum);
         ubi_free_vid_hdr(ubi, vid_hdr);
+        vid_hdr = NULL;
         spin_lock(&ubi->wl_lock);
         if (scrubbing)
                 wl_tree_add(e1, &ubi->scrub);
         else
                 wl_tree_add(e1, &ubi->used);
+        ubi_assert(!ubi->move_to_put);
         ubi->move_from = ubi->move_to = NULL;
-        ubi->move_to_put = ubi->wl_scheduled = 0;
+        ubi->wl_scheduled = 0;
         spin_unlock(&ubi->wl_lock);
 
-        err = schedule_erase(ubi, e2, 0);
+        e1 = NULL;
+        err = schedule_erase(ubi, e2, torture);
         if (err)
                 goto out_error;
 
@@ -938,8 +868,10 @@ out_error:
         ubi->move_to_put = ubi->wl_scheduled = 0;
         spin_unlock(&ubi->wl_lock);
 
-        kmem_cache_free(ubi_wl_entry_slab, e1);
-        kmem_cache_free(ubi_wl_entry_slab, e2);
+        if (e1)
+                kmem_cache_free(ubi_wl_entry_slab, e1);
+        if (e2)
+                kmem_cache_free(ubi_wl_entry_slab, e2);
         ubi_ro_mode(ubi);
 
         mutex_unlock(&ubi->move_mutex);
@@ -988,7 +920,7 @@ static int ensure_wear_leveling(struct ubi_device *ubi)
                  * erase counter of free physical eraseblocks is greater then
                  * %UBI_WL_THRESHOLD.
                  */
-                e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, rb);
+                e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
                 e2 = find_wl_entry(&ubi->free, WL_FREE_MAX_DIFF);
 
                 if (!(e2->ec - e1->ec >= UBI_WL_THRESHOLD))
@@ -1050,7 +982,6 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
                 kfree(wl_wrk);
 
                 spin_lock(&ubi->wl_lock);
-                ubi->abs_ec += 1;
                 wl_tree_add(e, &ubi->free);
                 spin_unlock(&ubi->wl_lock);
 
@@ -1058,7 +989,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
                  * One more erase operation has happened, take care about
                  * protected physical eraseblocks.
                  */
-                check_protection_over(ubi);
+                serve_prot_queue(ubi);
 
                 /* And take care about wear-leveling */
                 err = ensure_wear_leveling(ubi);
@@ -1190,12 +1121,12 @@ retry:
         } else {
                 if (in_wl_tree(e, &ubi->used)) {
                         paranoid_check_in_wl_tree(e, &ubi->used);
-                        rb_erase(&e->rb, &ubi->used);
+                        rb_erase(&e->u.rb, &ubi->used);
                 } else if (in_wl_tree(e, &ubi->scrub)) {
                         paranoid_check_in_wl_tree(e, &ubi->scrub);
-                        rb_erase(&e->rb, &ubi->scrub);
+                        rb_erase(&e->u.rb, &ubi->scrub);
                 } else {
-                        err = prot_tree_del(ubi, e->pnum);
+                        err = prot_queue_del(ubi, e->pnum);
                         if (err) {
                                 ubi_err("PEB %d not found", pnum);
                                 ubi_ro_mode(ubi);
@@ -1255,11 +1186,11 @@ retry:
 
         if (in_wl_tree(e, &ubi->used)) {
                 paranoid_check_in_wl_tree(e, &ubi->used);
-                rb_erase(&e->rb, &ubi->used);
+                rb_erase(&e->u.rb, &ubi->used);
         } else {
                 int err;
 
-                err = prot_tree_del(ubi, e->pnum);
+                err = prot_queue_del(ubi, e->pnum);
                 if (err) {
                         ubi_err("PEB %d not found", pnum);
                         ubi_ro_mode(ubi);
@@ -1290,7 +1221,7 @@ int ubi_wl_flush(struct ubi_device *ubi)
         int err;
 
         /*
-         * Erase while the pending works queue is not empty, but not more then
+         * Erase while the pending works queue is not empty, but not more than
          * the number of currently pending works.
          */
         dbg_wl("flush (%d pending works)", ubi->works_count);
@@ -1308,7 +1239,7 @@ int ubi_wl_flush(struct ubi_device *ubi)
         up_write(&ubi->work_sem);
 
         /*
-         * And in case last was the WL worker and it cancelled the LEB
+         * And in case last was the WL worker and it canceled the LEB
          * movement, flush again.
          */
         while (ubi->works_count) {
@@ -1337,11 +1268,11 @@ static void tree_destroy(struct rb_root *root)
                 else if (rb->rb_right)
                         rb = rb->rb_right;
                 else {
-                        e = rb_entry(rb, struct ubi_wl_entry, rb);
+                        e = rb_entry(rb, struct ubi_wl_entry, u.rb);
 
                         rb = rb_parent(rb);
                         if (rb) {
-                                if (rb->rb_left == &e->rb)
+                                if (rb->rb_left == &e->u.rb)
                                         rb->rb_left = NULL;
                                 else
                                         rb->rb_right = NULL;
@@ -1436,15 +1367,13 @@ static void cancel_pending(struct ubi_device *ubi)
  */
 int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
 {
-        int err;
+        int err, i;
         struct rb_node *rb1, *rb2;
         struct ubi_scan_volume *sv;
         struct ubi_scan_leb *seb, *tmp;
         struct ubi_wl_entry *e;
 
-
         ubi->used = ubi->free = ubi->scrub = RB_ROOT;
-        ubi->prot.pnum = ubi->prot.aec = RB_ROOT;
         spin_lock_init(&ubi->wl_lock);
         mutex_init(&ubi->move_mutex);
         init_rwsem(&ubi->work_sem);
@@ -1458,6 +1387,10 @@ int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
         if (!ubi->lookuptbl)
                 return err;
 
+        for (i = 0; i < UBI_PROT_QUEUE_LEN; i++)
+                INIT_LIST_HEAD(&ubi->pq[i]);
+        ubi->pq_head = 0;
+
         list_for_each_entry_safe(seb, tmp, &si->erase, u.list) {
                 cond_resched();
 
@@ -1552,33 +1485,18 @@ out_free:
 }
 
 /**
- * protection_trees_destroy - destroy the protection RB-trees.
+ * protection_queue_destroy - destroy the protection queue.
  * @ubi: UBI device description object
  */
-static void protection_trees_destroy(struct ubi_device *ubi)
+static void protection_queue_destroy(struct ubi_device *ubi)
 {
-        struct rb_node *rb;
-        struct ubi_wl_prot_entry *pe;
-
-        rb = ubi->prot.aec.rb_node;
-        while (rb) {
-                if (rb->rb_left)
-                        rb = rb->rb_left;
-                else if (rb->rb_right)
-                        rb = rb->rb_right;
-                else {
-                        pe = rb_entry(rb, struct ubi_wl_prot_entry, rb_aec);
-
-                        rb = rb_parent(rb);
-                        if (rb) {
-                                if (rb->rb_left == &pe->rb_aec)
-                                        rb->rb_left = NULL;
-                                else
-                                        rb->rb_right = NULL;
-                        }
+        int i;
+        struct ubi_wl_entry *e, *tmp;
 
-                        kmem_cache_free(ubi_wl_entry_slab, pe->e);
-                        kfree(pe);
+        for (i = 0; i < UBI_PROT_QUEUE_LEN; ++i) {
+                list_for_each_entry_safe(e, tmp, &ubi->pq[i], u.list) {
+                        list_del(&e->u.list);
+                        kmem_cache_free(ubi_wl_entry_slab, e);
                 }
         }
 }
@@ -1591,7 +1509,7 @@ void ubi_wl_close(struct ubi_device *ubi)
 {
         dbg_wl("close the WL sub-system");
         cancel_pending(ubi);
-        protection_trees_destroy(ubi);
+        protection_queue_destroy(ubi);
         tree_destroy(&ubi->used);
         tree_destroy(&ubi->free);
         tree_destroy(&ubi->scrub);
@@ -1661,4 +1579,27 @@ static int paranoid_check_in_wl_tree(struct ubi_wl_entry *e,
         return 1;
 }
 
+/**
+ * paranoid_check_in_pq - check if wear-leveling entry is in the protection
+ *                        queue.
+ * @ubi: UBI device description object
+ * @e: the wear-leveling entry to check
+ *
+ * This function returns zero if @e is in @ubi->pq and %1 if it is not.
+ */
+static int paranoid_check_in_pq(struct ubi_device *ubi, struct ubi_wl_entry *e)
+{
+        struct ubi_wl_entry *p;
+        int i;
+
+        for (i = 0; i < UBI_PROT_QUEUE_LEN; ++i)
+                list_for_each_entry(p, &ubi->pq[i], u.list)
+                        if (p == e)
+                                return 0;
+
+        ubi_err("paranoid check failed for PEB %d, EC %d, Protect queue",
+                e->pnum, e->ec);
+        ubi_dbg_dump_stack();
+        return 1;
+}
 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 8514c3a1746a..c2e1bcbb28a7 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -45,7 +45,7 @@
 
 #include "cpqphp.h"
 #include "cpqphp_nvram.h"
-#include "../../../arch/x86/pci/pci.h"  /* horrible hack showing how processor dependent we are... */
+#include <asm/pci_x86.h>
 
 
 /* Global variables */
diff --git a/drivers/pci/hotplug/cpqphp_pci.c b/drivers/pci/hotplug/cpqphp_pci.c
index 09021930589f..df146be9d2e9 100644
--- a/drivers/pci/hotplug/cpqphp_pci.c
+++ b/drivers/pci/hotplug/cpqphp_pci.c
@@ -37,7 +37,7 @@
 #include "../pci.h"
 #include "cpqphp.h"
 #include "cpqphp_nvram.h"
-#include "../../../arch/x86/pci/pci.h"  /* horrible hack showing how processor dependent we are... */
+#include <asm/pci_x86.h>
 
 
 u8 cpqhp_nic_irq;
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 633e743442ac..dd18f857dfb0 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -35,7 +35,7 @@
 #include <linux/delay.h>
 #include <linux/wait.h>
 #include "../pci.h"
-#include "../../../arch/x86/pci/pci.h"  /* for struct irq_routing_table */
+#include <asm/pci_x86.h>                /* for struct irq_routing_table */
 #include "ibmphp.h"
 
 #define attn_on(sl)  ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON)
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 8a8df7552969..06b71823f399 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -632,8 +632,8 @@ do_IRQ (struct pt_regs *regs)
         struct pt_regs *old_regs;
 
         old_regs = set_irq_regs(regs);
-        irq_enter();
         s390_idle_check();
+        irq_enter();
         if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
                 /* Serve timer interrupts first. */
                 clock_comparator_work();
diff --git a/drivers/s390/s390mach.c b/drivers/s390/s390mach.c
index 834e9ee7e934..92b0417f8e12 100644
--- a/drivers/s390/s390mach.c
+++ b/drivers/s390/s390mach.c
@@ -18,6 +18,7 @@
 #include <asm/etr.h>
 #include <asm/lowcore.h>
 #include <asm/cio.h>
+#include <asm/cpu.h>
 #include "s390mach.h"
 
 static struct semaphore m_sem;
@@ -369,6 +370,8 @@ s390_do_machine_check(struct pt_regs *regs)
 
         lockdep_off();
 
+        s390_idle_check();
+
         mci = (struct mci *) &S390_lowcore.mcck_interruption_code;
         mcck = &__get_cpu_var(cpu_mcck);
         umode = user_mode(regs);
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 4fd3fa5546b1..ec68c741b564 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -55,6 +55,13 @@ config SOFT_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called softdog.
 
+config WM8350_WATCHDOG
+        tristate "WM8350 watchdog"
+        depends on MFD_WM8350
+        help
+          Support for the watchdog in the WM8350 AudioPlus PMIC.  When
+          the watchdog triggers the system will be reset.
+
 # ALPHA Architecture
 
 # ARM Architecture
@@ -551,6 +558,18 @@ config CPU5_WDT
           To compile this driver as a module, choose M here: the
           module will be called cpu5wdt.
 
+config SMSC_SCH311X_WDT
+        tristate "SMSC SCH311X Watchdog Timer"
+        depends on X86
+        ---help---
+          This is the driver for the hardware watchdog timer on the
+          SMSC SCH3112, SCH3114 and SCH3116 Super IO chipset
+          (LPC IO with 8042 KBC, Reset Generation, HWM and multiple
+          serial ports).
+
+          To compile this driver as a module, choose M here: the
+          module will be called sch311x_wdt.
+
 config SMSC37B787_WDT
         tristate "Winbond SMsC37B787 Watchdog Timer"
         depends on X86
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index e352bbb7630b..c19b866f5ed1 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -83,6 +83,7 @@ obj-$(CONFIG_60XX_WDT) += sbc60xxwdt.o
 obj-$(CONFIG_SBC8360_WDT) += sbc8360.o
 obj-$(CONFIG_SBC7240_WDT) += sbc7240_wdt.o
 obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o
+obj-$(CONFIG_SMSC_SCH311X_WDT) += sch311x_wdt.o
 obj-$(CONFIG_SMSC37B787_WDT) += smsc37b787_wdt.o
 obj-$(CONFIG_W83627HF_WDT) += w83627hf_wdt.o
 obj-$(CONFIG_W83697HF_WDT) += w83697hf_wdt.o
@@ -133,4 +134,5 @@ obj-$(CONFIG_WATCHDOG_CP1XXX)		+= cpwd.o
 # XTENSA Architecture
 
 # Architecture Independant
+obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o
 obj-$(CONFIG_SOFT_WATCHDOG) += softdog.o
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index 317ef2b16cff..4bef3ddff4a5 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -91,32 +91,16 @@ static char expect_close;
  *
  */
 
-static int wd_times[] = {
-        30,     /* 0x0 */
-        28,     /* 0x1 */
-        26,     /* 0x2 */
-        24,     /* 0x3 */
-        22,     /* 0x4 */
-        20,     /* 0x5 */
-        18,     /* 0x6 */
-        16,     /* 0x7 */
-        14,     /* 0x8 */
-        12,     /* 0x9 */
-        10,     /* 0xA */
-        8,      /* 0xB */
-        6,      /* 0xC */
-        4,      /* 0xD */
-        2,      /* 0xE */
-        0,      /* 0xF */
-};
-
 #define WDT_STOP 0x441
 #define WDT_START 0x443
 
 /* Default timeout */
-#define WD_TIMO 0               /* 30 seconds +/- 20%, from table */
-
-static int wd_margin = WD_TIMO;
+#define WATCHDOG_TIMEOUT 30             /* 30 seconds +/- 20% */
+static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. 0<= timeout <=30, default="
+                __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
@@ -131,6 +115,8 @@ MODULE_PARM_DESC(nowayout,
 
 static void ibwdt_ping(void)
 {
+        int wd_margin = 15 - ((timeout + 1) / 2);
+
         spin_lock(&ibwdt_lock);
 
         /* Write a watchdog value */
@@ -148,15 +134,10 @@ static void ibwdt_disable(void)
 
 static int ibwdt_set_heartbeat(int t)
 {
-        int i;
-
-        if ((t < 0) || (t > 30))
+        if (t < 0 || t > 30)
                 return -EINVAL;
 
-        for (i = 0x0F; i > -1; i--)
-                if (wd_times[i] >= t)
-                        break;
-        wd_margin = i;
+        timeout = t;
         return 0;
 }
 
@@ -240,7 +221,7 @@ static long ibwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 /* Fall */
 
         case WDIOC_GETTIMEOUT:
-                return put_user(wd_times[wd_margin], p);
+                return put_user(timeout, p);
 
         default:
                 return -ENOTTY;
@@ -317,6 +298,14 @@ static int __devinit ibwdt_probe(struct platform_device *dev)
                 goto out_nostartreg;
         }
 
+        /* Check that the heartbeat value is within it's range ;
+         * if not reset to the default */
+        if (ibwdt_set_heartbeat(timeout)) {
+                ibwdt_set_heartbeat(WATCHDOG_TIMEOUT);
+                printk(KERN_INFO PFX
+                        "timeout value must be 0<=x<=30, using %d\n", timeout);
+        }
+
         res = misc_register(&ibwdt_miscdev);
         if (res) {
                 printk(KERN_ERR PFX "failed to register misc device\n");
diff --git a/drivers/watchdog/sch311x_wdt.c b/drivers/watchdog/sch311x_wdt.c
new file mode 100644
index 000000000000..569eb295a7a8
--- /dev/null
+++ b/drivers/watchdog/sch311x_wdt.c
@@ -0,0 +1,578 @@
+/*
+ *      sch311x_wdt.c - Driver for the SCH311x Super-I/O chips
+ *                      integrated watchdog.
+ *
+ *      (c) Copyright 2008 Wim Van Sebroeck <wim@iguana.be>.
+ *
+ *      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.
+ *
+ *      Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor
+ *      provide warranty for any of this software. This material is
+ *      provided "AS-IS" and at no charge.
+ */
+
+/*
+ *      Includes, defines, variables, module parameters, ...
+ */
+
+/* Includes */
+#include <linux/module.h>               /* For module specific items */
+#include <linux/moduleparam.h>          /* For new moduleparam's */
+#include <linux/types.h>                /* For standard types (like size_t) */
+#include <linux/errno.h>                /* For the -ENODEV/... values */
+#include <linux/kernel.h>               /* For printk/... */
+#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
+                                                        (WATCHDOG_MINOR) */
+#include <linux/watchdog.h>             /* For the watchdog specific items */
+#include <linux/init.h>                 /* For __init/__exit/... */
+#include <linux/fs.h>                   /* For file operations */
+#include <linux/platform_device.h>      /* For platform_driver framework */
+#include <linux/ioport.h>               /* For io-port access */
+#include <linux/spinlock.h>             /* For spin_lock/spin_unlock/... */
+#include <linux/uaccess.h>              /* For copy_to_user/put_user/... */
+#include <linux/io.h>                   /* For inb/outb/... */
+
+/* Module and version information */
+#define DRV_NAME        "sch311x_wdt"
+#define PFX             DRV_NAME ": "
+
+/* Runtime registers */
+#define RESGEN                  0x1d
+#define GP60                    0x47
+#define WDT_TIME_OUT            0x65
+#define WDT_VAL                 0x66
+#define WDT_CFG                 0x67
+#define WDT_CTRL                0x68
+
+/* internal variables */
+static unsigned long sch311x_wdt_is_open;
+static char sch311x_wdt_expect_close;
+static struct platform_device *sch311x_wdt_pdev;
+
+static int sch311x_ioports[] = { 0x2e, 0x4e, 0x162e, 0x164e, 0x00 };
+
+static struct { /* The devices private data */
+        /* the Runtime Register base address */
+        unsigned short runtime_reg;
+        /* The card's boot status */
+        int boot_status;
+        /* the lock for io operations */
+        spinlock_t io_lock;
+} sch311x_wdt_data;
+
+/* Module load parameters */
+static unsigned short force_id;
+module_param(force_id, ushort, 0);
+MODULE_PARM_DESC(force_id, "Override the detected device ID");
+
+static unsigned short therm_trip;
+module_param(therm_trip, ushort, 0);
+MODULE_PARM_DESC(therm_trip, "Should a ThermTrip trigger the reset generator");
+
+#define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
+static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. 1<= timeout <=15300, default="
+                __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+/*
+ *      Super-IO functions
+ */
+
+static inline void sch311x_sio_enter(int sio_config_port)
+{
+        outb(0x55, sio_config_port);
+}
+
+static inline void sch311x_sio_exit(int sio_config_port)
+{
+        outb(0xaa, sio_config_port);
+}
+
+static inline int sch311x_sio_inb(int sio_config_port, int reg)
+{
+        outb(reg, sio_config_port);
+        return inb(sio_config_port + 1);
+}
+
+static inline void sch311x_sio_outb(int sio_config_port, int reg, int val)
+{
+        outb(reg, sio_config_port);
+        outb(val, sio_config_port + 1);
+}
+
+/*
+ *      Watchdog Operations
+ */
+
+static void sch311x_wdt_set_timeout(int t)
+{
+        unsigned char timeout_unit = 0x80;
+
+        /* When new timeout is bigger then 255 seconds, we will use minutes */
+        if (t > 255) {
+                timeout_unit = 0;
+                t /= 60;
+        }
+
+        /* -- Watchdog Timeout --
+         * Bit 0-6 (Reserved)
+         * Bit 7   WDT Time-out Value Units Select
+         *         (0 = Minutes, 1 = Seconds)
+         */
+        outb(timeout_unit, sch311x_wdt_data.runtime_reg + WDT_TIME_OUT);
+
+        /* -- Watchdog Timer Time-out Value --
+         * Bit 0-7 Binary coded units (0=Disabled, 1..255)
+         */
+        outb(t, sch311x_wdt_data.runtime_reg + WDT_VAL);
+}
+
+static void sch311x_wdt_start(void)
+{
+        spin_lock(&sch311x_wdt_data.io_lock);
+
+        /* set watchdog's timeout */
+        sch311x_wdt_set_timeout(timeout);
+        /* enable the watchdog */
+        /* -- General Purpose I/O Bit 6.0 --
+         * Bit 0,   In/Out: 0 = Output, 1 = Input
+         * Bit 1,   Polarity: 0 = No Invert, 1 = Invert
+         * Bit 2-3, Function select: 00 = GPI/O, 01 = LED1, 11 = WDT,
+         *                           10 = Either Edge Triggered Intr.4
+         * Bit 4-6  (Reserved)
+         * Bit 7,   Output Type: 0 = Push Pull Bit, 1 = Open Drain
+         */
+        outb(0x0e, sch311x_wdt_data.runtime_reg + GP60);
+
+        spin_unlock(&sch311x_wdt_data.io_lock);
+
+}
+
+static void sch311x_wdt_stop(void)
+{
+        spin_lock(&sch311x_wdt_data.io_lock);
+
+        /* stop the watchdog */
+        outb(0x01, sch311x_wdt_data.runtime_reg + GP60);
+        /* disable timeout by setting it to 0 */
+        sch311x_wdt_set_timeout(0);
+
+        spin_unlock(&sch311x_wdt_data.io_lock);
+}
+
+static void sch311x_wdt_keepalive(void)
+{
+        spin_lock(&sch311x_wdt_data.io_lock);
+        sch311x_wdt_set_timeout(timeout);
+        spin_unlock(&sch311x_wdt_data.io_lock);
+}
+
+static int sch311x_wdt_set_heartbeat(int t)
+{
+        if (t < 1 || t > (255*60))
+                return -EINVAL;
+
+        /* When new timeout is bigger then 255 seconds,
+         * we will round up to minutes (with a max of 255) */
+        if (t > 255)
+                t = (((t - 1) / 60) + 1) * 60;
+
+        timeout = t;
+        return 0;
+}
+
+static void sch311x_wdt_get_status(int *status)
+{
+        unsigned char new_status;
+
+        *status = 0;
+
+        spin_lock(&sch311x_wdt_data.io_lock);
+
+        /* -- Watchdog timer control --
+         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+         * Bit 1   Reserved
+         * Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
+         * Bit 3   P20 Force Timeout enabled:
+         *          0 = P20 activity does not generate the WD timeout event
+         *          1 = P20 Allows rising edge of P20, from the keyboard
+         *              controller, to force the WD timeout event.
+         * Bit 4-7 Reserved
+         */
+        new_status = inb(sch311x_wdt_data.runtime_reg + WDT_CTRL);
+        if (new_status & 0x01)
+                *status |= WDIOF_CARDRESET;
+
+        spin_unlock(&sch311x_wdt_data.io_lock);
+}
+
+/*
+ *      /dev/watchdog handling
+ */
+
+static ssize_t sch311x_wdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
+{
+        if (count) {
+                if (!nowayout) {
+                        size_t i;
+
+                        sch311x_wdt_expect_close = 0;
+
+                        for (i = 0; i != count; i++) {
+                                char c;
+                                if (get_user(c, buf + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        sch311x_wdt_expect_close = 42;
+                        }
+                }
+                sch311x_wdt_keepalive();
+        }
+        return count;
+}
+
+static long sch311x_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int status;
+        int new_timeout;
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        static struct watchdog_info ident = {
+                .options                = WDIOF_KEEPALIVEPING |
+                                          WDIOF_SETTIMEOUT |
+                                          WDIOF_MAGICCLOSE,
+                .firmware_version       = 1,
+                .identity               = DRV_NAME,
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+
+        case WDIOC_GETSTATUS:
+        {
+                sch311x_wdt_get_status(&status);
+                return put_user(status, p);
+        }
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(sch311x_wdt_data.boot_status, p);
+
+        case WDIOC_SETOPTIONS:
+        {
+                int options, retval = -EINVAL;
+
+                if (get_user(options, p))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        sch311x_wdt_stop();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        sch311x_wdt_start();
+                        retval = 0;
+                }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                sch311x_wdt_keepalive();
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (sch311x_wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                sch311x_wdt_keepalive();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
+        }
+        return 0;
+}
+
+static int sch311x_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &sch311x_wdt_is_open))
+                return -EBUSY;
+        /*
+         *      Activate
+         */
+        sch311x_wdt_start();
+        return nonseekable_open(inode, file);
+}
+
+static int sch311x_wdt_close(struct inode *inode, struct file *file)
+{
+        if (sch311x_wdt_expect_close == 42) {
+                sch311x_wdt_stop();
+        } else {
+                printk(KERN_CRIT PFX
+                                "Unexpected close, not stopping watchdog!\n");
+                sch311x_wdt_keepalive();
+        }
+        clear_bit(0, &sch311x_wdt_is_open);
+        sch311x_wdt_expect_close = 0;
+        return 0;
+}
+
+/*
+ *      Kernel Interfaces
+ */
+
+static const struct file_operations sch311x_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = sch311x_wdt_write,
+        .unlocked_ioctl = sch311x_wdt_ioctl,
+        .open           = sch311x_wdt_open,
+        .release        = sch311x_wdt_close,
+};
+
+static struct miscdevice sch311x_wdt_miscdev = {
+        .minor  = WATCHDOG_MINOR,
+        .name   = "watchdog",
+        .fops   = &sch311x_wdt_fops,
+};
+
+/*
+ *      Init & exit routines
+ */
+
+static int __devinit sch311x_wdt_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        unsigned char val;
+        int err;
+
+        spin_lock_init(&sch311x_wdt_data.io_lock);
+
+        if (!request_region(sch311x_wdt_data.runtime_reg + RESGEN, 1,
+                                                                DRV_NAME)) {
+                dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n",
+                        sch311x_wdt_data.runtime_reg + RESGEN,
+                        sch311x_wdt_data.runtime_reg + RESGEN);
+                err = -EBUSY;
+                goto exit;
+        }
+
+        if (!request_region(sch311x_wdt_data.runtime_reg + GP60, 1, DRV_NAME)) {
+                dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n",
+                        sch311x_wdt_data.runtime_reg + GP60,
+                        sch311x_wdt_data.runtime_reg + GP60);
+                err = -EBUSY;
+                goto exit_release_region;
+        }
+
+        if (!request_region(sch311x_wdt_data.runtime_reg + WDT_TIME_OUT, 4,
+                                                                DRV_NAME)) {
+                dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n",
+                        sch311x_wdt_data.runtime_reg + WDT_TIME_OUT,
+                        sch311x_wdt_data.runtime_reg + WDT_CTRL);
+                err = -EBUSY;
+                goto exit_release_region2;
+        }
+
+        /* Make sure that the watchdog is not running */
+        sch311x_wdt_stop();
+
+        /* Disable keyboard and mouse interaction and interrupt */
+        /* -- Watchdog timer configuration --
+         * Bit 0   Reserved
+         * Bit 1   Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr.
+         * Bit 2   Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr
+         * Bit 3   Reserved
+         * Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled,
+         *            0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15)
+         */
+        outb(0, sch311x_wdt_data.runtime_reg + WDT_CFG);
+
+        /* Check that the heartbeat value is within it's range ;
+         * if not reset to the default */
+        if (sch311x_wdt_set_heartbeat(timeout)) {
+                sch311x_wdt_set_heartbeat(WATCHDOG_TIMEOUT);
+                dev_info(dev, "timeout value must be 1<=x<=15300, using %d\n",
+                        timeout);
+        }
+
+        /* Get status at boot */
+        sch311x_wdt_get_status(&sch311x_wdt_data.boot_status);
+
+        /* enable watchdog */
+        /* -- Reset Generator --
+         * Bit 0   Enable Watchdog Timer Generation: 0* = Enabled, 1 = Disabled
+         * Bit 1   Thermtrip Source Select: O* = No Source, 1 = Source
+         * Bit 2   WDT2_CTL: WDT input bit
+         * Bit 3-7 Reserved
+         */
+        outb(0, sch311x_wdt_data.runtime_reg + RESGEN);
+        val = therm_trip ? 0x06 : 0x04;
+        outb(val, sch311x_wdt_data.runtime_reg + RESGEN);
+
+        err = misc_register(&sch311x_wdt_miscdev);
+        if (err != 0) {
+                dev_err(dev, "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, err);
+                goto exit_release_region3;
+        }
+
+        sch311x_wdt_miscdev.parent = dev;
+
+        dev_info(dev,
+                "SMSC SCH311x WDT initialized. timeout=%d sec (nowayout=%d)\n",
+                timeout, nowayout);
+
+        return 0;
+
+exit_release_region3:
+        release_region(sch311x_wdt_data.runtime_reg + WDT_TIME_OUT, 4);
+exit_release_region2:
+        release_region(sch311x_wdt_data.runtime_reg + GP60, 1);
+exit_release_region:
+        release_region(sch311x_wdt_data.runtime_reg + RESGEN, 1);
+        sch311x_wdt_data.runtime_reg = 0;
+exit:
+        return err;
+}
+
+static int __devexit sch311x_wdt_remove(struct platform_device *pdev)
+{
+        /* Stop the timer before we leave */
+        if (!nowayout)
+                sch311x_wdt_stop();
+
+        /* Deregister */
+        misc_deregister(&sch311x_wdt_miscdev);
+        release_region(sch311x_wdt_data.runtime_reg + WDT_TIME_OUT, 4);
+        release_region(sch311x_wdt_data.runtime_reg + GP60, 1);
+        release_region(sch311x_wdt_data.runtime_reg + RESGEN, 1);
+        sch311x_wdt_data.runtime_reg = 0;
+        return 0;
+}
+
+static void sch311x_wdt_shutdown(struct platform_device *dev)
+{
+        /* Turn the WDT off if we have a soft shutdown */
+        sch311x_wdt_stop();
+}
+
+#define sch311x_wdt_suspend NULL
+#define sch311x_wdt_resume  NULL
+
+static struct platform_driver sch311x_wdt_driver = {
+        .probe          = sch311x_wdt_probe,
+        .remove         = __devexit_p(sch311x_wdt_remove),
+        .shutdown       = sch311x_wdt_shutdown,
+        .suspend        = sch311x_wdt_suspend,
+        .resume         = sch311x_wdt_resume,
+        .driver         = {
+                .owner = THIS_MODULE,
+                .name = DRV_NAME,
+        },
+};
+
+static int __init sch311x_detect(int sio_config_port, unsigned short *addr)
+{
+        int err = 0, reg;
+        unsigned short base_addr;
+        unsigned char dev_id;
+
+        sch311x_sio_enter(sio_config_port);
+
+        /* Check device ID. We currently know about:
+         * SCH3112 (0x7c), SCH3114 (0x7d), and SCH3116 (0x7f). */
+        reg = force_id ? force_id : sch311x_sio_inb(sio_config_port, 0x20);
+        if (!(reg == 0x7c || reg == 0x7d || reg == 0x7f)) {
+                err = -ENODEV;
+                goto exit;
+        }
+        dev_id = reg == 0x7c ? 2 : reg == 0x7d ? 4 : 6;
+
+        /* Select logical device A (runtime registers) */
+        sch311x_sio_outb(sio_config_port, 0x07, 0x0a);
+
+        /* Check if Logical Device Register is currently active */
+        if (sch311x_sio_inb(sio_config_port, 0x30) && 0x01 == 0)
+                printk(KERN_INFO PFX "Seems that LDN 0x0a is not active...\n");
+
+        /* Get the base address of the runtime registers */
+        base_addr = (sch311x_sio_inb(sio_config_port, 0x60) << 8) |
+                           sch311x_sio_inb(sio_config_port, 0x61);
+        if (!base_addr) {
+                printk(KERN_ERR PFX "Base address not set.\n");
+                err = -ENODEV;
+                goto exit;
+        }
+        *addr = base_addr;
+
+        printk(KERN_INFO PFX "Found an SMSC SCH311%d chip at 0x%04x\n",
+                dev_id, base_addr);
+
+exit:
+        sch311x_sio_exit(sio_config_port);
+        return err;
+}
+
+static int __init sch311x_wdt_init(void)
+{
+        int err, i, found = 0;
+        unsigned short addr = 0;
+
+        for (i = 0; !found && sch311x_ioports[i]; i++)
+                if (sch311x_detect(sch311x_ioports[i], &addr) == 0)
+                        found++;
+
+        if (!found)
+                return -ENODEV;
+
+        sch311x_wdt_data.runtime_reg = addr;
+
+        err = platform_driver_register(&sch311x_wdt_driver);
+        if (err)
+                return err;
+
+        sch311x_wdt_pdev = platform_device_register_simple(DRV_NAME, addr,
+                                                                NULL, 0);
+
+        if (IS_ERR(sch311x_wdt_pdev)) {
+                err = PTR_ERR(sch311x_wdt_pdev);
+                goto unreg_platform_driver;
+        }
+
+        return 0;
+
+unreg_platform_driver:
+        platform_driver_unregister(&sch311x_wdt_driver);
+        return err;
+}
+
+static void __exit sch311x_wdt_exit(void)
+{
+        platform_device_unregister(sch311x_wdt_pdev);
+        platform_driver_unregister(&sch311x_wdt_driver);
+}
+
+module_init(sch311x_wdt_init);
+module_exit(sch311x_wdt_exit);
+
+MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
+MODULE_DESCRIPTION("SMSC SCH311x WatchDog Timer Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
diff --git a/drivers/watchdog/wm8350_wdt.c b/drivers/watchdog/wm8350_wdt.c
new file mode 100644
index 000000000000..2bc0d4d4b415
--- /dev/null
+++ b/drivers/watchdog/wm8350_wdt.c
@@ -0,0 +1,329 @@
+/*
+ * Watchdog driver for the wm8350
+ *
+ * Copyright (C) 2007, 2008 Wolfson Microelectronics <linux@wolfsonmicro.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
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+#include <linux/uaccess.h>
+#include <linux/mfd/wm8350/core.h>
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static unsigned long wm8350_wdt_users;
+static struct miscdevice wm8350_wdt_miscdev;
+static int wm8350_wdt_expect_close;
+static DEFINE_MUTEX(wdt_mutex);
+
+static struct {
+        int time;  /* Seconds */
+        u16 val;   /* To be set in WM8350_SYSTEM_CONTROL_2 */
+} wm8350_wdt_cfgs[] = {
+        { 1, 0x02 },
+        { 2, 0x04 },
+        { 4, 0x05 },
+};
+
+static struct wm8350 *get_wm8350(void)
+{
+        return dev_get_drvdata(wm8350_wdt_miscdev.parent);
+}
+
+static int wm8350_wdt_set_timeout(struct wm8350 *wm8350, u16 value)
+{
+        int ret;
+        u16 reg;
+
+        mutex_lock(&wdt_mutex);
+        wm8350_reg_unlock(wm8350);
+
+        reg = wm8350_reg_read(wm8350, WM8350_SYSTEM_CONTROL_2);
+        reg &= ~WM8350_WDOG_TO_MASK;
+        reg |= value;
+        ret = wm8350_reg_write(wm8350, WM8350_SYSTEM_CONTROL_2, reg);
+
+        wm8350_reg_lock(wm8350);
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm8350_wdt_start(struct wm8350 *wm8350)
+{
+        int ret;
+        u16 reg;
+
+        mutex_lock(&wdt_mutex);
+        wm8350_reg_unlock(wm8350);
+
+        reg = wm8350_reg_read(wm8350, WM8350_SYSTEM_CONTROL_2);
+        reg &= ~WM8350_WDOG_MODE_MASK;
+        reg |= 0x20;
+        ret = wm8350_reg_write(wm8350, WM8350_SYSTEM_CONTROL_2, reg);
+
+        wm8350_reg_lock(wm8350);
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm8350_wdt_stop(struct wm8350 *wm8350)
+{
+        int ret;
+        u16 reg;
+
+        mutex_lock(&wdt_mutex);
+        wm8350_reg_unlock(wm8350);
+
+        reg = wm8350_reg_read(wm8350, WM8350_SYSTEM_CONTROL_2);
+        reg &= ~WM8350_WDOG_MODE_MASK;
+        ret = wm8350_reg_write(wm8350, WM8350_SYSTEM_CONTROL_2, reg);
+
+        wm8350_reg_lock(wm8350);
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm8350_wdt_kick(struct wm8350 *wm8350)
+{
+        int ret;
+        u16 reg;
+
+        mutex_lock(&wdt_mutex);
+
+        reg = wm8350_reg_read(wm8350, WM8350_SYSTEM_CONTROL_2);
+        ret = wm8350_reg_write(wm8350, WM8350_SYSTEM_CONTROL_2, reg);
+
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm8350_wdt_open(struct inode *inode, struct file *file)
+{
+        struct wm8350 *wm8350 = get_wm8350();
+        int ret;
+
+        if (!wm8350)
+                return -ENODEV;
+
+        if (test_and_set_bit(0, &wm8350_wdt_users))
+                return -EBUSY;
+
+        ret = wm8350_wdt_start(wm8350);
+        if (ret != 0)
+                return ret;
+
+        return nonseekable_open(inode, file);
+}
+
+static int wm8350_wdt_release(struct inode *inode, struct file *file)
+{
+        struct wm8350 *wm8350 = get_wm8350();
+
+        if (wm8350_wdt_expect_close)
+                wm8350_wdt_stop(wm8350);
+        else {
+                dev_warn(wm8350->dev, "Watchdog device closed uncleanly\n");
+                wm8350_wdt_kick(wm8350);
+        }
+
+        clear_bit(0, &wm8350_wdt_users);
+
+        return 0;
+}
+
+static ssize_t wm8350_wdt_write(struct file *file,
+                                const char __user *data, size_t count,
+                                loff_t *ppos)
+{
+        struct wm8350 *wm8350 = get_wm8350();
+        size_t i;
+
+        if (count) {
+                wm8350_wdt_kick(wm8350);
+
+                if (!nowayout) {
+                        /* In case it was set long ago */
+                        wm8350_wdt_expect_close = 0;
+
+                        /* scan to see whether or not we got the magic
+                           character */
+                        for (i = 0; i != count; i++) {
+                                char c;
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        wm8350_wdt_expect_close = 42;
+                        }
+                }
+        }
+        return count;
+}
+
+static struct watchdog_info ident = {
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
+        .identity = "WM8350 Watchdog",
+};
+
+static long wm8350_wdt_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long arg)
+{
+        struct wm8350 *wm8350 = get_wm8350();
+        int ret = -ENOTTY, time, i;
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        u16 reg;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, p);
+                break;
+
+        case WDIOC_SETOPTIONS:
+        {
+                int options;
+
+                if (get_user(options, p))
+                        return -EFAULT;
+
+                ret = -EINVAL;
+
+                /* Setting both simultaneously means at least one must fail */
+                if (options == WDIOS_DISABLECARD)
+                        ret = wm8350_wdt_start(wm8350);
+
+                if (options == WDIOS_ENABLECARD)
+                        ret = wm8350_wdt_stop(wm8350);
+                break;
+        }
+
+        case WDIOC_KEEPALIVE:
+                ret = wm8350_wdt_kick(wm8350);
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, p);
+                if (ret)
+                        break;
+
+                if (time == 0) {
+                        if (nowayout)
+                                ret = -EINVAL;
+                        else
+                                wm8350_wdt_stop(wm8350);
+                        break;
+                }
+
+                for (i = 0; i < ARRAY_SIZE(wm8350_wdt_cfgs); i++)
+                        if (wm8350_wdt_cfgs[i].time == time)
+                                break;
+                if (i == ARRAY_SIZE(wm8350_wdt_cfgs))
+                        ret = -EINVAL;
+                else
+                        ret = wm8350_wdt_set_timeout(wm8350,
+                                                     wm8350_wdt_cfgs[i].val);
+                break;
+
+        case WDIOC_GETTIMEOUT:
+                reg = wm8350_reg_read(wm8350, WM8350_SYSTEM_CONTROL_2);
+                reg &= WM8350_WDOG_TO_MASK;
+                for (i = 0; i < ARRAY_SIZE(wm8350_wdt_cfgs); i++)
+                        if (wm8350_wdt_cfgs[i].val == reg)
+                                break;
+                if (i == ARRAY_SIZE(wm8350_wdt_cfgs)) {
+                        dev_warn(wm8350->dev,
+                                 "Unknown watchdog configuration: %x\n", reg);
+                        ret = -EINVAL;
+                } else
+                        ret = put_user(wm8350_wdt_cfgs[i].time, p);
+
+        }
+
+        return ret;
+}
+
+static const struct file_operations wm8350_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = wm8350_wdt_write,
+        .unlocked_ioctl = wm8350_wdt_ioctl,
+        .open = wm8350_wdt_open,
+        .release = wm8350_wdt_release,
+};
+
+static struct miscdevice wm8350_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &wm8350_wdt_fops,
+};
+
+static int wm8350_wdt_probe(struct platform_device *pdev)
+{
+        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
+
+        if (!wm8350) {
+                dev_err(wm8350->dev, "No driver data supplied\n");
+                return -ENODEV;
+        }
+
+        /* Default to 4s timeout */
+        wm8350_wdt_set_timeout(wm8350, 0x05);
+
+        wm8350_wdt_miscdev.parent = &pdev->dev;
+
+        return misc_register(&wm8350_wdt_miscdev);
+}
+
+static int __exit wm8350_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&wm8350_wdt_miscdev);
+
+        return 0;
+}
+
+static struct platform_driver wm8350_wdt_driver = {
+        .probe = wm8350_wdt_probe,
+        .remove = wm8350_wdt_remove,
+        .driver = {
+                .name = "wm8350-wdt",
+        },
+};
+
+static int __init wm8350_wdt_init(void)
+{
+        return platform_driver_register(&wm8350_wdt_driver);
+}
+module_init(wm8350_wdt_init);
+
+static void __exit wm8350_wdt_exit(void)
+{
+        platform_driver_unregister(&wm8350_wdt_driver);
+}
+module_exit(wm8350_wdt_exit);
+
+MODULE_AUTHOR("Mark Brown");
+MODULE_DESCRIPTION("WM8350 Watchdog");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm8350-wdt");
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index f1f3f4192a60..b639dcf7c778 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -95,92 +95,55 @@ static int aout_core_dump(long signr, struct pt_regs *regs, struct file *file, u
         int has_dumped = 0;
         unsigned long dump_start, dump_size;
         struct user dump;
-#if defined(__alpha__)
+#ifdef __alpha__
 #       define START_DATA(u)    (u.start_data)
-#elif defined(__arm__)
+#else
 #       define START_DATA(u)    ((u.u_tsize << PAGE_SHIFT) + u.start_code)
-#elif defined(__sparc__)
-#       define START_DATA(u)    (u.u_tsize)
-#elif defined(__i386__) || defined(__mc68000__) || defined(__arch_um__)
-#       define START_DATA(u)    (u.u_tsize << PAGE_SHIFT)
 #endif
-#ifdef __sparc__
-#       define START_STACK(u)   ((regs->u_regs[UREG_FP]) & ~(PAGE_SIZE - 1))
-#else
 #       define START_STACK(u)   (u.start_stack)
-#endif
 
         fs = get_fs();
         set_fs(KERNEL_DS);
         has_dumped = 1;
         current->flags |= PF_DUMPCORE;
         strncpy(dump.u_comm, current->comm, sizeof(dump.u_comm));
-#ifndef __sparc__
         dump.u_ar0 = offsetof(struct user, regs);
-#endif
         dump.signal = signr;
         aout_dump_thread(regs, &dump);
 
 /* If the size of the dump file exceeds the rlimit, then see what would happen
    if we wrote the stack, but not the data area.  */
-#ifdef __sparc__
-        if ((dump.u_dsize + dump.u_ssize) > limit)
-                dump.u_dsize = 0;
-#else
         if ((dump.u_dsize + dump.u_ssize+1) * PAGE_SIZE > limit)
                 dump.u_dsize = 0;
-#endif
 
 /* Make sure we have enough room to write the stack and data areas. */
-#ifdef __sparc__
-        if (dump.u_ssize > limit)
-                dump.u_ssize = 0;
-#else
         if ((dump.u_ssize + 1) * PAGE_SIZE > limit)
                 dump.u_ssize = 0;
-#endif
 
 /* make sure we actually have a data and stack area to dump */
         set_fs(USER_DS);
-#ifdef __sparc__
-        if (!access_ok(VERIFY_READ, (void __user *)START_DATA(dump), dump.u_dsize))
-                dump.u_dsize = 0;
-        if (!access_ok(VERIFY_READ, (void __user *)START_STACK(dump), dump.u_ssize))
-                dump.u_ssize = 0;
-#else
         if (!access_ok(VERIFY_READ, (void __user *)START_DATA(dump), dump.u_dsize << PAGE_SHIFT))
                 dump.u_dsize = 0;
         if (!access_ok(VERIFY_READ, (void __user *)START_STACK(dump), dump.u_ssize << PAGE_SHIFT))
                 dump.u_ssize = 0;
-#endif
 
         set_fs(KERNEL_DS);
 /* struct user */
         DUMP_WRITE(&dump,sizeof(dump));
 /* Now dump all of the user data.  Include malloced stuff as well */
-#ifndef __sparc__
         DUMP_SEEK(PAGE_SIZE);
-#endif
 /* now we start writing out the user space info */
         set_fs(USER_DS);
 /* Dump the data area */
         if (dump.u_dsize != 0) {
                 dump_start = START_DATA(dump);
-#ifdef __sparc__
-                dump_size = dump.u_dsize;
-#else
                 dump_size = dump.u_dsize << PAGE_SHIFT;
-#endif
                 DUMP_WRITE(dump_start,dump_size);
         }
 /* Now prepare to dump the stack area */
         if (dump.u_ssize != 0) {
                 dump_start = START_STACK(dump);
-#ifdef __sparc__
-                dump_size = dump.u_ssize;
-#else
                 dump_size = dump.u_ssize << PAGE_SHIFT;
-#endif
                 DUMP_WRITE(dump_start,dump_size);
         }
 /* Finally dump the task struct.  Not be used by gdb, but could be useful */
@@ -205,29 +168,24 @@ static unsigned long __user *create_aout_tables(char __user *p, struct linux_bin
         int envc = bprm->envc;
 
         sp = (void __user *)((-(unsigned long)sizeof(char *)) & (unsigned long) p);
-#ifdef __sparc__
-        /* This imposes the proper stack alignment for a new process. */
-        sp = (void __user *) (((unsigned long) sp) & ~7);
-        if ((envc+argc+3)&1) --sp;
-#endif
 #ifdef __alpha__
 /* whee.. test-programs are so much fun. */
         put_user(0, --sp);
         put_user(0, --sp);
         if (bprm->loader) {
                 put_user(0, --sp);
-                put_user(0x3eb, --sp);
+                put_user(1003, --sp);
                 put_user(bprm->loader, --sp);
-                put_user(0x3ea, --sp);
+                put_user(1002, --sp);
         }
         put_user(bprm->exec, --sp);
-        put_user(0x3e9, --sp);
+        put_user(1001, --sp);
 #endif
         sp -= envc+1;
         envp = (char __user * __user *) sp;
         sp -= argc+1;
         argv = (char __user * __user *) sp;
-#if defined(__i386__) || defined(__mc68000__) || defined(__arm__) || defined(__arch_um__)
+#ifndef __alpha__
         put_user((unsigned long) envp,--sp);
         put_user((unsigned long) argv,--sp);
 #endif
@@ -300,13 +258,8 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                 return retval;
 
         /* OK, This is the point of no return */
-#if defined(__alpha__)
+#ifdef __alpha__
         SET_AOUT_PERSONALITY(bprm, ex);
-#elif defined(__sparc__)
-        set_personality(PER_SUNOS);
-#if !defined(__sparc_v9__)
-        memcpy(&current->thread.core_exec, &ex, sizeof(struct exec));
-#endif
 #else
         set_personality(PER_LINUX);
 #endif
@@ -322,24 +275,6 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 
         install_exec_creds(bprm);
         current->flags &= ~PF_FORKNOEXEC;
-#ifdef __sparc__
-        if (N_MAGIC(ex) == NMAGIC) {
-                loff_t pos = fd_offset;
-                /* Fuck me plenty... */
-                /* <AOL></AOL> */
-                down_write(&current->mm->mmap_sem);     
-                error = do_brk(N_TXTADDR(ex), ex.a_text);
-                up_write(&current->mm->mmap_sem);
-                bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
-                          ex.a_text, &pos);
-                down_write(&current->mm->mmap_sem);
-                error = do_brk(N_DATADDR(ex), ex.a_data);
-                up_write(&current->mm->mmap_sem);
-                bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
-                          ex.a_data, &pos);
-                goto beyond_if;
-        }
-#endif
 
         if (N_MAGIC(ex) == OMAGIC) {
                 unsigned long text_addr, map_size;
@@ -347,7 +282,7 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 
                 text_addr = N_TXTADDR(ex);
 
-#if defined(__alpha__) || defined(__sparc__)
+#ifdef __alpha__
                 pos = fd_offset;
                 map_size = ex.a_text+ex.a_data + PAGE_SIZE - 1;
 #else
diff --git a/fs/exec.c b/fs/exec.c
index dfbf7009fbe7..3ef9cf9b1871 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -57,11 +57,6 @@
 #include <asm/tlb.h>
 #include "internal.h"
 
-#ifdef __alpha__
-/* for /sbin/loader handling in search_binary_handler() */
-#include <linux/a.out.h>
-#endif
-
 int core_uses_pid;
 char core_pattern[CORENAME_MAX_SIZE] = "core";
 int suid_dumpable = 0;
@@ -1172,41 +1167,7 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
         unsigned int depth = bprm->recursion_depth;
         int try,retval;
         struct linux_binfmt *fmt;
-#ifdef __alpha__
-        /* handle /sbin/loader.. */
-        {
-            struct exec * eh = (struct exec *) bprm->buf;
 
-            if (!bprm->loader && eh->fh.f_magic == 0x183 &&
-                (eh->fh.f_flags & 0x3000) == 0x3000)
-            {
-                struct file * file;
-                unsigned long loader;
-
-                allow_write_access(bprm->file);
-                fput(bprm->file);
-                bprm->file = NULL;
-
-                loader = bprm->vma->vm_end - sizeof(void *);
-
-                file = open_exec("/sbin/loader");
-                retval = PTR_ERR(file);
-                if (IS_ERR(file))
-                        return retval;
-
-                /* Remember if the application is TASO.  */
-                bprm->taso = eh->ah.entry < 0x100000000UL;
-
-                bprm->file = file;
-                bprm->loader = loader;
-                retval = prepare_binprm(bprm);
-                if (retval<0)
-                        return retval;
-                /* should call search_binary_handler recursively here,
-                   but it does not matter */
-            }
-        }
-#endif
         retval = security_bprm_check(bprm);
         if (retval)
                 return retval;
diff --git a/fs/ubifs/budget.c b/fs/ubifs/budget.c
index 4a18f084cc42..0e5e54d82924 100644
--- a/fs/ubifs/budget.c
+++ b/fs/ubifs/budget.c
@@ -32,18 +32,15 @@
 
 #include "ubifs.h"
 #include <linux/writeback.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 
 /*
  * When pessimistic budget calculations say that there is no enough space,
  * UBIFS starts writing back dirty inodes and pages, doing garbage collection,
- * or committing. The below constants define maximum number of times UBIFS
+ * or committing. The below constant defines maximum number of times UBIFS
  * repeats the operations.
  */
-#define MAX_SHRINK_RETRIES 8
-#define MAX_GC_RETRIES     4
-#define MAX_CMT_RETRIES    2
-#define MAX_NOSPC_RETRIES  1
+#define MAX_MKSPC_RETRIES 3
 
 /*
  * The below constant defines amount of dirty pages which should be written
@@ -52,30 +49,6 @@
 #define NR_TO_WRITE 16
 
 /**
- * struct retries_info - information about re-tries while making free space.
- * @prev_liability: previous liability
- * @shrink_cnt: how many times the liability was shrinked
- * @shrink_retries: count of liability shrink re-tries (increased when
- *                  liability does not shrink)
- * @try_gc: GC should be tried first
- * @gc_retries: how many times GC was run
- * @cmt_retries: how many times commit has been done
- * @nospc_retries: how many times GC returned %-ENOSPC
- *
- * Since we consider budgeting to be the fast-path, and this structure has to
- * be allocated on stack and zeroed out, we make it smaller using bit-fields.
- */
-struct retries_info {
-        long long prev_liability;
-        unsigned int shrink_cnt;
-        unsigned int shrink_retries:5;
-        unsigned int try_gc:1;
-        unsigned int gc_retries:4;
-        unsigned int cmt_retries:3;
-        unsigned int nospc_retries:1;
-};
-
-/**
  * shrink_liability - write-back some dirty pages/inodes.
  * @c: UBIFS file-system description object
  * @nr_to_write: how many dirty pages to write-back
@@ -147,9 +120,25 @@ static int run_gc(struct ubifs_info *c)
 }
 
 /**
+ * get_liability - calculate current liability.
+ * @c: UBIFS file-system description object
+ *
+ * This function calculates and returns current UBIFS liability, i.e. the
+ * amount of bytes UBIFS has "promised" to write to the media.
+ */
+static long long get_liability(struct ubifs_info *c)
+{
+        long long liab;
+
+        spin_lock(&c->space_lock);
+        liab = c->budg_idx_growth + c->budg_data_growth + c->budg_dd_growth;
+        spin_unlock(&c->space_lock);
+        return liab;
+}
+
+/**
  * make_free_space - make more free space on the file-system.
  * @c: UBIFS file-system description object
- * @ri: information about previous invocations of this function
  *
  * This function is called when an operation cannot be budgeted because there
  * is supposedly no free space. But in most cases there is some free space:
@@ -165,87 +154,42 @@ static int run_gc(struct ubifs_info *c)
  * Returns %-ENOSPC if it couldn't do more free space, and other negative error
  * codes on failures.
  */
-static int make_free_space(struct ubifs_info *c, struct retries_info *ri)
+static int make_free_space(struct ubifs_info *c)
 {
-        int err;
-
-        /*
-         * If we have some dirty pages and inodes (liability), try to write
-         * them back unless this was tried too many times without effect
-         * already.
-         */
-        if (ri->shrink_retries < MAX_SHRINK_RETRIES && !ri->try_gc) {
-                long long liability;
-
-                spin_lock(&c->space_lock);
-                liability = c->budg_idx_growth + c->budg_data_growth +
-                            c->budg_dd_growth;
-                spin_unlock(&c->space_lock);
+        int err, retries = 0;
+        long long liab1, liab2;
 
-                if (ri->prev_liability >= liability) {
-                        /* Liability does not shrink, next time try GC then */
-                        ri->shrink_retries += 1;
-                        if (ri->gc_retries < MAX_GC_RETRIES)
-                                ri->try_gc = 1;
-                        dbg_budg("liability did not shrink: retries %d of %d",
-                                 ri->shrink_retries, MAX_SHRINK_RETRIES);
-                }
+        do {
+                liab1 = get_liability(c);
+                /*
+                 * We probably have some dirty pages or inodes (liability), try
+                 * to write them back.
+                 */
+                dbg_budg("liability %lld, run write-back", liab1);
+                shrink_liability(c, NR_TO_WRITE);
 
-                dbg_budg("force write-back (count %d)", ri->shrink_cnt);
-                shrink_liability(c, NR_TO_WRITE + ri->shrink_cnt);
+                liab2 = get_liability(c);
+                if (liab2 < liab1)
+                        return -EAGAIN;
 
-                ri->prev_liability = liability;
-                ri->shrink_cnt += 1;
-                return -EAGAIN;
-        }
+                dbg_budg("new liability %lld (not shrinked)", liab2);
 
-        /*
-         * Try to run garbage collector unless it was already tried too many
-         * times.
-         */
-        if (ri->gc_retries < MAX_GC_RETRIES) {
-                ri->gc_retries += 1;
-                dbg_budg("run GC, retries %d of %d",
-                         ri->gc_retries, MAX_GC_RETRIES);
-
-                ri->try_gc = 0;
+                /* Liability did not shrink again, try GC */
+                dbg_budg("Run GC");
                 err = run_gc(c);
                 if (!err)
                         return -EAGAIN;
 
-                if (err == -EAGAIN) {
-                        dbg_budg("GC asked to commit");
-                        err = ubifs_run_commit(c);
-                        if (err)
-                                return err;
-                        return -EAGAIN;
-                }
-
-                if (err != -ENOSPC)
-                        return err;
-
-                /*
-                 * GC could not make any progress. If this is the first time,
-                 * then it makes sense to try to commit, because it might make
-                 * some dirty space.
-                 */
-                dbg_budg("GC returned -ENOSPC, retries %d",
-                         ri->nospc_retries);
-                if (ri->nospc_retries >= MAX_NOSPC_RETRIES)
+                if (err != -EAGAIN && err != -ENOSPC)
+                        /* Some real error happened */
                         return err;
-                ri->nospc_retries += 1;
-        }
 
-        /* Neither GC nor write-back helped, try to commit */
-        if (ri->cmt_retries < MAX_CMT_RETRIES) {
-                ri->cmt_retries += 1;
-                dbg_budg("run commit, retries %d of %d",
-                         ri->cmt_retries, MAX_CMT_RETRIES);
+                dbg_budg("Run commit (retries %d)", retries);
                 err = ubifs_run_commit(c);
                 if (err)
                         return err;
-                return -EAGAIN;
-        }
+        } while (retries++ < MAX_MKSPC_RETRIES);
+
         return -ENOSPC;
 }
 
@@ -258,8 +202,8 @@ static int make_free_space(struct ubifs_info *c, struct retries_info *ri)
  */
 int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
 {
-        int ret;
-        uint64_t idx_size;
+        int idx_lebs, eff_leb_size = c->leb_size - c->max_idx_node_sz;
+        long long idx_size;
 
         idx_size = c->old_idx_sz + c->budg_idx_growth + c->budg_uncommitted_idx;
 
@@ -271,23 +215,16 @@ int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
          * pair, nor similarly the two variables for the new index size, so we
          * have to do this costly 64-bit division on fast-path.
          */
-        if (do_div(idx_size, c->leb_size - c->max_idx_node_sz))
-                ret = idx_size + 1;
-        else
-                ret = idx_size;
+        idx_size += eff_leb_size - 1;
+        idx_lebs = div_u64(idx_size, eff_leb_size);
         /*
          * The index head is not available for the in-the-gaps method, so add an
          * extra LEB to compensate.
          */
-        ret += 1;
-        /*
-         * At present the index needs at least 2 LEBs: one for the index head
-         * and one for in-the-gaps method (which currently does not cater for
-         * the index head and so excludes it from consideration).
-         */
-        if (ret < 2)
-                ret = 2;
-        return ret;
+        idx_lebs += 1;
+        if (idx_lebs < MIN_INDEX_LEBS)
+                idx_lebs = MIN_INDEX_LEBS;
+        return idx_lebs;
 }
 
 /**
@@ -530,8 +467,7 @@ static int calc_dd_growth(const struct ubifs_info *c,
 int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req)
 {
         int uninitialized_var(cmt_retries), uninitialized_var(wb_retries);
-        int err, idx_growth, data_growth, dd_growth;
-        struct retries_info ri;
+        int err, idx_growth, data_growth, dd_growth, retried = 0;
 
         ubifs_assert(req->new_page <= 1);
         ubifs_assert(req->dirtied_page <= 1);
@@ -549,7 +485,6 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req)
         if (!data_growth && !dd_growth)
                 return 0;
         idx_growth = calc_idx_growth(c, req);
-        memset(&ri, 0, sizeof(struct retries_info));
 
 again:
         spin_lock(&c->space_lock);
@@ -587,12 +522,17 @@ again:
                 return err;
         }
 
-        err = make_free_space(c, &ri);
+        err = make_free_space(c);
+        cond_resched();
         if (err == -EAGAIN) {
                 dbg_budg("try again");
-                cond_resched();
                 goto again;
         } else if (err == -ENOSPC) {
+                if (!retried) {
+                        retried = 1;
+                        dbg_budg("-ENOSPC, but anyway try once again");
+                        goto again;
+                }
                 dbg_budg("FS is full, -ENOSPC");
                 c->nospace = 1;
                 if (can_use_rp(c) || c->rp_size == 0)
@@ -712,9 +652,9 @@ void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
  * user-space. User-space application tend to expect that if the file-system
  * (e.g., via the 'statfs()' call) reports that it has N bytes available, they
  * are able to write a file of size N. UBIFS attaches node headers to each data
- * node and it has to write indexind nodes as well. This introduces additional
- * overhead, and UBIFS it has to report sligtly less free space to meet the
- * above expectetion.
+ * node and it has to write indexing nodes as well. This introduces additional
+ * overhead, and UBIFS has to report slightly less free space to meet the above
+ * expectations.
  *
  * This function assumes free space is made up of uncompressed data nodes and
  * full index nodes (one per data node, tripled because we always allow enough
@@ -723,7 +663,7 @@ void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
  * Note, the calculation is pessimistic, which means that most of the time
  * UBIFS reports less space than it actually has.
  */
-long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
+long long ubifs_reported_space(const struct ubifs_info *c, long long free)
 {
         int divisor, factor, f;
 
@@ -737,7 +677,7 @@ long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
          * of data nodes, f - fanout. Because effective UBIFS fanout is twice
          * as less than maximum fanout, we assume that each data node
          * introduces 3 * @c->max_idx_node_sz / (@c->fanout/2 - 1) bytes.
-         * Note, the multiplier 3 is because UBIFS reseves thrice as more space
+         * Note, the multiplier 3 is because UBIFS reserves thrice as more space
          * for the index.
          */
         f = c->fanout > 3 ? c->fanout >> 1 : 2;
@@ -745,8 +685,7 @@ long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
         divisor = UBIFS_MAX_DATA_NODE_SZ;
         divisor += (c->max_idx_node_sz * 3) / (f - 1);
         free *= factor;
-        do_div(free, divisor);
-        return free;
+        return div_u64(free, divisor);
 }
 
 /**
@@ -756,10 +695,10 @@ long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free)
  * This function calculates amount of free space to report to user-space.
  *
  * Because UBIFS may introduce substantial overhead (the index, node headers,
- * alighment, wastage at the end of eraseblocks, etc), it cannot report real
+ * alignment, wastage at the end of eraseblocks, etc), it cannot report real
  * amount of free flash space it has (well, because not all dirty space is
- * reclamable, UBIFS does not actually know the real amount). If UBIFS did so,
- * it would bread user expectetion about what free space is. Users seem to
+ * reclaimable, UBIFS does not actually know the real amount). If UBIFS did so,
+ * it would bread user expectations about what free space is. Users seem to
  * accustomed to assume that if the file-system reports N bytes of free space,
  * they would be able to fit a file of N bytes to the FS. This almost works for
  * traditional file-systems, because they have way less overhead than UBIFS.
@@ -771,18 +710,9 @@ long long ubifs_get_free_space(struct ubifs_info *c)
         long long available, outstanding, free;
 
         spin_lock(&c->space_lock);
-        min_idx_lebs = ubifs_calc_min_idx_lebs(c);
+        min_idx_lebs = c->min_idx_lebs;
+        ubifs_assert(min_idx_lebs == ubifs_calc_min_idx_lebs(c));
         outstanding = c->budg_data_growth + c->budg_dd_growth;
-
-        /*
-         * Force the amount available to the total size reported if the used
-         * space is zero.
-         */
-        if (c->lst.total_used <= UBIFS_INO_NODE_SZ && !outstanding) {
-                spin_unlock(&c->space_lock);
-                return (long long)c->block_cnt << UBIFS_BLOCK_SHIFT;
-        }
-
         available = ubifs_calc_available(c, min_idx_lebs);
 
         /*
diff --git a/fs/ubifs/commit.c b/fs/ubifs/commit.c
index b49884c8c10e..f3a7945527fb 100644
--- a/fs/ubifs/commit.c
+++ b/fs/ubifs/commit.c
@@ -470,12 +470,12 @@ int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot)
 {
         struct ubifs_idx_node *idx;
         int lnum, offs, len, err = 0;
+        struct ubifs_debug_info *d = c->dbg;
 
-        c->old_zroot = *zroot;
-
-        lnum = c->old_zroot.lnum;
-        offs = c->old_zroot.offs;
-        len = c->old_zroot.len;
+        d->old_zroot = *zroot;
+        lnum = d->old_zroot.lnum;
+        offs = d->old_zroot.offs;
+        len = d->old_zroot.len;
 
         idx = kmalloc(c->max_idx_node_sz, GFP_NOFS);
         if (!idx)
@@ -485,8 +485,8 @@ int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot)
         if (err)
                 goto out;
 
-        c->old_zroot_level = le16_to_cpu(idx->level);
-        c->old_zroot_sqnum = le64_to_cpu(idx->ch.sqnum);
+        d->old_zroot_level = le16_to_cpu(idx->level);
+        d->old_zroot_sqnum = le64_to_cpu(idx->ch.sqnum);
 out:
         kfree(idx);
         return err;
@@ -509,6 +509,7 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
 {
         int lnum, offs, len, err = 0, uninitialized_var(last_level), child_cnt;
         int first = 1, iip;
+        struct ubifs_debug_info *d = c->dbg;
         union ubifs_key lower_key, upper_key, l_key, u_key;
         unsigned long long uninitialized_var(last_sqnum);
         struct ubifs_idx_node *idx;
@@ -525,9 +526,9 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
              UBIFS_IDX_NODE_SZ;
 
         /* Start at the old zroot */
-        lnum = c->old_zroot.lnum;
-        offs = c->old_zroot.offs;
-        len = c->old_zroot.len;
+        lnum = d->old_zroot.lnum;
+        offs = d->old_zroot.offs;
+        len = d->old_zroot.len;
         iip = 0;
 
         /*
@@ -560,11 +561,11 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
                 if (first) {
                         first = 0;
                         /* Check root level and sqnum */
-                        if (le16_to_cpu(idx->level) != c->old_zroot_level) {
+                        if (le16_to_cpu(idx->level) != d->old_zroot_level) {
                                 err = 2;
                                 goto out_dump;
                         }
-                        if (le64_to_cpu(idx->ch.sqnum) != c->old_zroot_sqnum) {
+                        if (le64_to_cpu(idx->ch.sqnum) != d->old_zroot_sqnum) {
                                 err = 3;
                                 goto out_dump;
                         }
diff --git a/fs/ubifs/compress.c b/fs/ubifs/compress.c
index a0ada596b17c..11e4132f314a 100644
--- a/fs/ubifs/compress.c
+++ b/fs/ubifs/compress.c
@@ -33,7 +33,7 @@
 /* Fake description object for the "none" compressor */
 static struct ubifs_compressor none_compr = {
         .compr_type = UBIFS_COMPR_NONE,
-        .name = "no compression",
+        .name = "none",
         .capi_name = "",
 };
 
@@ -43,13 +43,13 @@ static DEFINE_MUTEX(lzo_mutex);
 static struct ubifs_compressor lzo_compr = {
         .compr_type = UBIFS_COMPR_LZO,
         .comp_mutex = &lzo_mutex,
-        .name = "LZO",
+        .name = "lzo",
         .capi_name = "lzo",
 };
 #else
 static struct ubifs_compressor lzo_compr = {
         .compr_type = UBIFS_COMPR_LZO,
-        .name = "LZO",
+        .name = "lzo",
 };
 #endif
 
@@ -108,7 +108,7 @@ void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,
         if (compr->comp_mutex)
                 mutex_lock(compr->comp_mutex);
         err = crypto_comp_compress(compr->cc, in_buf, in_len, out_buf,
-                                   out_len);
+                                   (unsigned int *)out_len);
         if (compr->comp_mutex)
                 mutex_unlock(compr->comp_mutex);
         if (unlikely(err)) {
@@ -119,10 +119,10 @@ void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,
         }
 
         /*
-         * Presently, we just require that compression results in less data,
-         * rather than any defined minimum compression ratio or amount.
+         * If the data compressed only slightly, it is better to leave it
+         * uncompressed to improve read speed.
          */
-        if (ALIGN(*out_len, 8) >= ALIGN(in_len, 8))
+        if (in_len - *out_len < UBIFS_MIN_COMPRESS_DIFF)
                 goto no_compr;
 
         return;
@@ -172,7 +172,7 @@ int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
         if (compr->decomp_mutex)
                 mutex_lock(compr->decomp_mutex);
         err = crypto_comp_decompress(compr->cc, in_buf, in_len, out_buf,
-                                     out_len);
+                                     (unsigned int *)out_len);
         if (compr->decomp_mutex)
                 mutex_unlock(compr->decomp_mutex);
         if (err)
@@ -244,7 +244,7 @@ out_lzo:
 /**
  * ubifs_compressors_exit - de-initialize UBIFS compressors.
  */
-void __exit ubifs_compressors_exit(void)
+void ubifs_compressors_exit(void)
 {
         compr_exit(&lzo_compr);
         compr_exit(&zlib_compr);
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 510ffa0bbda4..792c5a16c182 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -32,6 +32,8 @@
 #include "ubifs.h"
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/debugfs.h>
+#include <linux/math64.h>
 
 #ifdef CONFIG_UBIFS_FS_DEBUG
 
@@ -596,7 +598,9 @@ void dbg_dump_budg(struct ubifs_info *c)
         struct rb_node *rb;
         struct ubifs_bud *bud;
         struct ubifs_gced_idx_leb *idx_gc;
+        long long available, outstanding, free;
 
+        ubifs_assert(spin_is_locked(&c->space_lock));
         spin_lock(&dbg_lock);
         printk(KERN_DEBUG "(pid %d) Budgeting info: budg_data_growth %lld, "
                "budg_dd_growth %lld, budg_idx_growth %lld\n", current->pid,
@@ -629,6 +633,17 @@ void dbg_dump_budg(struct ubifs_info *c)
                 printk(KERN_DEBUG "\tGC'ed idx LEB %d unmap %d\n",
                        idx_gc->lnum, idx_gc->unmap);
         printk(KERN_DEBUG "\tcommit state %d\n", c->cmt_state);
+
+        /* Print budgeting predictions */
+        available = ubifs_calc_available(c, c->min_idx_lebs);
+        outstanding = c->budg_data_growth + c->budg_dd_growth;
+        if (available > outstanding)
+                free = ubifs_reported_space(c, available - outstanding);
+        else
+                free = 0;
+        printk(KERN_DEBUG "Budgeting predictions:\n");
+        printk(KERN_DEBUG "\tavailable: %lld, outstanding %lld, free %lld\n",
+               available, outstanding, free);
         spin_unlock(&dbg_lock);
 }
 
@@ -645,7 +660,8 @@ void dbg_dump_lprops(struct ubifs_info *c)
         struct ubifs_lprops lp;
         struct ubifs_lp_stats lst;
 
-        printk(KERN_DEBUG "(pid %d) Dumping LEB properties\n", current->pid);
+        printk(KERN_DEBUG "(pid %d) start dumping LEB properties\n",
+               current->pid);
         ubifs_get_lp_stats(c, &lst);
         dbg_dump_lstats(&lst);
 
@@ -656,6 +672,8 @@ void dbg_dump_lprops(struct ubifs_info *c)
 
                 dbg_dump_lprop(c, &lp);
         }
+        printk(KERN_DEBUG "(pid %d) finish dumping LEB properties\n",
+               current->pid);
 }
 
 void dbg_dump_lpt_info(struct ubifs_info *c)
@@ -663,6 +681,7 @@ void dbg_dump_lpt_info(struct ubifs_info *c)
         int i;
 
         spin_lock(&dbg_lock);
+        printk(KERN_DEBUG "(pid %d) dumping LPT information\n", current->pid);
         printk(KERN_DEBUG "\tlpt_sz:        %lld\n", c->lpt_sz);
         printk(KERN_DEBUG "\tpnode_sz:      %d\n", c->pnode_sz);
         printk(KERN_DEBUG "\tnnode_sz:      %d\n", c->nnode_sz);
@@ -684,7 +703,8 @@ void dbg_dump_lpt_info(struct ubifs_info *c)
         printk(KERN_DEBUG "\tLPT root is at %d:%d\n", c->lpt_lnum, c->lpt_offs);
         printk(KERN_DEBUG "\tLPT head is at %d:%d\n",
                c->nhead_lnum, c->nhead_offs);
-        printk(KERN_DEBUG "\tLPT ltab is at %d:%d\n", c->ltab_lnum, c->ltab_offs);
+        printk(KERN_DEBUG "\tLPT ltab is at %d:%d\n",
+               c->ltab_lnum, c->ltab_offs);
         if (c->big_lpt)
                 printk(KERN_DEBUG "\tLPT lsave is at %d:%d\n",
                        c->lsave_lnum, c->lsave_offs);
@@ -703,9 +723,9 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
         if (dbg_failure_mode)
                 return;
 
-        printk(KERN_DEBUG "(pid %d) Dumping LEB %d\n", current->pid, lnum);
-
-        sleb = ubifs_scan(c, lnum, 0, c->dbg_buf);
+        printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
+               current->pid, lnum);
+        sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
         if (IS_ERR(sleb)) {
                 ubifs_err("scan error %d", (int)PTR_ERR(sleb));
                 return;
@@ -721,6 +741,8 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
                 dbg_dump_node(c, snod->node);
         }
 
+        printk(KERN_DEBUG "(pid %d) finish dumping LEB %d\n",
+               current->pid, lnum);
         ubifs_scan_destroy(sleb);
         return;
 }
@@ -768,7 +790,7 @@ void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)
 {
         int i;
 
-        printk(KERN_DEBUG "(pid %d) Dumping heap cat %d (%d elements)\n",
+        printk(KERN_DEBUG "(pid %d) start dumping heap cat %d (%d elements)\n",
                current->pid, cat, heap->cnt);
         for (i = 0; i < heap->cnt; i++) {
                 struct ubifs_lprops *lprops = heap->arr[i];
@@ -777,6 +799,7 @@ void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)
                        "flags %d\n", i, lprops->lnum, lprops->hpos,
                        lprops->free, lprops->dirty, lprops->flags);
         }
+        printk(KERN_DEBUG "(pid %d) finish dumping heap\n", current->pid);
 }
 
 void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
@@ -784,7 +807,7 @@ void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
 {
         int i;
 
-        printk(KERN_DEBUG "(pid %d) Dumping pnode:\n", current->pid);
+        printk(KERN_DEBUG "(pid %d) dumping pnode:\n", current->pid);
         printk(KERN_DEBUG "\taddress %zx parent %zx cnext %zx\n",
                (size_t)pnode, (size_t)parent, (size_t)pnode->cnext);
         printk(KERN_DEBUG "\tflags %lu iip %d level %d num %d\n",
@@ -803,7 +826,7 @@ void dbg_dump_tnc(struct ubifs_info *c)
         int level;
 
         printk(KERN_DEBUG "\n");
-        printk(KERN_DEBUG "(pid %d) Dumping the TNC tree\n", current->pid);
+        printk(KERN_DEBUG "(pid %d) start dumping TNC tree\n", current->pid);
         znode = ubifs_tnc_levelorder_next(c->zroot.znode, NULL);
         level = znode->level;
         printk(KERN_DEBUG "== Level %d ==\n", level);
@@ -815,8 +838,7 @@ void dbg_dump_tnc(struct ubifs_info *c)
                 dbg_dump_znode(c, znode);
                 znode = ubifs_tnc_levelorder_next(c->zroot.znode, znode);
         }
-
-        printk(KERN_DEBUG "\n");
+        printk(KERN_DEBUG "(pid %d) finish dumping TNC tree\n", current->pid);
 }
 
 static int dump_znode(struct ubifs_info *c, struct ubifs_znode *znode,
@@ -992,8 +1014,8 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
                         zbr1->offs, DBGKEY(&key));
                 dbg_err("but it should have key %s according to tnc",
                         DBGKEY(&zbr1->key));
-                        dbg_dump_node(c, dent1);
-                        goto out_free;
+                dbg_dump_node(c, dent1);
+                goto out_free;
         }
 
         key_read(c, &dent2->key, &key);
@@ -1002,8 +1024,8 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
                         zbr1->offs, DBGKEY(&key));
                 dbg_err("but it should have key %s according to tnc",
                         DBGKEY(&zbr2->key));
-                        dbg_dump_node(c, dent2);
-                        goto out_free;
+                dbg_dump_node(c, dent2);
+                goto out_free;
         }
 
         nlen1 = le16_to_cpu(dent1->nlen);
@@ -1020,9 +1042,9 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1,
                 dbg_err("bad order of colliding key %s",
                         DBGKEY(&key));
 
-        dbg_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs);
+        ubifs_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs);
         dbg_dump_node(c, dent1);
-        dbg_msg("second node at %d:%d\n", zbr2->lnum, zbr2->offs);
+        ubifs_msg("second node at %d:%d\n", zbr2->lnum, zbr2->offs);
         dbg_dump_node(c, dent2);
 
 out_free:
@@ -2097,13 +2119,13 @@ static int simple_rand(void)
         return (next >> 16) & 32767;
 }
 
-void dbg_failure_mode_registration(struct ubifs_info *c)
+static void failure_mode_init(struct ubifs_info *c)
 {
         struct failure_mode_info *fmi;
 
         fmi = kmalloc(sizeof(struct failure_mode_info), GFP_NOFS);
         if (!fmi) {
-                dbg_err("Failed to register failure mode - no memory");
+                ubifs_err("Failed to register failure mode - no memory");
                 return;
         }
         fmi->c = c;
@@ -2112,7 +2134,7 @@ void dbg_failure_mode_registration(struct ubifs_info *c)
         spin_unlock(&fmi_lock);
 }
 
-void dbg_failure_mode_deregistration(struct ubifs_info *c)
+static void failure_mode_exit(struct ubifs_info *c)
 {
         struct failure_mode_info *fmi, *tmp;
 
@@ -2146,42 +2168,44 @@ static int in_failure_mode(struct ubi_volume_desc *desc)
         struct ubifs_info *c = dbg_find_info(desc);
 
         if (c && dbg_failure_mode)
-                return c->failure_mode;
+                return c->dbg->failure_mode;
         return 0;
 }
 
 static int do_fail(struct ubi_volume_desc *desc, int lnum, int write)
 {
         struct ubifs_info *c = dbg_find_info(desc);
+        struct ubifs_debug_info *d;
 
         if (!c || !dbg_failure_mode)
                 return 0;
-        if (c->failure_mode)
+        d = c->dbg;
+        if (d->failure_mode)
                 return 1;
-        if (!c->fail_cnt) {
+        if (!d->fail_cnt) {
                 /* First call - decide delay to failure */
                 if (chance(1, 2)) {
                         unsigned int delay = 1 << (simple_rand() >> 11);
 
                         if (chance(1, 2)) {
-                                c->fail_delay = 1;
-                                c->fail_timeout = jiffies +
+                                d->fail_delay = 1;
+                                d->fail_timeout = jiffies +
                                                   msecs_to_jiffies(delay);
                                 dbg_rcvry("failing after %ums", delay);
                         } else {
-                                c->fail_delay = 2;
-                                c->fail_cnt_max = delay;
+                                d->fail_delay = 2;
+                                d->fail_cnt_max = delay;
                                 dbg_rcvry("failing after %u calls", delay);
                         }
                 }
-                c->fail_cnt += 1;
+                d->fail_cnt += 1;
         }
         /* Determine if failure delay has expired */
-        if (c->fail_delay == 1) {
-                if (time_before(jiffies, c->fail_timeout))
+        if (d->fail_delay == 1) {
+                if (time_before(jiffies, d->fail_timeout))
                         return 0;
-        } else if (c->fail_delay == 2)
-                if (c->fail_cnt++ < c->fail_cnt_max)
+        } else if (d->fail_delay == 2)
+                if (d->fail_cnt++ < d->fail_cnt_max)
                         return 0;
         if (lnum == UBIFS_SB_LNUM) {
                 if (write) {
@@ -2239,7 +2263,7 @@ static int do_fail(struct ubi_volume_desc *desc, int lnum, int write)
                 dbg_rcvry("failing in bud LEB %d commit not running", lnum);
         }
         ubifs_err("*** SETTING FAILURE MODE ON (LEB %d) ***", lnum);
-        c->failure_mode = 1;
+        d->failure_mode = 1;
         dump_stack();
         return 1;
 }
@@ -2344,4 +2368,181 @@ int dbg_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype)
         return 0;
 }
 
+/**
+ * ubifs_debugging_init - initialize UBIFS debugging.
+ * @c: UBIFS file-system description object
+ *
+ * This function initializes debugging-related data for the file system.
+ * Returns zero in case of success and a negative error code in case of
+ * failure.
+ */
+int ubifs_debugging_init(struct ubifs_info *c)
+{
+        c->dbg = kzalloc(sizeof(struct ubifs_debug_info), GFP_KERNEL);
+        if (!c->dbg)
+                return -ENOMEM;
+
+        c->dbg->buf = vmalloc(c->leb_size);
+        if (!c->dbg->buf)
+                goto out;
+
+        failure_mode_init(c);
+        return 0;
+
+out:
+        kfree(c->dbg);
+        return -ENOMEM;
+}
+
+/**
+ * ubifs_debugging_exit - free debugging data.
+ * @c: UBIFS file-system description object
+ */
+void ubifs_debugging_exit(struct ubifs_info *c)
+{
+        failure_mode_exit(c);
+        vfree(c->dbg->buf);
+        kfree(c->dbg);
+}
+
+/*
+ * Root directory for UBIFS stuff in debugfs. Contains sub-directories which
+ * contain the stuff specific to particular file-system mounts.
+ */
+static struct dentry *debugfs_rootdir;
+
+/**
+ * dbg_debugfs_init - initialize debugfs file-system.
+ *
+ * UBIFS uses debugfs file-system to expose various debugging knobs to
+ * user-space. This function creates "ubifs" directory in the debugfs
+ * file-system. Returns zero in case of success and a negative error code in
+ * case of failure.
+ */
+int dbg_debugfs_init(void)
+{
+        debugfs_rootdir = debugfs_create_dir("ubifs", NULL);
+        if (IS_ERR(debugfs_rootdir)) {
+                int err = PTR_ERR(debugfs_rootdir);
+                ubifs_err("cannot create \"ubifs\" debugfs directory, "
+                          "error %d\n", err);
+                return err;
+        }
+
+        return 0;
+}
+
+/**
+ * dbg_debugfs_exit - remove the "ubifs" directory from debugfs file-system.
+ */
+void dbg_debugfs_exit(void)
+{
+        debugfs_remove(debugfs_rootdir);
+}
+
+static int open_debugfs_file(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+
+static ssize_t write_debugfs_file(struct file *file, const char __user *buf,
+                                  size_t count, loff_t *ppos)
+{
+        struct ubifs_info *c = file->private_data;
+        struct ubifs_debug_info *d = c->dbg;
+
+        if (file->f_path.dentry == d->dump_lprops)
+                dbg_dump_lprops(c);
+        else if (file->f_path.dentry == d->dump_budg) {
+                spin_lock(&c->space_lock);
+                dbg_dump_budg(c);
+                spin_unlock(&c->space_lock);
+        } else if (file->f_path.dentry == d->dump_tnc) {
+                mutex_lock(&c->tnc_mutex);
+                dbg_dump_tnc(c);
+                mutex_unlock(&c->tnc_mutex);
+        } else
+                return -EINVAL;
+
+        *ppos += count;
+        return count;
+}
+
+static const struct file_operations debugfs_fops = {
+        .open = open_debugfs_file,
+        .write = write_debugfs_file,
+        .owner = THIS_MODULE,
+};
+
+/**
+ * dbg_debugfs_init_fs - initialize debugfs for UBIFS instance.
+ * @c: UBIFS file-system description object
+ *
+ * This function creates all debugfs files for this instance of UBIFS. Returns
+ * zero in case of success and a negative error code in case of failure.
+ *
+ * Note, the only reason we have not merged this function with the
+ * 'ubifs_debugging_init()' function is because it is better to initialize
+ * debugfs interfaces at the very end of the mount process, and remove them at
+ * the very beginning of the mount process.
+ */
+int dbg_debugfs_init_fs(struct ubifs_info *c)
+{
+        int err;
+        const char *fname;
+        struct dentry *dent;
+        struct ubifs_debug_info *d = c->dbg;
+
+        sprintf(d->debugfs_dir_name, "ubi%d_%d", c->vi.ubi_num, c->vi.vol_id);
+        d->debugfs_dir = debugfs_create_dir(d->debugfs_dir_name,
+                                              debugfs_rootdir);
+        if (IS_ERR(d->debugfs_dir)) {
+                err = PTR_ERR(d->debugfs_dir);
+                ubifs_err("cannot create \"%s\" debugfs directory, error %d\n",
+                          d->debugfs_dir_name, err);
+                goto out;
+        }
+
+        fname = "dump_lprops";
+        dent = debugfs_create_file(fname, S_IWUGO, d->debugfs_dir, c,
+                                   &debugfs_fops);
+        if (IS_ERR(dent))
+                goto out_remove;
+        d->dump_lprops = dent;
+
+        fname = "dump_budg";
+        dent = debugfs_create_file(fname, S_IWUGO, d->debugfs_dir, c,
+                                   &debugfs_fops);
+        if (IS_ERR(dent))
+                goto out_remove;
+        d->dump_budg = dent;
+
+        fname = "dump_tnc";
+        dent = debugfs_create_file(fname, S_IWUGO, d->debugfs_dir, c,
+                                   &debugfs_fops);
+        if (IS_ERR(dent))
+                goto out_remove;
+        d->dump_tnc = dent;
+
+        return 0;
+
+out_remove:
+        err = PTR_ERR(dent);
+        ubifs_err("cannot create \"%s\" debugfs directory, error %d\n",
+                  fname, err);
+        debugfs_remove_recursive(d->debugfs_dir);
+out:
+        return err;
+}
+
+/**
+ * dbg_debugfs_exit_fs - remove all debugfs files.
+ * @c: UBIFS file-system description object
+ */
+void dbg_debugfs_exit_fs(struct ubifs_info *c)
+{
+        debugfs_remove_recursive(c->dbg->debugfs_dir);
+}
+
 #endif /* CONFIG_UBIFS_FS_DEBUG */
diff --git a/fs/ubifs/debug.h b/fs/ubifs/debug.h
index 33d6b95071e4..9820d6999f7e 100644
--- a/fs/ubifs/debug.h
+++ b/fs/ubifs/debug.h
@@ -25,7 +25,56 @@
 
 #ifdef CONFIG_UBIFS_FS_DEBUG
 
-#define UBIFS_DBG(op) op
+/**
+ * ubifs_debug_info - per-FS debugging information.
+ * @buf: a buffer of LEB size, used for various purposes
+ * @old_zroot: old index root - used by 'dbg_check_old_index()'
+ * @old_zroot_level: old index root level - used by 'dbg_check_old_index()'
+ * @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()'
+ * @failure_mode: failure mode for recovery testing
+ * @fail_delay: 0=>don't delay, 1=>delay a time, 2=>delay a number of calls
+ * @fail_timeout: time in jiffies when delay of failure mode expires
+ * @fail_cnt: current number of calls to failure mode I/O functions
+ * @fail_cnt_max: number of calls by which to delay failure mode
+ * @chk_lpt_sz: used by LPT tree size checker
+ * @chk_lpt_sz2: used by LPT tree size checker
+ * @chk_lpt_wastage: used by LPT tree size checker
+ * @chk_lpt_lebs: used by LPT tree size checker
+ * @new_nhead_offs: used by LPT tree size checker
+ * @new_ihead_lnum: used by debugging to check ihead_lnum
+ * @new_ihead_offs: used by debugging to check ihead_offs
+ *
+ * debugfs_dir_name: name of debugfs directory containing this file-system's
+ *                   files
+ * debugfs_dir: direntry object of the file-system debugfs directory
+ * dump_lprops: "dump lprops" debugfs knob
+ * dump_budg: "dump budgeting information" debugfs knob
+ * dump_tnc: "dump TNC" debugfs knob
+ */
+struct ubifs_debug_info {
+        void *buf;
+        struct ubifs_zbranch old_zroot;
+        int old_zroot_level;
+        unsigned long long old_zroot_sqnum;
+        int failure_mode;
+        int fail_delay;
+        unsigned long fail_timeout;
+        unsigned int fail_cnt;
+        unsigned int fail_cnt_max;
+        long long chk_lpt_sz;
+        long long chk_lpt_sz2;
+        long long chk_lpt_wastage;
+        int chk_lpt_lebs;
+        int new_nhead_offs;
+        int new_ihead_lnum;
+        int new_ihead_offs;
+
+        char debugfs_dir_name[100];
+        struct dentry *debugfs_dir;
+        struct dentry *dump_lprops;
+        struct dentry *dump_budg;
+        struct dentry *dump_tnc;
+};
 
 #define ubifs_assert(expr) do {                                                \
         if (unlikely(!(expr))) {                                               \
@@ -211,14 +260,18 @@ extern unsigned int ubifs_msg_flags;
 extern unsigned int ubifs_chk_flags;
 extern unsigned int ubifs_tst_flags;
 
-/* Dump functions */
+int ubifs_debugging_init(struct ubifs_info *c);
+void ubifs_debugging_exit(struct ubifs_info *c);
 
+/* Dump functions */
 const char *dbg_ntype(int type);
 const char *dbg_cstate(int cmt_state);
 const char *dbg_get_key_dump(const struct ubifs_info *c,
                              const union ubifs_key *key);
 void dbg_dump_inode(const struct ubifs_info *c, const struct inode *inode);
 void dbg_dump_node(const struct ubifs_info *c, const void *node);
+void dbg_dump_lpt_node(const struct ubifs_info *c, void *node, int lnum,
+                       int offs);
 void dbg_dump_budget_req(const struct ubifs_budget_req *req);
 void dbg_dump_lstats(const struct ubifs_lp_stats *lst);
 void dbg_dump_budg(struct ubifs_info *c);
@@ -233,9 +286,9 @@ void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                     struct ubifs_nnode *parent, int iip);
 void dbg_dump_tnc(struct ubifs_info *c);
 void dbg_dump_index(struct ubifs_info *c);
+void dbg_dump_lpt_lebs(const struct ubifs_info *c);
 
 /* Checking helper functions */
-
 typedef int (*dbg_leaf_callback)(struct ubifs_info *c,
                                  struct ubifs_zbranch *zbr, void *priv);
 typedef int (*dbg_znode_callback)(struct ubifs_info *c,
@@ -274,9 +327,6 @@ int dbg_force_in_the_gaps(void);
 
 #define dbg_failure_mode (ubifs_tst_flags & UBIFS_TST_RCVRY)
 
-void dbg_failure_mode_registration(struct ubifs_info *c);
-void dbg_failure_mode_deregistration(struct ubifs_info *c);
-
 #ifndef UBIFS_DBG_PRESERVE_UBI
 
 #define ubi_leb_read   dbg_leb_read
@@ -318,9 +368,13 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
         return dbg_leb_change(desc, lnum, buf, len, UBI_UNKNOWN);
 }
 
-#else /* !CONFIG_UBIFS_FS_DEBUG */
+/* Debugfs-related stuff */
+int dbg_debugfs_init(void);
+void dbg_debugfs_exit(void);
+int dbg_debugfs_init_fs(struct ubifs_info *c);
+void dbg_debugfs_exit_fs(struct ubifs_info *c);
 
-#define UBIFS_DBG(op)
+#else /* !CONFIG_UBIFS_FS_DEBUG */
 
 /* Use "if (0)" to make compiler check arguments even if debugging is off */
 #define ubifs_assert(expr)  do {                                               \
@@ -360,23 +414,28 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
 #define DBGKEY(key)  ((char *)(key))
 #define DBGKEY1(key) ((char *)(key))
 
-#define dbg_ntype(type)                       ""
-#define dbg_cstate(cmt_state)                 ""
-#define dbg_get_key_dump(c, key)              ({})
-#define dbg_dump_inode(c, inode)              ({})
-#define dbg_dump_node(c, node)                ({})
-#define dbg_dump_budget_req(req)              ({})
-#define dbg_dump_lstats(lst)                  ({})
-#define dbg_dump_budg(c)                      ({})
-#define dbg_dump_lprop(c, lp)                 ({})
-#define dbg_dump_lprops(c)                    ({})
-#define dbg_dump_lpt_info(c)                  ({})
-#define dbg_dump_leb(c, lnum)                 ({})
-#define dbg_dump_znode(c, znode)              ({})
-#define dbg_dump_heap(c, heap, cat)           ({})
-#define dbg_dump_pnode(c, pnode, parent, iip) ({})
-#define dbg_dump_tnc(c)                       ({})
-#define dbg_dump_index(c)                     ({})
+#define ubifs_debugging_init(c)                0
+#define ubifs_debugging_exit(c)                ({})
+
+#define dbg_ntype(type)                        ""
+#define dbg_cstate(cmt_state)                  ""
+#define dbg_get_key_dump(c, key)               ({})
+#define dbg_dump_inode(c, inode)               ({})
+#define dbg_dump_node(c, node)                 ({})
+#define dbg_dump_lpt_node(c, node, lnum, offs) ({})
+#define dbg_dump_budget_req(req)               ({})
+#define dbg_dump_lstats(lst)                   ({})
+#define dbg_dump_budg(c)                       ({})
+#define dbg_dump_lprop(c, lp)                  ({})
+#define dbg_dump_lprops(c)                     ({})
+#define dbg_dump_lpt_info(c)                   ({})
+#define dbg_dump_leb(c, lnum)                  ({})
+#define dbg_dump_znode(c, znode)               ({})
+#define dbg_dump_heap(c, heap, cat)            ({})
+#define dbg_dump_pnode(c, pnode, parent, iip)  ({})
+#define dbg_dump_tnc(c)                        ({})
+#define dbg_dump_index(c)                      ({})
+#define dbg_dump_lpt_lebs(c)                   ({})
 
 #define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0
 #define dbg_old_index_check_init(c, zroot)         0
@@ -396,9 +455,11 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
 #define dbg_force_in_the_gaps_enabled              0
 #define dbg_force_in_the_gaps()                    0
 #define dbg_failure_mode                           0
-#define dbg_failure_mode_registration(c)           ({})
-#define dbg_failure_mode_deregistration(c)         ({})
 
-#endif /* !CONFIG_UBIFS_FS_DEBUG */
+#define dbg_debugfs_init()                         0
+#define dbg_debugfs_exit()
+#define dbg_debugfs_init_fs(c)                     0
+#define dbg_debugfs_exit_fs(c)                     0
 
+#endif /* !CONFIG_UBIFS_FS_DEBUG */
 #endif /* !__UBIFS_DEBUG_H__ */
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 2624411d9758..fe82d2464d46 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -72,8 +72,8 @@ static int read_block(struct inode *inode, void *addr, unsigned int block,
                 return err;
         }
 
-        ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
-
+        ubifs_assert(le64_to_cpu(dn->ch.sqnum) >
+                     ubifs_inode(inode)->creat_sqnum);
         len = le32_to_cpu(dn->size);
         if (len <= 0 || len > UBIFS_BLOCK_SIZE)
                 goto dump;
@@ -254,7 +254,7 @@ static int write_begin_slow(struct address_space *mapping,
         }
 
         if (!PageUptodate(page)) {
-                if (!(pos & PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE)
+                if (!(pos & ~PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE)
                         SetPageChecked(page);
                 else {
                         err = do_readpage(page);
@@ -444,7 +444,7 @@ static int ubifs_write_begin(struct file *file, struct address_space *mapping,
 
         if (!PageUptodate(page)) {
                 /* The page is not loaded from the flash */
-                if (!(pos & PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE)
+                if (!(pos & ~PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE)
                         /*
                          * We change whole page so no need to load it. But we
                          * have to set the @PG_checked flag to make the further
diff --git a/fs/ubifs/ioctl.c b/fs/ubifs/ioctl.c
index 5e82cffe9695..6db7a6be6c97 100644
--- a/fs/ubifs/ioctl.c
+++ b/fs/ubifs/ioctl.c
@@ -154,6 +154,7 @@ long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case FS_IOC_GETFLAGS:
                 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
 
+                dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
                 return put_user(flags, (int __user *) arg);
 
         case FS_IOC_SETFLAGS: {
@@ -176,6 +177,7 @@ long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 err = mnt_want_write(file->f_path.mnt);
                 if (err)
                         return err;
+                dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
                 err = setflags(inode, flags);
                 mnt_drop_write(file->f_path.mnt);
                 return err;
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index f91b745908ea..10ae25b7d1db 100644
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -704,7 +704,7 @@ int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
         data->size = cpu_to_le32(len);
         zero_data_node_unused(data);
 
-        if (!(ui->flags && UBIFS_COMPR_FL))
+        if (!(ui->flags & UBIFS_COMPR_FL))
                 /* Compression is disabled for this inode */
                 compr_type = UBIFS_COMPR_NONE;
         else
@@ -1220,7 +1220,7 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
         data_key_init(c, &key, inum, blk);
 
         bit = old_size & (UBIFS_BLOCK_SIZE - 1);
-        blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0: 1);
+        blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
         data_key_init(c, &to_key, inum, blk);
 
         err = ubifs_tnc_remove_range(c, &key, &to_key);
diff --git a/fs/ubifs/key.h b/fs/ubifs/key.h
index 3f1f16bc25c9..efb3430a2581 100644
--- a/fs/ubifs/key.h
+++ b/fs/ubifs/key.h
@@ -38,6 +38,22 @@
 #define __UBIFS_KEY_H__
 
 /**
+ * key_mask_hash - mask a valid hash value.
+ * @val: value to be masked
+ *
+ * We use hash values as offset in directories, so values %0 and %1 are
+ * reserved for "." and "..". %2 is reserved for "end of readdir" marker. This
+ * function makes sure the reserved values are not used.
+ */
+static inline uint32_t key_mask_hash(uint32_t hash)
+{
+        hash &= UBIFS_S_KEY_HASH_MASK;
+        if (unlikely(hash <= 2))
+                hash += 3;
+        return hash;
+}
+
+/**
  * key_r5_hash - R5 hash function (borrowed from reiserfs).
  * @s: direntry name
  * @len: name length
@@ -54,16 +70,7 @@ static inline uint32_t key_r5_hash(const char *s, int len)
                 str++;
         }
 
-        a &= UBIFS_S_KEY_HASH_MASK;
-
-        /*
-         * We use hash values as offset in directories, so values %0 and %1 are
-         * reserved for "." and "..". %2 is reserved for "end of readdir"
-         * marker.
-         */
-        if (unlikely(a >= 0 && a <= 2))
-                a += 3;
-        return a;
+        return key_mask_hash(a);
 }
 
 /**
@@ -77,10 +84,7 @@ static inline uint32_t key_test_hash(const char *str, int len)
 
         len = min_t(uint32_t, len, 4);
         memcpy(&a, str, len);
-        a &= UBIFS_S_KEY_HASH_MASK;
-        if (unlikely(a >= 0 && a <= 2))
-                a += 3;
-        return a;
+        return key_mask_hash(a);
 }
 
 /**
diff --git a/fs/ubifs/lprops.c b/fs/ubifs/lprops.c
index f27176e9b70d..dfd2bcece27a 100644
--- a/fs/ubifs/lprops.c
+++ b/fs/ubifs/lprops.c
@@ -520,13 +520,13 @@ static int is_lprops_dirty(struct ubifs_info *c, struct ubifs_lprops *lprops)
  * @flags: new flags
  * @idx_gc_cnt: change to the count of idx_gc list
  *
- * This function changes LEB properties. This function does not change a LEB
- * property (@free, @dirty or @flag) if the value passed is %LPROPS_NC.
+ * This function changes LEB properties (@free, @dirty or @flag). However, the
+ * property which has the %LPROPS_NC value is not changed. Returns a pointer to
+ * the updated LEB properties on success and a negative error code on failure.
  *
- * This function returns a pointer to the updated LEB properties on success
- * and a negative error code on failure. N.B. the LEB properties may have had to
- * be copied (due to COW) and consequently the pointer returned may not be the
- * same as the pointer passed.
+ * Note, the LEB properties may have had to be copied (due to COW) and
+ * consequently the pointer returned may not be the same as the pointer
+ * passed.
  */
 const struct ubifs_lprops *ubifs_change_lp(struct ubifs_info *c,
                                            const struct ubifs_lprops *lp,
@@ -1088,7 +1088,7 @@ static int scan_check_cb(struct ubifs_info *c,
                 }
         }
 
-        sleb = ubifs_scan(c, lnum, 0, c->dbg_buf);
+        sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
         if (IS_ERR(sleb)) {
                 /*
                  * After an unclean unmount, empty and freeable LEBs
diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index db8bd0e518b2..b2792e84d245 100644
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -36,15 +36,16 @@
  * can be written into a single eraseblock. In that case, garbage collection
  * consists of just writing the whole table, which therefore makes all other
  * eraseblocks reusable. In the case of the big model, dirty eraseblocks are
- * selected for garbage collection, which consists are marking the nodes in
+ * selected for garbage collection, which consists of marking the clean nodes in
  * that LEB as dirty, and then only the dirty nodes are written out. Also, in
  * the case of the big model, a table of LEB numbers is saved so that the entire
  * LPT does not to be scanned looking for empty eraseblocks when UBIFS is first
  * mounted.
  */
 
-#include <linux/crc16.h>
 #include "ubifs.h"
+#include <linux/crc16.h>
+#include <linux/math64.h>
 
 /**
  * do_calc_lpt_geom - calculate sizes for the LPT area.
@@ -135,15 +136,13 @@ static void do_calc_lpt_geom(struct ubifs_info *c)
 int ubifs_calc_lpt_geom(struct ubifs_info *c)
 {
         int lebs_needed;
-        uint64_t sz;
+        long long sz;
 
         do_calc_lpt_geom(c);
 
         /* Verify that lpt_lebs is big enough */
         sz = c->lpt_sz * 2; /* Must have at least 2 times the size */
-        sz += c->leb_size - 1;
-        do_div(sz, c->leb_size);
-        lebs_needed = sz;
+        lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
         if (lebs_needed > c->lpt_lebs) {
                 ubifs_err("too few LPT LEBs");
                 return -EINVAL;
@@ -156,7 +155,6 @@ int ubifs_calc_lpt_geom(struct ubifs_info *c)
         }
 
         c->check_lpt_free = c->big_lpt;
-
         return 0;
 }
 
@@ -176,7 +174,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info *c, int *main_lebs,
                               int *big_lpt)
 {
         int i, lebs_needed;
-        uint64_t sz;
+        long long sz;
 
         /* Start by assuming the minimum number of LPT LEBs */
         c->lpt_lebs = UBIFS_MIN_LPT_LEBS;
@@ -203,9 +201,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info *c, int *main_lebs,
         /* Now check there are enough LPT LEBs */
         for (i = 0; i < 64 ; i++) {
                 sz = c->lpt_sz * 4; /* Allow 4 times the size */
-                sz += c->leb_size - 1;
-                do_div(sz, c->leb_size);
-                lebs_needed = sz;
+                lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
                 if (lebs_needed > c->lpt_lebs) {
                         /* Not enough LPT LEBs so try again with more */
                         c->lpt_lebs = lebs_needed;
@@ -558,7 +554,7 @@ static int calc_nnode_num(int row, int col)
  * This function calculates and returns the nnode number based on the parent's
  * nnode number and the index in parent.
  */
-static int calc_nnode_num_from_parent(struct ubifs_info *c,
+static int calc_nnode_num_from_parent(const struct ubifs_info *c,
                                       struct ubifs_nnode *parent, int iip)
 {
         int num, shft;
@@ -583,7 +579,7 @@ static int calc_nnode_num_from_parent(struct ubifs_info *c,
  * This function calculates and returns the pnode number based on the parent's
  * nnode number and the index in parent.
  */
-static int calc_pnode_num_from_parent(struct ubifs_info *c,
+static int calc_pnode_num_from_parent(const struct ubifs_info *c,
                                       struct ubifs_nnode *parent, int iip)
 {
         int i, n = c->lpt_hght - 1, pnum = parent->num, num = 0;
@@ -966,7 +962,7 @@ static int check_lpt_type(uint8_t **addr, int *pos, int type)
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int unpack_pnode(struct ubifs_info *c, void *buf,
+static int unpack_pnode(const struct ubifs_info *c, void *buf,
                         struct ubifs_pnode *pnode)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
@@ -996,15 +992,15 @@ static int unpack_pnode(struct ubifs_info *c, void *buf,
 }
 
 /**
- * unpack_nnode - unpack a nnode.
+ * ubifs_unpack_nnode - unpack a nnode.
  * @c: UBIFS file-system description object
  * @buf: buffer containing packed nnode to unpack
  * @nnode: nnode structure to fill
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int unpack_nnode(struct ubifs_info *c, void *buf,
-                        struct ubifs_nnode *nnode)
+int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
+                       struct ubifs_nnode *nnode)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
@@ -1036,7 +1032,7 @@ static int unpack_nnode(struct ubifs_info *c, void *buf,
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int unpack_ltab(struct ubifs_info *c, void *buf)
+static int unpack_ltab(const struct ubifs_info *c, void *buf)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
@@ -1068,7 +1064,7 @@ static int unpack_ltab(struct ubifs_info *c, void *buf)
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int unpack_lsave(struct ubifs_info *c, void *buf)
+static int unpack_lsave(const struct ubifs_info *c, void *buf)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
@@ -1096,7 +1092,7 @@ static int unpack_lsave(struct ubifs_info *c, void *buf)
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int validate_nnode(struct ubifs_info *c, struct ubifs_nnode *nnode,
+static int validate_nnode(const struct ubifs_info *c, struct ubifs_nnode *nnode,
                           struct ubifs_nnode *parent, int iip)
 {
         int i, lvl, max_offs;
@@ -1140,7 +1136,7 @@ static int validate_nnode(struct ubifs_info *c, struct ubifs_nnode *nnode,
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int validate_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
+static int validate_pnode(const struct ubifs_info *c, struct ubifs_pnode *pnode,
                           struct ubifs_nnode *parent, int iip)
 {
         int i;
@@ -1174,7 +1170,8 @@ static int validate_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
  * This function calculates the LEB numbers for the LEB properties it contains
  * based on the pnode number.
  */
-static void set_pnode_lnum(struct ubifs_info *c, struct ubifs_pnode *pnode)
+static void set_pnode_lnum(const struct ubifs_info *c,
+                           struct ubifs_pnode *pnode)
 {
         int i, lnum;
 
@@ -1227,7 +1224,7 @@ int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
                 err = ubi_read(c->ubi, lnum, buf, offs, c->nnode_sz);
                 if (err)
                         goto out;
-                err = unpack_nnode(c, buf, nnode);
+                err = ubifs_unpack_nnode(c, buf, nnode);
                 if (err)
                         goto out;
         }
@@ -1816,7 +1813,7 @@ static struct ubifs_nnode *scan_get_nnode(struct ubifs_info *c,
                                c->nnode_sz);
                 if (err)
                         return ERR_PTR(err);
-                err = unpack_nnode(c, buf, nnode);
+                err = ubifs_unpack_nnode(c, buf, nnode);
                 if (err)
                         return ERR_PTR(err);
         }
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index a41434b42785..96ca95707175 100644
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -320,6 +320,8 @@ no_space:
         dbg_err("LPT out of space at LEB %d:%d needing %d, done_ltab %d, "
                 "done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
         dbg_dump_lpt_info(c);
+        dbg_dump_lpt_lebs(c);
+        dump_stack();
         return err;
 }
 
@@ -546,8 +548,10 @@ static int write_cnodes(struct ubifs_info *c)
 no_space:
         ubifs_err("LPT out of space mismatch");
         dbg_err("LPT out of space mismatch at LEB %d:%d needing %d, done_ltab "
-                "%d, done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
+                "%d, done_lsave %d", lnum, offs, len, done_ltab, done_lsave);
         dbg_dump_lpt_info(c);
+        dbg_dump_lpt_lebs(c);
+        dump_stack();
         return err;
 }
 
@@ -749,7 +753,7 @@ static void lpt_tgc_start(struct ubifs_info *c)
  * LPT trivial garbage collection is where a LPT LEB contains only dirty and
  * free space and so may be reused as soon as the next commit is completed.
  * This function is called after the commit is completed (master node has been
- * written) and unmaps LPT LEBs that were marked for trivial GC.
+ * written) and un-maps LPT LEBs that were marked for trivial GC.
  */
 static int lpt_tgc_end(struct ubifs_info *c)
 {
@@ -1025,7 +1029,7 @@ static int make_node_dirty(struct ubifs_info *c, int node_type, int node_num,
  * @c: UBIFS file-system description object
  * @node_type: LPT node type
  */
-static int get_lpt_node_len(struct ubifs_info *c, int node_type)
+static int get_lpt_node_len(const struct ubifs_info *c, int node_type)
 {
         switch (node_type) {
         case UBIFS_LPT_NNODE:
@@ -1046,7 +1050,7 @@ static int get_lpt_node_len(struct ubifs_info *c, int node_type)
  * @buf: buffer
  * @len: length of buffer
  */
-static int get_pad_len(struct ubifs_info *c, uint8_t *buf, int len)
+static int get_pad_len(const struct ubifs_info *c, uint8_t *buf, int len)
 {
         int offs, pad_len;
 
@@ -1063,7 +1067,8 @@ static int get_pad_len(struct ubifs_info *c, uint8_t *buf, int len)
  * @buf: buffer
  * @node_num: node number is returned here
  */
-static int get_lpt_node_type(struct ubifs_info *c, uint8_t *buf, int *node_num)
+static int get_lpt_node_type(const struct ubifs_info *c, uint8_t *buf,
+                             int *node_num)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int pos = 0, node_type;
@@ -1081,7 +1086,7 @@ static int get_lpt_node_type(struct ubifs_info *c, uint8_t *buf, int *node_num)
  *
  * This function returns %1 if the buffer contains a node or %0 if it does not.
  */
-static int is_a_node(struct ubifs_info *c, uint8_t *buf, int len)
+static int is_a_node(const struct ubifs_info *c, uint8_t *buf, int len)
 {
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int pos = 0, node_type, node_len;
@@ -1105,7 +1110,6 @@ static int is_a_node(struct ubifs_info *c, uint8_t *buf, int len)
         return 1;
 }
 
-
 /**
  * lpt_gc_lnum - garbage collect a LPT LEB.
  * @c: UBIFS file-system description object
@@ -1463,7 +1467,7 @@ void ubifs_lpt_free(struct ubifs_info *c, int wr_only)
 #ifdef CONFIG_UBIFS_FS_DEBUG
 
 /**
- * dbg_is_all_ff - determine if a buffer contains only 0xff bytes.
+ * dbg_is_all_ff - determine if a buffer contains only 0xFF bytes.
  * @buf: buffer
  * @len: buffer length
  */
@@ -1488,7 +1492,7 @@ static int dbg_is_nnode_dirty(struct ubifs_info *c, int lnum, int offs)
         struct ubifs_nnode *nnode;
         int hght;
 
-        /* Entire tree is in memory so first_nnode / next_nnode are ok */
+        /* Entire tree is in memory so first_nnode / next_nnode are OK */
         nnode = first_nnode(c, &hght);
         for (; nnode; nnode = next_nnode(c, nnode, &hght)) {
                 struct ubifs_nbranch *branch;
@@ -1602,7 +1606,10 @@ static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
 {
         int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len;
         int ret;
-        void *buf = c->dbg_buf;
+        void *buf = c->dbg->buf;
+
+        if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
+                return 0;
 
         dbg_lp("LEB %d", lnum);
         err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
@@ -1704,6 +1711,9 @@ int dbg_chk_lpt_free_spc(struct ubifs_info *c)
         long long free = 0;
         int i;
 
+        if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
+                return 0;
+
         for (i = 0; i < c->lpt_lebs; i++) {
                 if (c->ltab[i].tgc || c->ltab[i].cmt)
                         continue;
@@ -1716,6 +1726,8 @@ int dbg_chk_lpt_free_spc(struct ubifs_info *c)
                 dbg_err("LPT space error: free %lld lpt_sz %lld",
                         free, c->lpt_sz);
                 dbg_dump_lpt_info(c);
+                dbg_dump_lpt_lebs(c);
+                dump_stack();
                 return -EINVAL;
         }
         return 0;
@@ -1731,15 +1743,19 @@ int dbg_chk_lpt_free_spc(struct ubifs_info *c)
  */
 int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
 {
+        struct ubifs_debug_info *d = c->dbg;
         long long chk_lpt_sz, lpt_sz;
         int err = 0;
 
+        if (!(ubifs_chk_flags & UBIFS_CHK_LPROPS))
+                return 0;
+
         switch (action) {
         case 0:
-                c->chk_lpt_sz = 0;
-                c->chk_lpt_sz2 = 0;
-                c->chk_lpt_lebs = 0;
-                c->chk_lpt_wastage = 0;
+                d->chk_lpt_sz = 0;
+                d->chk_lpt_sz2 = 0;
+                d->chk_lpt_lebs = 0;
+                d->chk_lpt_wastage = 0;
                 if (c->dirty_pn_cnt > c->pnode_cnt) {
                         dbg_err("dirty pnodes %d exceed max %d",
                                 c->dirty_pn_cnt, c->pnode_cnt);
@@ -1752,35 +1768,35 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
                 }
                 return err;
         case 1:
-                c->chk_lpt_sz += len;
+                d->chk_lpt_sz += len;
                 return 0;
         case 2:
-                c->chk_lpt_sz += len;
-                c->chk_lpt_wastage += len;
-                c->chk_lpt_lebs += 1;
+                d->chk_lpt_sz += len;
+                d->chk_lpt_wastage += len;
+                d->chk_lpt_lebs += 1;
                 return 0;
         case 3:
                 chk_lpt_sz = c->leb_size;
-                chk_lpt_sz *= c->chk_lpt_lebs;
+                chk_lpt_sz *= d->chk_lpt_lebs;
                 chk_lpt_sz += len - c->nhead_offs;
-                if (c->chk_lpt_sz != chk_lpt_sz) {
+                if (d->chk_lpt_sz != chk_lpt_sz) {
                         dbg_err("LPT wrote %lld but space used was %lld",
-                                c->chk_lpt_sz, chk_lpt_sz);
+                                d->chk_lpt_sz, chk_lpt_sz);
                         err = -EINVAL;
                 }
-                if (c->chk_lpt_sz > c->lpt_sz) {
+                if (d->chk_lpt_sz > c->lpt_sz) {
                         dbg_err("LPT wrote %lld but lpt_sz is %lld",
-                                c->chk_lpt_sz, c->lpt_sz);
+                                d->chk_lpt_sz, c->lpt_sz);
                         err = -EINVAL;
                 }
-                if (c->chk_lpt_sz2 && c->chk_lpt_sz != c->chk_lpt_sz2) {
+                if (d->chk_lpt_sz2 && d->chk_lpt_sz != d->chk_lpt_sz2) {
                         dbg_err("LPT layout size %lld but wrote %lld",
-                                c->chk_lpt_sz, c->chk_lpt_sz2);
+                                d->chk_lpt_sz, d->chk_lpt_sz2);
                         err = -EINVAL;
                 }
-                if (c->chk_lpt_sz2 && c->new_nhead_offs != len) {
+                if (d->chk_lpt_sz2 && d->new_nhead_offs != len) {
                         dbg_err("LPT new nhead offs: expected %d was %d",
-                                c->new_nhead_offs, len);
+                                d->new_nhead_offs, len);
                         err = -EINVAL;
                 }
                 lpt_sz = (long long)c->pnode_cnt * c->pnode_sz;
@@ -1788,26 +1804,146 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
                 lpt_sz += c->ltab_sz;
                 if (c->big_lpt)
                         lpt_sz += c->lsave_sz;
-                if (c->chk_lpt_sz - c->chk_lpt_wastage > lpt_sz) {
+                if (d->chk_lpt_sz - d->chk_lpt_wastage > lpt_sz) {
                         dbg_err("LPT chk_lpt_sz %lld + waste %lld exceeds %lld",
-                                c->chk_lpt_sz, c->chk_lpt_wastage, lpt_sz);
+                                d->chk_lpt_sz, d->chk_lpt_wastage, lpt_sz);
                         err = -EINVAL;
                 }
-                if (err)
+                if (err) {
                         dbg_dump_lpt_info(c);
-                c->chk_lpt_sz2 = c->chk_lpt_sz;
-                c->chk_lpt_sz = 0;
-                c->chk_lpt_wastage = 0;
-                c->chk_lpt_lebs = 0;
-                c->new_nhead_offs = len;
+                        dbg_dump_lpt_lebs(c);
+                        dump_stack();
+                }
+                d->chk_lpt_sz2 = d->chk_lpt_sz;
+                d->chk_lpt_sz = 0;
+                d->chk_lpt_wastage = 0;
+                d->chk_lpt_lebs = 0;
+                d->new_nhead_offs = len;
                 return err;
         case 4:
-                c->chk_lpt_sz += len;
-                c->chk_lpt_wastage += len;
+                d->chk_lpt_sz += len;
+                d->chk_lpt_wastage += len;
                 return 0;
         default:
                 return -EINVAL;
         }
 }
 
+/**
+ * dbg_dump_lpt_leb - dump an LPT LEB.
+ * @c: UBIFS file-system description object
+ * @lnum: LEB number to dump
+ *
+ * This function dumps an LEB from LPT area. Nodes in this area are very
+ * different to nodes in the main area (e.g., they do not have common headers,
+ * they do not have 8-byte alignments, etc), so we have a separate function to
+ * dump LPT area LEBs. Note, LPT has to be locked by the caller.
+ */
+static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
+{
+        int err, len = c->leb_size, node_type, node_num, node_len, offs;
+        void *buf = c->dbg->buf;
+
+        printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
+               current->pid, lnum);
+        err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
+        if (err) {
+                ubifs_err("cannot read LEB %d, error %d", lnum, err);
+                return;
+        }
+        while (1) {
+                offs = c->leb_size - len;
+                if (!is_a_node(c, buf, len)) {
+                        int pad_len;
+
+                        pad_len = get_pad_len(c, buf, len);
+                        if (pad_len) {
+                                printk(KERN_DEBUG "LEB %d:%d, pad %d bytes\n",
+                                       lnum, offs, pad_len);
+                                buf += pad_len;
+                                len -= pad_len;
+                                continue;
+                        }
+                        if (len)
+                                printk(KERN_DEBUG "LEB %d:%d, free %d bytes\n",
+                                       lnum, offs, len);
+                        break;
+                }
+
+                node_type = get_lpt_node_type(c, buf, &node_num);
+                switch (node_type) {
+                case UBIFS_LPT_PNODE:
+                {
+                        node_len = c->pnode_sz;
+                        if (c->big_lpt)
+                                printk(KERN_DEBUG "LEB %d:%d, pnode num %d\n",
+                                       lnum, offs, node_num);
+                        else
+                                printk(KERN_DEBUG "LEB %d:%d, pnode\n",
+                                       lnum, offs);
+                        break;
+                }
+                case UBIFS_LPT_NNODE:
+                {
+                        int i;
+                        struct ubifs_nnode nnode;
+
+                        node_len = c->nnode_sz;
+                        if (c->big_lpt)
+                                printk(KERN_DEBUG "LEB %d:%d, nnode num %d, ",
+                                       lnum, offs, node_num);
+                        else
+                                printk(KERN_DEBUG "LEB %d:%d, nnode, ",
+                                       lnum, offs);
+                        err = ubifs_unpack_nnode(c, buf, &nnode);
+                        for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
+                                printk("%d:%d", nnode.nbranch[i].lnum,
+                                       nnode.nbranch[i].offs);
+                                if (i != UBIFS_LPT_FANOUT - 1)
+                                        printk(", ");
+                        }
+                        printk("\n");
+                        break;
+                }
+                case UBIFS_LPT_LTAB:
+                        node_len = c->ltab_sz;
+                        printk(KERN_DEBUG "LEB %d:%d, ltab\n",
+                               lnum, offs);
+                        break;
+                case UBIFS_LPT_LSAVE:
+                        node_len = c->lsave_sz;
+                        printk(KERN_DEBUG "LEB %d:%d, lsave len\n", lnum, offs);
+                        break;
+                default:
+                        ubifs_err("LPT node type %d not recognized", node_type);
+                        return;
+                }
+
+                buf += node_len;
+                len -= node_len;
+        }
+
+        printk(KERN_DEBUG "(pid %d) finish dumping LEB %d\n",
+               current->pid, lnum);
+}
+
+/**
+ * dbg_dump_lpt_lebs - dump LPT lebs.
+ * @c: UBIFS file-system description object
+ *
+ * This function dumps all LPT LEBs. The caller has to make sure the LPT is
+ * locked.
+ */
+void dbg_dump_lpt_lebs(const struct ubifs_info *c)
+{
+        int i;
+
+        printk(KERN_DEBUG "(pid %d) start dumping all LPT LEBs\n",
+               current->pid);
+        for (i = 0; i < c->lpt_lebs; i++)
+                dump_lpt_leb(c, i + c->lpt_first);
+        printk(KERN_DEBUG "(pid %d) finish dumping all LPT LEBs\n",
+               current->pid);
+}
+
 #endif /* CONFIG_UBIFS_FS_DEBUG */
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 9bd5a43d4526..9e6f403f170e 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -899,7 +899,7 @@ static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
         for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
                 struct ubifs_scan_leb *sleb;
 
-                sleb = ubifs_scan(c, lnum, 0, c->dbg_buf);
+                sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
                 if (IS_ERR(sleb)) {
                         err = PTR_ERR(sleb);
                         break;
diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 21f7d047c306..ce42a7b0ca5a 100644
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -144,7 +144,7 @@ static int set_bud_lprops(struct ubifs_info *c, struct replay_entry *r)
                 /*
                  * If the replay order was perfect the dirty space would now be
                  * zero. The order is not perfect because the the journal heads
-                 * race with eachother. This is not a problem but is does mean
+                 * race with each other. This is not a problem but is does mean
                  * that the dirty space may temporarily exceed c->leb_size
                  * during the replay.
                  */
@@ -656,7 +656,7 @@ out_dump:
  * @dirty: amount of dirty space from padding and deletion nodes
  *
  * This function inserts a reference node to the replay tree and returns zero
- * in case of success ort a negative error code in case of failure.
+ * in case of success or a negative error code in case of failure.
  */
 static int insert_ref_node(struct ubifs_info *c, int lnum, int offs,
                            unsigned long long sqnum, int free, int dirty)
@@ -883,7 +883,7 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
                  * This means that we reached end of log and now
                  * look to the older log data, which was already
                  * committed but the eraseblock was not erased (UBIFS
-                 * only unmaps it). So this basically means we have to
+                 * only un-maps it). So this basically means we have to
                  * exit with "end of log" code.
                  */
                 err = 1;
@@ -1062,6 +1062,15 @@ int ubifs_replay_journal(struct ubifs_info *c)
         if (err)
                 goto out;
 
+        /*
+         * UBIFS budgeting calculations use @c->budg_uncommitted_idx variable
+         * to roughly estimate index growth. Things like @c->min_idx_lebs
+         * depend on it. This means we have to initialize it to make sure
+         * budgeting works properly.
+         */
+        c->budg_uncommitted_idx = atomic_long_read(&c->dirty_zn_cnt);
+        c->budg_uncommitted_idx *= c->max_idx_node_sz;
+
         ubifs_assert(c->bud_bytes <= c->max_bud_bytes || c->need_recovery);
         dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, "
                 "highest_inum %lu", c->lhead_lnum, c->lhead_offs, c->max_sqnum,
diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
index 0f392351dc5a..e070c643d1bb 100644
--- a/fs/ubifs/sb.c
+++ b/fs/ubifs/sb.c
@@ -28,6 +28,7 @@
 
 #include "ubifs.h"
 #include <linux/random.h>
+#include <linux/math64.h>
 
 /*
  * Default journal size in logical eraseblocks as a percent of total
@@ -80,7 +81,7 @@ static int create_default_filesystem(struct ubifs_info *c)
         int err, tmp, jnl_lebs, log_lebs, max_buds, main_lebs, main_first;
         int lpt_lebs, lpt_first, orph_lebs, big_lpt, ino_waste, sup_flags = 0;
         int min_leb_cnt = UBIFS_MIN_LEB_CNT;
-        uint64_t tmp64, main_bytes;
+        long long tmp64, main_bytes;
         __le64 tmp_le64;
 
         /* Some functions called from here depend on the @c->key_len filed */
@@ -160,7 +161,7 @@ static int create_default_filesystem(struct ubifs_info *c)
         if (!sup)
                 return -ENOMEM;
 
-        tmp64 = (uint64_t)max_buds * c->leb_size;
+        tmp64 = (long long)max_buds * c->leb_size;
         if (big_lpt)
                 sup_flags |= UBIFS_FLG_BIGLPT;
 
@@ -179,14 +180,16 @@ static int create_default_filesystem(struct ubifs_info *c)
         sup->fanout        = cpu_to_le32(DEFAULT_FANOUT);
         sup->lsave_cnt     = cpu_to_le32(c->lsave_cnt);
         sup->fmt_version   = cpu_to_le32(UBIFS_FORMAT_VERSION);
-        sup->default_compr = cpu_to_le16(UBIFS_COMPR_LZO);
         sup->time_gran     = cpu_to_le32(DEFAULT_TIME_GRAN);
+        if (c->mount_opts.override_compr)
+                sup->default_compr = cpu_to_le16(c->mount_opts.compr_type);
+        else
+                sup->default_compr = cpu_to_le16(UBIFS_COMPR_LZO);
 
         generate_random_uuid(sup->uuid);
 
-        main_bytes = (uint64_t)main_lebs * c->leb_size;
-        tmp64 = main_bytes * DEFAULT_RP_PERCENT;
-        do_div(tmp64, 100);
+        main_bytes = (long long)main_lebs * c->leb_size;
+        tmp64 = div_u64(main_bytes * DEFAULT_RP_PERCENT, 100);
         if (tmp64 > DEFAULT_MAX_RP_SIZE)
                 tmp64 = DEFAULT_MAX_RP_SIZE;
         sup->rp_size = cpu_to_le64(tmp64);
@@ -582,16 +585,15 @@ int ubifs_read_superblock(struct ubifs_info *c)
         c->jhead_cnt     = le32_to_cpu(sup->jhead_cnt) + NONDATA_JHEADS_CNT;
         c->fanout        = le32_to_cpu(sup->fanout);
         c->lsave_cnt     = le32_to_cpu(sup->lsave_cnt);
-        c->default_compr = le16_to_cpu(sup->default_compr);
         c->rp_size       = le64_to_cpu(sup->rp_size);
         c->rp_uid        = le32_to_cpu(sup->rp_uid);
         c->rp_gid        = le32_to_cpu(sup->rp_gid);
         sup_flags        = le32_to_cpu(sup->flags);
+        if (!c->mount_opts.override_compr)
+                c->default_compr = le16_to_cpu(sup->default_compr);
 
         c->vfs_sb->s_time_gran = le32_to_cpu(sup->time_gran);
-
         memcpy(&c->uuid, &sup->uuid, 16);
-
         c->big_lpt = !!(sup_flags & UBIFS_FLG_BIGLPT);
 
         /* Automatically increase file system size to the maximum size */
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index d80b2aef42b6..0d7564b95f8e 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -34,6 +34,8 @@
 #include <linux/parser.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
+#include <linux/math64.h>
+#include <linux/writeback.h>
 #include "ubifs.h"
 
 /*
@@ -417,39 +419,54 @@ static int ubifs_show_options(struct seq_file *s, struct vfsmount *mnt)
         else if (c->mount_opts.chk_data_crc == 1)
                 seq_printf(s, ",no_chk_data_crc");
 
+        if (c->mount_opts.override_compr) {
+                seq_printf(s, ",compr=");
+                seq_printf(s, ubifs_compr_name(c->mount_opts.compr_type));
+        }
+
         return 0;
 }
 
 static int ubifs_sync_fs(struct super_block *sb, int wait)
 {
+        int i, err;
         struct ubifs_info *c = sb->s_fs_info;
-        int i, ret = 0, err;
-        long long bud_bytes;
-
-        if (c->jheads) {
-                for (i = 0; i < c->jhead_cnt; i++) {
-                        err = ubifs_wbuf_sync(&c->jheads[i].wbuf);
-                        if (err && !ret)
-                                ret = err;
-                }
+        struct writeback_control wbc = {
+                .sync_mode   = wait ? WB_SYNC_ALL : WB_SYNC_HOLD,
+                .range_start = 0,
+                .range_end   = LLONG_MAX,
+                .nr_to_write = LONG_MAX,
+        };
+
+        if (sb->s_flags & MS_RDONLY)
+                return 0;
 
-                /* Commit the journal unless it has too little data */
-                spin_lock(&c->buds_lock);
-                bud_bytes = c->bud_bytes;
-                spin_unlock(&c->buds_lock);
-                if (bud_bytes > c->leb_size) {
-                        err = ubifs_run_commit(c);
-                        if (err)
-                                return err;
-                }
+        /*
+         * Synchronize write buffers, because 'ubifs_run_commit()' does not
+         * do this if it waits for an already running commit.
+         */
+        for (i = 0; i < c->jhead_cnt; i++) {
+                err = ubifs_wbuf_sync(&c->jheads[i].wbuf);
+                if (err)
+                        return err;
         }
 
         /*
-         * We ought to call sync for c->ubi but it does not have one. If it had
-         * it would in turn call mtd->sync, however mtd operations are
-         * synchronous anyway, so we don't lose any sleep here.
+         * VFS calls '->sync_fs()' before synchronizing all dirty inodes and
+         * pages, so synchronize them first, then commit the journal. Strictly
+         * speaking, it is not necessary to commit the journal here,
+         * synchronizing write-buffers would be enough. But committing makes
+         * UBIFS free space predictions much more accurate, so we want to let
+         * the user be able to get more accurate results of 'statfs()' after
+         * they synchronize the file system.
          */
-        return ret;
+        generic_sync_sb_inodes(sb, &wbc);
+
+        err = ubifs_run_commit(c);
+        if (err)
+                return err;
+
+        return ubi_sync(c->vi.ubi_num);
 }
 
 /**
@@ -596,7 +613,7 @@ static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad)
 }
 
 /*
- * init_constants_late - initialize UBIFS constants.
+ * init_constants_sb - initialize UBIFS constants.
  * @c: UBIFS file-system description object
  *
  * This is a helper function which initializes various UBIFS constants after
@@ -604,10 +621,10 @@ static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad)
  * makes sure they are all right. Returns zero in case of success and a
  * negative error code in case of failure.
  */
-static int init_constants_late(struct ubifs_info *c)
+static int init_constants_sb(struct ubifs_info *c)
 {
         int tmp, err;
-        uint64_t tmp64;
+        long long tmp64;
 
         c->main_bytes = (long long)c->main_lebs * c->leb_size;
         c->max_znode_sz = sizeof(struct ubifs_znode) +
@@ -634,9 +651,8 @@ static int init_constants_late(struct ubifs_info *c)
          * Make sure that the log is large enough to fit reference nodes for
          * all buds plus one reserved LEB.
          */
-        tmp64 = c->max_bud_bytes;
-        tmp = do_div(tmp64, c->leb_size);
-        c->max_bud_cnt = tmp64 + !!tmp;
+        tmp64 = c->max_bud_bytes + c->leb_size - 1;
+        c->max_bud_cnt = div_u64(tmp64, c->leb_size);
         tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1);
         tmp /= c->leb_size;
         tmp += 1;
@@ -672,7 +688,7 @@ static int init_constants_late(struct ubifs_info *c)
          * Consequently, if the journal is too small, UBIFS will treat it as
          * always full.
          */
-        tmp64 = (uint64_t)(c->jhead_cnt + 1) * c->leb_size + 1;
+        tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1;
         if (c->bg_bud_bytes < tmp64)
                 c->bg_bud_bytes = tmp64;
         if (c->max_bud_bytes < tmp64 + c->leb_size)
@@ -682,6 +698,21 @@ static int init_constants_late(struct ubifs_info *c)
         if (err)
                 return err;
 
+        return 0;
+}
+
+/*
+ * init_constants_master - initialize UBIFS constants.
+ * @c: UBIFS file-system description object
+ *
+ * This is a helper function which initializes various UBIFS constants after
+ * the master node has been read. It also checks various UBIFS parameters and
+ * makes sure they are all right.
+ */
+static void init_constants_master(struct ubifs_info *c)
+{
+        long long tmp64;
+
         c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
 
         /*
@@ -690,14 +721,13 @@ static int init_constants_late(struct ubifs_info *c)
          * necessary to report something for the 'statfs()' call.
          *
          * Subtract the LEB reserved for GC, the LEB which is reserved for
-         * deletions, and assume only one journal head is available.
+         * deletions, minimum LEBs for the index, and assume only one journal
+         * head is available.
          */
-        tmp64 = c->main_lebs - 2 - c->jhead_cnt + 1;
-        tmp64 *= (uint64_t)c->leb_size - c->leb_overhead;
+        tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1;
+        tmp64 *= (long long)c->leb_size - c->leb_overhead;
         tmp64 = ubifs_reported_space(c, tmp64);
         c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT;
-
-        return 0;
 }
 
 /**
@@ -878,6 +908,7 @@ static int check_volume_empty(struct ubifs_info *c)
  * Opt_no_bulk_read: disable bulk-reads
  * Opt_chk_data_crc: check CRCs when reading data nodes
  * Opt_no_chk_data_crc: do not check CRCs when reading data nodes
+ * Opt_override_compr: override default compressor
  * Opt_err: just end of array marker
  */
 enum {
@@ -887,6 +918,7 @@ enum {
         Opt_no_bulk_read,
         Opt_chk_data_crc,
         Opt_no_chk_data_crc,
+        Opt_override_compr,
         Opt_err,
 };
 
@@ -897,6 +929,7 @@ static const match_table_t tokens = {
         {Opt_no_bulk_read, "no_bulk_read"},
         {Opt_chk_data_crc, "chk_data_crc"},
         {Opt_no_chk_data_crc, "no_chk_data_crc"},
+        {Opt_override_compr, "compr=%s"},
         {Opt_err, NULL},
 };
 
@@ -950,6 +983,28 @@ static int ubifs_parse_options(struct ubifs_info *c, char *options,
                         c->mount_opts.chk_data_crc = 1;
                         c->no_chk_data_crc = 1;
                         break;
+                case Opt_override_compr:
+                {
+                        char *name = match_strdup(&args[0]);
+
+                        if (!name)
+                                return -ENOMEM;
+                        if (!strcmp(name, "none"))
+                                c->mount_opts.compr_type = UBIFS_COMPR_NONE;
+                        else if (!strcmp(name, "lzo"))
+                                c->mount_opts.compr_type = UBIFS_COMPR_LZO;
+                        else if (!strcmp(name, "zlib"))
+                                c->mount_opts.compr_type = UBIFS_COMPR_ZLIB;
+                        else {
+                                ubifs_err("unknown compressor \"%s\"", name);
+                                kfree(name);
+                                return -EINVAL;
+                        }
+                        kfree(name);
+                        c->mount_opts.override_compr = 1;
+                        c->default_compr = c->mount_opts.compr_type;
+                        break;
+                }
                 default:
                         ubifs_err("unrecognized mount option \"%s\" "
                                   "or missing value", p);
@@ -1019,6 +1074,30 @@ again:
 }
 
 /**
+ * check_free_space - check if there is enough free space to mount.
+ * @c: UBIFS file-system description object
+ *
+ * This function makes sure UBIFS has enough free space to be mounted in
+ * read/write mode. UBIFS must always have some free space to allow deletions.
+ */
+static int check_free_space(struct ubifs_info *c)
+{
+        ubifs_assert(c->dark_wm > 0);
+        if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) {
+                ubifs_err("insufficient free space to mount in read/write mode");
+                dbg_dump_budg(c);
+                dbg_dump_lprops(c);
+                /*
+                 * We return %-EINVAL instead of %-ENOSPC because it seems to
+                 * be the closest error code mentioned in the mount function
+                 * documentation.
+                 */
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/**
  * mount_ubifs - mount UBIFS file-system.
  * @c: UBIFS file-system description object
  *
@@ -1039,11 +1118,9 @@ static int mount_ubifs(struct ubifs_info *c)
         if (err)
                 return err;
 
-#ifdef CONFIG_UBIFS_FS_DEBUG
-        c->dbg_buf = vmalloc(c->leb_size);
-        if (!c->dbg_buf)
-                return -ENOMEM;
-#endif
+        err = ubifs_debugging_init(c);
+        if (err)
+                return err;
 
         err = check_volume_empty(c);
         if (err)
@@ -1100,27 +1177,25 @@ static int mount_ubifs(struct ubifs_info *c)
                 goto out_free;
 
         /*
-         * Make sure the compressor which is set as the default on in the
-         * superblock was actually compiled in.
+         * Make sure the compressor which is set as default in the superblock
+         * or overridden by mount options is actually compiled in.
          */
         if (!ubifs_compr_present(c->default_compr)) {
-                ubifs_warn("'%s' compressor is set by superblock, but not "
-                           "compiled in", ubifs_compr_name(c->default_compr));
-                c->default_compr = UBIFS_COMPR_NONE;
+                ubifs_err("'compressor \"%s\" is not compiled in",
+                          ubifs_compr_name(c->default_compr));
+                goto out_free;
         }
 
-        dbg_failure_mode_registration(c);
-
-        err = init_constants_late(c);
+        err = init_constants_sb(c);
         if (err)
-                goto out_dereg;
+                goto out_free;
 
         sz = ALIGN(c->max_idx_node_sz, c->min_io_size);
         sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size);
         c->cbuf = kmalloc(sz, GFP_NOFS);
         if (!c->cbuf) {
                 err = -ENOMEM;
-                goto out_dereg;
+                goto out_free;
         }
 
         sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id);
@@ -1145,6 +1220,8 @@ static int mount_ubifs(struct ubifs_info *c)
         if (err)
                 goto out_master;
 
+        init_constants_master(c);
+
         if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) {
                 ubifs_msg("recovery needed");
                 c->need_recovery = 1;
@@ -1183,12 +1260,9 @@ static int mount_ubifs(struct ubifs_info *c)
         if (!mounted_read_only) {
                 int lnum;
 
-                /* Check for enough free space */
-                if (ubifs_calc_available(c, c->min_idx_lebs) <= 0) {
-                        ubifs_err("insufficient available space");
-                        err = -EINVAL;
+                err = check_free_space(c);
+                if (err)
                         goto out_orphans;
-                }
 
                 /* Check for enough log space */
                 lnum = c->lhead_lnum + 1;
@@ -1232,6 +1306,10 @@ static int mount_ubifs(struct ubifs_info *c)
                 }
         }
 
+        err = dbg_debugfs_init_fs(c);
+        if (err)
+                goto out_infos;
+
         err = dbg_check_filesystem(c);
         if (err)
                 goto out_infos;
@@ -1283,8 +1361,20 @@ static int mount_ubifs(struct ubifs_info *c)
         dbg_msg("tree fanout:         %d", c->fanout);
         dbg_msg("reserved GC LEB:     %d", c->gc_lnum);
         dbg_msg("first main LEB:      %d", c->main_first);
+        dbg_msg("max. znode size      %d", c->max_znode_sz);
+        dbg_msg("max. index node size %d", c->max_idx_node_sz);
+        dbg_msg("node sizes:          data %zu, inode %zu, dentry %zu",
+                UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ);
+        dbg_msg("node sizes:          trun %zu, sb %zu, master %zu",
+                UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ);
+        dbg_msg("node sizes:          ref %zu, cmt. start %zu, orph %zu",
+                UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ);
+        dbg_msg("max. node sizes:     data %zu, inode %zu dentry %zu",
+                UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ,
+                UBIFS_MAX_DENT_NODE_SZ);
         dbg_msg("dead watermark:      %d", c->dead_wm);
         dbg_msg("dark watermark:      %d", c->dark_wm);
+        dbg_msg("LEB overhead:        %d", c->leb_overhead);
         x = (long long)c->main_lebs * c->dark_wm;
         dbg_msg("max. dark space:     %lld (%lld KiB, %lld MiB)",
                 x, x >> 10, x >> 20);
@@ -1320,14 +1410,12 @@ out_wbufs:
         free_wbufs(c);
 out_cbuf:
         kfree(c->cbuf);
-out_dereg:
-        dbg_failure_mode_deregistration(c);
 out_free:
         kfree(c->bu.buf);
         vfree(c->ileb_buf);
         vfree(c->sbuf);
         kfree(c->bottom_up_buf);
-        UBIFS_DBG(vfree(c->dbg_buf));
+        ubifs_debugging_exit(c);
         return err;
 }
 
@@ -1345,6 +1433,7 @@ static void ubifs_umount(struct ubifs_info *c)
         dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num,
                 c->vi.vol_id);
 
+        dbg_debugfs_exit_fs(c);
         spin_lock(&ubifs_infos_lock);
         list_del(&c->infos_list);
         spin_unlock(&ubifs_infos_lock);
@@ -1364,8 +1453,7 @@ static void ubifs_umount(struct ubifs_info *c)
         vfree(c->ileb_buf);
         vfree(c->sbuf);
         kfree(c->bottom_up_buf);
-        UBIFS_DBG(vfree(c->dbg_buf));
-        dbg_failure_mode_deregistration(c);
+        ubifs_debugging_exit(c);
 }
 
 /**
@@ -1387,12 +1475,9 @@ static int ubifs_remount_rw(struct ubifs_info *c)
         c->remounting_rw = 1;
         c->always_chk_crc = 1;
 
-        /* Check for enough free space */
-        if (ubifs_calc_available(c, c->min_idx_lebs) <= 0) {
-                ubifs_err("insufficient available space");
-                err = -EINVAL;
+        err = check_free_space(c);
+        if (err)
                 goto out;
-        }
 
         if (c->old_leb_cnt != c->leb_cnt) {
                 struct ubifs_sb_node *sup;
@@ -1515,20 +1600,24 @@ out:
  * @c: UBIFS file-system description object
  *
  * This function is called during un-mounting and re-mounting, and it commits
- * the journal unless the "fast unmount" mode is enabled. It also avoids
- * committing the journal if it contains too few data.
+ * the journal unless the "fast unmount" mode is enabled.
  */
 static void commit_on_unmount(struct ubifs_info *c)
 {
-        if (!c->fast_unmount) {
-                long long bud_bytes;
+        struct super_block *sb = c->vfs_sb;
+        long long bud_bytes;
 
-                spin_lock(&c->buds_lock);
-                bud_bytes = c->bud_bytes;
-                spin_unlock(&c->buds_lock);
-                if (bud_bytes > c->leb_size)
-                        ubifs_run_commit(c);
-        }
+        /*
+         * This function is called before the background thread is stopped, so
+         * we may race with ongoing commit, which means we have to take
+         * @c->bud_lock to access @c->bud_bytes.
+         */
+        spin_lock(&c->buds_lock);
+        bud_bytes = c->bud_bytes;
+        spin_unlock(&c->buds_lock);
+
+        if (!c->fast_unmount && !(sb->s_flags & MS_RDONLY) && bud_bytes)
+                ubifs_run_commit(c);
 }
 
 /**
@@ -1849,7 +1938,6 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
                 goto out_iput;
 
         mutex_unlock(&c->umount_mutex);
-
         return 0;
 
 out_iput:
@@ -1955,7 +2043,7 @@ static void ubifs_kill_sb(struct super_block *sb)
          * We do 'commit_on_unmount()' here instead of 'ubifs_put_super()'
          * in order to be outside BKL.
          */
-        if (sb->s_root && !(sb->s_flags & MS_RDONLY))
+        if (sb->s_root)
                 commit_on_unmount(c);
         /* The un-mount routine is actually done in put_super() */
         generic_shutdown_super(sb);
@@ -2021,6 +2109,14 @@ static int __init ubifs_init(void)
         BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64);
 
         /*
+         * We use 2 bit wide bit-fields to store compression type, which should
+         * be amended if more compressors are added. The bit-fields are:
+         * @compr_type in 'struct ubifs_inode', @default_compr in
+         * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'.
+         */
+        BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4);
+
+        /*
          * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to
          * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.
          */
@@ -2049,11 +2145,17 @@ static int __init ubifs_init(void)
 
         err = ubifs_compressors_init();
         if (err)
+                goto out_shrinker;
+
+        err = dbg_debugfs_init();
+        if (err)
                 goto out_compr;
 
         return 0;
 
 out_compr:
+        ubifs_compressors_exit();
+out_shrinker:
         unregister_shrinker(&ubifs_shrinker_info);
         kmem_cache_destroy(ubifs_inode_slab);
 out_reg:
@@ -2068,6 +2170,7 @@ static void __exit ubifs_exit(void)
         ubifs_assert(list_empty(&ubifs_infos));
         ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0);
 
+        dbg_debugfs_exit();
         ubifs_compressors_exit();
         unregister_shrinker(&ubifs_shrinker_info);
         kmem_cache_destroy(ubifs_inode_slab);
diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c
index 6eef5344a145..f7e36f545527 100644
--- a/fs/ubifs/tnc.c
+++ b/fs/ubifs/tnc.c
@@ -2245,12 +2245,11 @@ int ubifs_tnc_replace(struct ubifs_info *c, const union ubifs_key *key,
                         if (found) {
                                 /* Ensure the znode is dirtied */
                                 if (znode->cnext || !ubifs_zn_dirty(znode)) {
-                                            znode = dirty_cow_bottom_up(c,
-                                                                        znode);
-                                            if (IS_ERR(znode)) {
-                                                    err = PTR_ERR(znode);
-                                                    goto out_unlock;
-                                            }
+                                        znode = dirty_cow_bottom_up(c, znode);
+                                        if (IS_ERR(znode)) {
+                                                err = PTR_ERR(znode);
+                                                goto out_unlock;
+                                        }
                                 }
                                 zbr = &znode->zbranch[n];
                                 lnc_free(zbr);
@@ -2317,11 +2316,11 @@ int ubifs_tnc_add_nm(struct ubifs_info *c, const union ubifs_key *key,
 
                 /* Ensure the znode is dirtied */
                 if (znode->cnext || !ubifs_zn_dirty(znode)) {
-                            znode = dirty_cow_bottom_up(c, znode);
-                            if (IS_ERR(znode)) {
-                                    err = PTR_ERR(znode);
-                                    goto out_unlock;
-                            }
+                        znode = dirty_cow_bottom_up(c, znode);
+                        if (IS_ERR(znode)) {
+                                err = PTR_ERR(znode);
+                                goto out_unlock;
+                        }
                 }
 
                 if (found == 1) {
@@ -2627,11 +2626,11 @@ int ubifs_tnc_remove_range(struct ubifs_info *c, union ubifs_key *from_key,
 
                 /* Ensure the znode is dirtied */
                 if (znode->cnext || !ubifs_zn_dirty(znode)) {
-                            znode = dirty_cow_bottom_up(c, znode);
-                            if (IS_ERR(znode)) {
-                                    err = PTR_ERR(znode);
-                                    goto out_unlock;
-                            }
+                        znode = dirty_cow_bottom_up(c, znode);
+                        if (IS_ERR(znode)) {
+                                err = PTR_ERR(znode);
+                                goto out_unlock;
+                        }
                 }
 
                 /* Remove all keys in range except the first */
diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index 8ac76b1c2d55..fde8d127c768 100644
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -553,8 +553,8 @@ static int layout_in_empty_space(struct ubifs_info *c)
         }
 
 #ifdef CONFIG_UBIFS_FS_DEBUG
-        c->new_ihead_lnum = lnum;
-        c->new_ihead_offs = buf_offs;
+        c->dbg->new_ihead_lnum = lnum;
+        c->dbg->new_ihead_offs = buf_offs;
 #endif
 
         return 0;
@@ -802,8 +802,10 @@ int ubifs_tnc_start_commit(struct ubifs_info *c, struct ubifs_zbranch *zroot)
          * budgeting subsystem to assume the index is already committed,
          * even though it is not.
          */
+        ubifs_assert(c->min_idx_lebs == ubifs_calc_min_idx_lebs(c));
         c->old_idx_sz = c->calc_idx_sz;
         c->budg_uncommitted_idx = 0;
+        c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
         spin_unlock(&c->space_lock);
         mutex_unlock(&c->tnc_mutex);
 
@@ -1002,7 +1004,8 @@ static int write_index(struct ubifs_info *c)
         }
 
 #ifdef CONFIG_UBIFS_FS_DEBUG
-        if (lnum != c->new_ihead_lnum || buf_offs != c->new_ihead_offs) {
+        if (lnum != c->dbg->new_ihead_lnum ||
+            buf_offs != c->dbg->new_ihead_offs) {
                 ubifs_err("inconsistent ihead");
                 return -EINVAL;
         }
diff --git a/fs/ubifs/ubifs-media.h b/fs/ubifs/ubifs-media.h
index 0b378042a3a2..b25fc36cf72f 100644
--- a/fs/ubifs/ubifs-media.h
+++ b/fs/ubifs/ubifs-media.h
@@ -51,6 +51,13 @@
  */
 #define UBIFS_MIN_COMPR_LEN 128
 
+/*
+ * If compressed data length is less than %UBIFS_MIN_COMPRESS_DIFF bytes
+ * shorter than uncompressed data length, UBIFS preferes to leave this data
+ * node uncompress, because it'll be read faster.
+ */
+#define UBIFS_MIN_COMPRESS_DIFF 64
+
 /* Root inode number */
 #define UBIFS_ROOT_INO 1
 
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 46b172560a06..fc2a4cc66d03 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -63,6 +63,14 @@
 #define SQNUM_WARN_WATERMARK 0xFFFFFFFF00000000ULL
 #define SQNUM_WATERMARK      0xFFFFFFFFFF000000ULL
 
+/*
+ * Minimum amount of LEBs reserved for the index. At present the index needs at
+ * least 2 LEBs: one for the index head and one for in-the-gaps method (which
+ * currently does not cater for the index head and so excludes it from
+ * consideration).
+ */
+#define MIN_INDEX_LEBS 2
+
 /* Minimum amount of data UBIFS writes to the flash */
 #define MIN_WRITE_SZ (UBIFS_DATA_NODE_SZ + 8)
 
@@ -386,12 +394,12 @@ struct ubifs_inode {
         unsigned int dirty:1;
         unsigned int xattr:1;
         unsigned int bulk_read:1;
+        unsigned int compr_type:2;
         struct mutex ui_mutex;
         spinlock_t ui_lock;
         loff_t synced_i_size;
         loff_t ui_size;
         int flags;
-        int compr_type;
         pgoff_t last_page_read;
         pgoff_t read_in_a_row;
         int data_len;
@@ -419,7 +427,7 @@ struct ubifs_unclean_leb {
  *
  * LPROPS_UNCAT: not categorized
  * LPROPS_DIRTY: dirty > 0, not index
- * LPROPS_DIRTY_IDX: dirty + free > UBIFS_CH_SZ and index
+ * LPROPS_DIRTY_IDX: dirty + free > @c->min_idx_node_sze and index
  * LPROPS_FREE: free > 0, not empty, not index
  * LPROPS_HEAP_CNT: number of heaps used for storing categorized LEBs
  * LPROPS_EMPTY: LEB is empty, not taken
@@ -473,8 +481,8 @@ struct ubifs_lprops {
 struct ubifs_lpt_lprops {
         int free;
         int dirty;
-        unsigned tgc : 1;
-        unsigned cmt : 1;
+        unsigned tgc:1;
+        unsigned cmt:1;
 };
 
 /**
@@ -482,24 +490,26 @@ struct ubifs_lpt_lprops {
  * @empty_lebs: number of empty LEBs
  * @taken_empty_lebs: number of taken LEBs
  * @idx_lebs: number of indexing LEBs
- * @total_free: total free space in bytes
- * @total_dirty: total dirty space in bytes
- * @total_used: total used space in bytes (includes only data LEBs)
- * @total_dead: total dead space in bytes (includes only data LEBs)
- * @total_dark: total dark space in bytes (includes only data LEBs)
+ * @total_free: total free space in bytes (includes all LEBs)
+ * @total_dirty: total dirty space in bytes (includes all LEBs)
+ * @total_used: total used space in bytes (does not include index LEBs)
+ * @total_dead: total dead space in bytes (does not include index LEBs)
+ * @total_dark: total dark space in bytes (does not include index LEBs)
+ *
+ * The @taken_empty_lebs field counts the LEBs that are in the transient state
+ * of having been "taken" for use but not yet written to. @taken_empty_lebs is
+ * needed to account correctly for @gc_lnum, otherwise @empty_lebs could be
+ * used by itself (in which case 'unused_lebs' would be a better name). In the
+ * case of @gc_lnum, it is "taken" at mount time or whenever a LEB is retained
+ * by GC, but unlike other empty LEBs that are "taken", it may not be written
+ * straight away (i.e. before the next commit start or unmount), so either
+ * @gc_lnum must be specially accounted for, or the current approach followed
+ * i.e. count it under @taken_empty_lebs.
  *
- * N.B. total_dirty and total_used are different to other total_* fields,
- * because they account _all_ LEBs, not just data LEBs.
+ * @empty_lebs includes @taken_empty_lebs.
  *
- * 'taken_empty_lebs' counts the LEBs that are in the transient state of having
- * been 'taken' for use but not yet written to. 'taken_empty_lebs' is needed
- * to account correctly for gc_lnum, otherwise 'empty_lebs' could be used
- * by itself (in which case 'unused_lebs' would be a better name). In the case
- * of gc_lnum, it is 'taken' at mount time or whenever a LEB is retained by GC,
- * but unlike other empty LEBs that are 'taken', it may not be written straight
- * away (i.e. before the next commit start or unmount), so either gc_lnum must
- * be specially accounted for, or the current approach followed i.e. count it
- * under 'taken_empty_lebs'.
+ * @total_used, @total_dead and @total_dark fields do not account indexing
+ * LEBs.
  */
 struct ubifs_lp_stats {
         int empty_lebs;
@@ -893,15 +903,25 @@ struct ubifs_orphan {
 /**
  * struct ubifs_mount_opts - UBIFS-specific mount options information.
  * @unmount_mode: selected unmount mode (%0 default, %1 normal, %2 fast)
- * @bulk_read: enable bulk-reads
- * @chk_data_crc: check CRCs when reading data nodes
+ * @bulk_read: enable/disable bulk-reads (%0 default, %1 disabe, %2 enable)
+ * @chk_data_crc: enable/disable CRC data checking when reading data nodes
+ *                (%0 default, %1 disabe, %2 enable)
+ * @override_compr: override default compressor (%0 - do not override and use
+ *                  superblock compressor, %1 - override and use compressor
+ *                  specified in @compr_type)
+ * @compr_type: compressor type to override the superblock compressor with
+ *              (%UBIFS_COMPR_NONE, etc)
  */
 struct ubifs_mount_opts {
         unsigned int unmount_mode:2;
         unsigned int bulk_read:2;
         unsigned int chk_data_crc:2;
+        unsigned int override_compr:1;
+        unsigned int compr_type:2;
 };
 
+struct ubifs_debug_info;
+
 /**
  * struct ubifs_info - UBIFS file-system description data structure
  * (per-superblock).
@@ -946,6 +966,7 @@ struct ubifs_mount_opts {
  * @no_chk_data_crc: do not check CRCs when reading data nodes (except during
  *                   recovery)
  * @bulk_read: enable bulk-reads
+ * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)
  *
  * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and
  *             @calc_idx_sz
@@ -963,8 +984,6 @@ struct ubifs_mount_opts {
  * @ileb_nxt: next pre-allocated index LEBs
  * @old_idx: tree of index nodes obsoleted since the last commit start
  * @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c
- * @new_ihead_lnum: used by debugging to check ihead_lnum
- * @new_ihead_offs: used by debugging to check ihead_offs
  *
  * @mst_node: master node
  * @mst_offs: offset of valid master node
@@ -986,7 +1005,6 @@ struct ubifs_mount_opts {
  * @main_lebs: count of LEBs in the main area
  * @main_first: first LEB of the main area
  * @main_bytes: main area size in bytes
- * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)
  *
  * @key_hash_type: type of the key hash
  * @key_hash: direntry key hash function
@@ -1149,15 +1167,7 @@ struct ubifs_mount_opts {
  * @always_chk_crc: always check CRCs (while mounting and remounting rw)
  * @mount_opts: UBIFS-specific mount options
  *
- * @dbg_buf: a buffer of LEB size used for debugging purposes
- * @old_zroot: old index root - used by 'dbg_check_old_index()'
- * @old_zroot_level: old index root level - used by 'dbg_check_old_index()'
- * @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()'
- * @failure_mode: failure mode for recovery testing
- * @fail_delay: 0=>don't delay, 1=>delay a time, 2=>delay a number of calls
- * @fail_timeout: time in jiffies when delay of failure mode expires
- * @fail_cnt: current number of calls to failure mode I/O functions
- * @fail_cnt_max: number of calls by which to delay failure mode
+ * @dbg: debugging-related information
  */
 struct ubifs_info {
         struct super_block *vfs_sb;
@@ -1196,6 +1206,7 @@ struct ubifs_info {
         unsigned int big_lpt:1;
         unsigned int no_chk_data_crc:1;
         unsigned int bulk_read:1;
+        unsigned int default_compr:2;
 
         struct mutex tnc_mutex;
         struct ubifs_zbranch zroot;
@@ -1212,10 +1223,6 @@ struct ubifs_info {
         int ileb_nxt;
         struct rb_root old_idx;
         int *bottom_up_buf;
-#ifdef CONFIG_UBIFS_FS_DEBUG
-        int new_ihead_lnum;
-        int new_ihead_offs;
-#endif
 
         struct ubifs_mst_node *mst_node;
         int mst_offs;
@@ -1237,7 +1244,6 @@ struct ubifs_info {
         int main_lebs;
         int main_first;
         long long main_bytes;
-        int default_compr;
 
         uint8_t key_hash_type;
         uint32_t (*key_hash)(const char *str, int len);
@@ -1315,8 +1321,8 @@ struct ubifs_info {
         void *sbuf;
         struct list_head idx_gc;
         int idx_gc_cnt;
-        volatile int gc_seq;
-        volatile int gced_lnum;
+        int gc_seq;
+        int gced_lnum;
 
         struct list_head infos_list;
         struct mutex umount_mutex;
@@ -1391,21 +1397,7 @@ struct ubifs_info {
         struct ubifs_mount_opts mount_opts;
 
 #ifdef CONFIG_UBIFS_FS_DEBUG
-        void *dbg_buf;
-        struct ubifs_zbranch old_zroot;
-        int old_zroot_level;
-        unsigned long long old_zroot_sqnum;
-        int failure_mode;
-        int fail_delay;
-        unsigned long fail_timeout;
-        unsigned int fail_cnt;
-        unsigned int fail_cnt_max;
-        long long chk_lpt_sz;
-        long long chk_lpt_sz2;
-        long long chk_lpt_wastage;
-        int chk_lpt_lebs;
-        int new_nhead_lnum;
-        int new_nhead_offs;
+        struct ubifs_debug_info *dbg;
 #endif
 };
 
@@ -1505,7 +1497,7 @@ void ubifs_cancel_ino_op(struct ubifs_info *c, struct inode *inode,
 long long ubifs_get_free_space(struct ubifs_info *c);
 int ubifs_calc_min_idx_lebs(struct ubifs_info *c);
 void ubifs_convert_page_budget(struct ubifs_info *c);
-long long ubifs_reported_space(const struct ubifs_info *c, uint64_t free);
+long long ubifs_reported_space(const struct ubifs_info *c, long long free);
 long long ubifs_calc_available(const struct ubifs_info *c, int min_idx_lebs);
 
 /* find.c */
@@ -1639,6 +1631,9 @@ void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty);
 void ubifs_add_nnode_dirt(struct ubifs_info *c, struct ubifs_nnode *nnode);
 uint32_t ubifs_unpack_bits(uint8_t **addr, int *pos, int nrbits);
 struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght);
+/* Needed only in debugging code in lpt_commit.c */
+int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
+                       struct ubifs_nnode *nnode);
 
 /* lpt_commit.c */
 int ubifs_lpt_start_commit(struct ubifs_info *c);
@@ -1714,7 +1709,7 @@ long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 
 /* compressor.c */
 int __init ubifs_compressors_init(void);
-void __exit ubifs_compressors_exit(void);
+void ubifs_compressors_exit(void);
 void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,
                     int *compr_type);
 int ubifs_decompress(const void *buf, int len, void *out, int *out_len,
diff --git a/include/linux/dvb/frontend.h b/include/linux/dvb/frontend.h
index 79a8ed8e6a7d..55026b1a40bd 100644
--- a/include/linux/dvb/frontend.h
+++ b/include/linux/dvb/frontend.h
@@ -62,10 +62,11 @@ typedef enum fe_caps {
         FE_CAN_HIERARCHY_AUTO           = 0x100000,
         FE_CAN_8VSB                     = 0x200000,
         FE_CAN_16VSB                    = 0x400000,
-        FE_HAS_EXTENDED_CAPS            = 0x800000,   // We need more bitspace for newer APIs, indicate this.
-        FE_NEEDS_BENDING                = 0x20000000, // not supported anymore, don't use (frontend requires frequency bending)
-        FE_CAN_RECOVER                  = 0x40000000, // frontend can recover from a cable unplug automatically
-        FE_CAN_MUTE_TS                  = 0x80000000  // frontend can stop spurious TS data output
+        FE_HAS_EXTENDED_CAPS            = 0x800000,   /* We need more bitspace for newer APIs, indicate this. */
+        FE_CAN_2G_MODULATION            = 0x10000000, /* frontend supports "2nd generation modulation" (DVB-S2) */
+        FE_NEEDS_BENDING                = 0x20000000, /* not supported anymore, don't use (frontend requires frequency bending) */
+        FE_CAN_RECOVER                  = 0x40000000, /* frontend can recover from a cable unplug automatically */
+        FE_CAN_MUTE_TS                  = 0x80000000  /* frontend can stop spurious TS data output */
 } fe_caps_t;
 
 
@@ -121,15 +122,15 @@ typedef enum fe_sec_mini_cmd {
 
 
 typedef enum fe_status {
-        FE_HAS_SIGNAL   = 0x01,   /*  found something above the noise level */
-        FE_HAS_CARRIER  = 0x02,   /*  found a DVB signal  */
-        FE_HAS_VITERBI  = 0x04,   /*  FEC is stable  */
-        FE_HAS_SYNC     = 0x08,   /*  found sync bytes  */
-        FE_HAS_LOCK     = 0x10,   /*  everything's working... */
-        FE_TIMEDOUT     = 0x20,   /*  no lock within the last ~2 seconds */
-        FE_REINIT       = 0x40    /*  frontend was reinitialized,  */
-} fe_status_t;                    /*  application is recommended to reset */
-                                  /*  DiSEqC, tone and parameters */
+        FE_HAS_SIGNAL   = 0x01,   /* found something above the noise level */
+        FE_HAS_CARRIER  = 0x02,   /* found a DVB signal  */
+        FE_HAS_VITERBI  = 0x04,   /* FEC is stable  */
+        FE_HAS_SYNC     = 0x08,   /* found sync bytes  */
+        FE_HAS_LOCK     = 0x10,   /* everything's working... */
+        FE_TIMEDOUT     = 0x20,   /* no lock within the last ~2 seconds */
+        FE_REINIT       = 0x40    /* frontend was reinitialized,  */
+} fe_status_t;                    /* application is recommended to reset */
+                                  /* DiSEqC, tone and parameters */
 
 typedef enum fe_spectral_inversion {
         INVERSION_OFF,
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index 4ee4b3d2316f..570d20413119 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -79,10 +79,13 @@ static inline unsigned int kstat_irqs(unsigned int irq)
 }
 
 extern unsigned long long task_delta_exec(struct task_struct *);
-extern void account_user_time(struct task_struct *, cputime_t);
-extern void account_user_time_scaled(struct task_struct *, cputime_t);
-extern void account_system_time(struct task_struct *, int, cputime_t);
-extern void account_system_time_scaled(struct task_struct *, cputime_t);
-extern void account_steal_time(struct task_struct *, cputime_t);
+extern void account_user_time(struct task_struct *, cputime_t, cputime_t);
+extern void account_system_time(struct task_struct *, int, cputime_t, cputime_t);
+extern void account_steal_time(cputime_t);
+extern void account_idle_time(cputime_t);
+
+extern void account_process_tick(struct task_struct *, int user);
+extern void account_steal_ticks(unsigned long ticks);
+extern void account_idle_ticks(unsigned long ticks);
 
 #endif /* _LINUX_KERNEL_STAT_H */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 143cebf0586f..7ac8b500d55c 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -151,4 +151,6 @@ static inline void mmc_claim_host(struct mmc_host *host)
         __mmc_claim_host(host, NULL);
 }
 
+extern u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max);
+
 #endif
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index f842f234e44f..4e457256bd33 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -41,6 +41,7 @@ struct mmc_ios {
 
 #define MMC_BUS_WIDTH_1         0
 #define MMC_BUS_WIDTH_4         2
+#define MMC_BUS_WIDTH_8         3
 
         unsigned char   timing;                 /* timing specification used */
 
@@ -116,6 +117,7 @@ struct mmc_host {
 #define MMC_CAP_SDIO_IRQ        (1 << 3)        /* Can signal pending SDIO IRQs */
 #define MMC_CAP_SPI             (1 << 4)        /* Talks only SPI protocols */
 #define MMC_CAP_NEEDS_POLL      (1 << 5)        /* Needs polling for card-detection */
+#define MMC_CAP_8_BIT_DATA      (1 << 6)        /* Can the host do 8 bit transfers */
 
         /* host specific block data */
         unsigned int            max_seg_size;   /* see blk_queue_max_segment_size */
diff --git a/include/linux/random.h b/include/linux/random.h
index adbf3bd3c6b3..407ea3646f8f 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -45,56 +45,6 @@ struct rand_pool_info {
 
 extern void rand_initialize_irq(int irq);
 
-struct timer_rand_state;
-#ifndef CONFIG_SPARSE_IRQ
-
-extern struct timer_rand_state *irq_timer_state[];
-
-static inline struct timer_rand_state *get_timer_rand_state(unsigned int irq)
-{
-        if (irq >= nr_irqs)
-                return NULL;
-
-        return irq_timer_state[irq];
-}
-
-static inline void set_timer_rand_state(unsigned int irq, struct timer_rand_state *state)
-{
-        if (irq >= nr_irqs)
-                return;
-
-        irq_timer_state[irq] = state;
-}
-
-#else
-
-#include <linux/irq.h>
-static inline struct timer_rand_state *get_timer_rand_state(unsigned int irq)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-
-        if (!desc)
-                return NULL;
-
-        return desc->timer_rand_state;
-}
-
-static inline void set_timer_rand_state(unsigned int irq, struct timer_rand_state *state)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-
-        if (!desc)
-                return;
-
-        desc->timer_rand_state = state;
-}
-#endif
-
-
 extern void add_input_randomness(unsigned int type, unsigned int code,
                                  unsigned int value);
 extern void add_interrupt_randomness(int irq);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 158d53d07765..38a3f4b15394 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -284,7 +284,6 @@ long io_schedule_timeout(long timeout);
 
 extern void cpu_init (void);
 extern void trap_init(void);
-extern void account_process_tick(struct task_struct *task, int user);
 extern void update_process_times(int user);
 extern void scheduler_tick(void);
 
diff --git a/include/linux/spi/mmc_spi.h b/include/linux/spi/mmc_spi.h
index a3626aedaec9..0f4eb165f254 100644
--- a/include/linux/spi/mmc_spi.h
+++ b/include/linux/spi/mmc_spi.h
@@ -1,9 +1,10 @@
 #ifndef __LINUX_SPI_MMC_SPI_H
 #define __LINUX_SPI_MMC_SPI_H
 
+#include <linux/device.h>
+#include <linux/spi/spi.h>
 #include <linux/interrupt.h>
 
-struct device;
 struct mmc_host;
 
 /* Put this in platform_data of a device being used to manage an MMC/SD
@@ -41,4 +42,16 @@ struct mmc_spi_platform_data {
         void (*setpower)(struct device *, unsigned int maskval);
 };
 
+#ifdef CONFIG_OF
+extern struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi);
+extern void mmc_spi_put_pdata(struct spi_device *spi);
+#else
+static inline struct mmc_spi_platform_data *
+mmc_spi_get_pdata(struct spi_device *spi)
+{
+        return spi->dev.platform_data;
+}
+static inline void mmc_spi_put_pdata(struct spi_device *spi) {}
+#endif /* CONFIG_OF */
+
 #endif /* __LINUX_SPI_MMC_SPI_H */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 1f126e30766c..5571dbe1c0ad 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -1370,25 +1370,41 @@ struct v4l2_streamparm {
 /*
  *      A D V A N C E D   D E B U G G I N G
  *
- *      NOTE: EXPERIMENTAL API
+ *      NOTE: EXPERIMENTAL API, NEVER RELY ON THIS IN APPLICATIONS!
+ *      FOR DEBUGGING, TESTING AND INTERNAL USE ONLY!
  */
 
 /* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */
 
 #define V4L2_CHIP_MATCH_HOST       0  /* Match against chip ID on host (0 for the host) */
-#define V4L2_CHIP_MATCH_I2C_DRIVER 1  /* Match against I2C driver ID */
+#define V4L2_CHIP_MATCH_I2C_DRIVER 1  /* Match against I2C driver name */
 #define V4L2_CHIP_MATCH_I2C_ADDR   2  /* Match against I2C 7-bit address */
 #define V4L2_CHIP_MATCH_AC97       3  /* Match against anciliary AC97 chip */
 
-struct v4l2_register {
-        __u32 match_type; /* Match type */
-        __u32 match_chip; /* Match this chip, meaning determined by match_type */
+struct v4l2_dbg_match {
+        __u32 type; /* Match type */
+        union {     /* Match this chip, meaning determined by type */
+                __u32 addr;
+                char name[32];
+        };
+} __attribute__ ((packed));
+
+struct v4l2_dbg_register {
+        struct v4l2_dbg_match match;
+        __u32 size;     /* register size in bytes */
         __u64 reg;
         __u64 val;
-};
+} __attribute__ ((packed));
+
+/* VIDIOC_DBG_G_CHIP_IDENT */
+struct v4l2_dbg_chip_ident {
+        struct v4l2_dbg_match match;
+        __u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
+        __u32 revision;    /* chip revision, chip specific */
+} __attribute__ ((packed));
 
-/* VIDIOC_G_CHIP_IDENT */
-struct v4l2_chip_ident {
+/* VIDIOC_G_CHIP_IDENT_OLD: Deprecated, do not use */
+struct v4l2_chip_ident_old {
         __u32 match_type;  /* Match type */
         __u32 match_chip;  /* Match this chip, meaning determined by match_type */
         __u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
@@ -1460,13 +1476,22 @@ struct v4l2_chip_ident {
 #define VIDIOC_G_ENC_INDEX       _IOR('V', 76, struct v4l2_enc_idx)
 #define VIDIOC_ENCODER_CMD      _IOWR('V', 77, struct v4l2_encoder_cmd)
 #define VIDIOC_TRY_ENCODER_CMD  _IOWR('V', 78, struct v4l2_encoder_cmd)
+#endif
 
-/* Experimental, only implemented if CONFIG_VIDEO_ADV_DEBUG is defined */
-#define VIDIOC_DBG_S_REGISTER    _IOW('V', 79, struct v4l2_register)
-#define VIDIOC_DBG_G_REGISTER   _IOWR('V', 80, struct v4l2_register)
-
-#define VIDIOC_G_CHIP_IDENT     _IOWR('V', 81, struct v4l2_chip_ident)
+#if 1
+/* Experimental, meant for debugging, testing and internal use.
+   Only implemented if CONFIG_VIDEO_ADV_DEBUG is defined.
+   You must be root to use these ioctls. Never use these in applications! */
+#define VIDIOC_DBG_S_REGISTER    _IOW('V', 79, struct v4l2_dbg_register)
+#define VIDIOC_DBG_G_REGISTER   _IOWR('V', 80, struct v4l2_dbg_register)
+
+/* Experimental, meant for debugging, testing and internal use.
+   Never use this ioctl in applications! */
+#define VIDIOC_DBG_G_CHIP_IDENT _IOWR('V', 81, struct v4l2_dbg_chip_ident)
+/* This is deprecated and will go away in 2.6.30 */
+#define VIDIOC_G_CHIP_IDENT_OLD _IOWR('V', 81, struct v4l2_chip_ident_old)
 #endif
+
 #define VIDIOC_S_HW_FREQ_SEEK    _IOW('V', 82, struct v4l2_hw_freq_seek)
 /* Reminder: when adding new ioctls please add support for them to
    drivers/media/video/v4l2-compat-ioctl32.c as well! */
diff --git a/include/media/saa7146_vv.h b/include/media/saa7146_vv.h
index 6bbb0d93bb5f..c8d0b23fde29 100644
--- a/include/media/saa7146_vv.h
+++ b/include/media/saa7146_vv.h
@@ -177,9 +177,9 @@ struct saa7146_ext_vv
         int (*std_callback)(struct saa7146_dev*, struct saa7146_standard *);
 
         struct saa7146_extension_ioctls *ioctls;
-        int (*ioctl)(struct saa7146_fh*, unsigned int cmd, void *arg);
+        long (*ioctl)(struct saa7146_fh *, unsigned int cmd, void *arg);
 
-        struct file_operations vbi_fops;
+        struct v4l2_file_operations vbi_fops;
 };
 
 struct saa7146_use_ops  {
@@ -216,7 +216,7 @@ void saa7146_set_gpio(struct saa7146_dev *saa, u8 pin, u8 data);
 extern struct saa7146_use_ops saa7146_video_uops;
 int saa7146_start_preview(struct saa7146_fh *fh);
 int saa7146_stop_preview(struct saa7146_fh *fh);
-int saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
+long saa7146_video_do_ioctl(struct file *file, unsigned int cmd, void *arg);
 
 /* from saa7146_vbi.c */
 extern struct saa7146_use_ops saa7146_vbi_uops;
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index 425b6a98c95c..7440d9250665 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -164,12 +164,12 @@ struct soc_camera_ops {
         unsigned long (*query_bus_param)(struct soc_camera_device *);
         int (*set_bus_param)(struct soc_camera_device *, unsigned long);
         int (*get_chip_id)(struct soc_camera_device *,
-                           struct v4l2_chip_ident *);
+                           struct v4l2_dbg_chip_ident *);
         int (*set_std)(struct soc_camera_device *, v4l2_std_id *);
         int (*enum_input)(struct soc_camera_device *, struct v4l2_input *);
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-        int (*get_register)(struct soc_camera_device *, struct v4l2_register *);
-        int (*set_register)(struct soc_camera_device *, struct v4l2_register *);
+        int (*get_register)(struct soc_camera_device *, struct v4l2_dbg_register *);
+        int (*set_register)(struct soc_camera_device *, struct v4l2_dbg_register *);
 #endif
         int (*get_control)(struct soc_camera_device *, struct v4l2_control *);
         int (*set_control)(struct soc_camera_device *, struct v4l2_control *);
diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h
index 43dbb659f1f5..9aaf652b20ef 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -2,7 +2,7 @@
     v4l2 chip identifiers header
 
     This header provides a list of chip identifiers that can be returned
-    through the VIDIOC_G_CHIP_IDENT ioctl.
+    through the VIDIOC_DBG_G_CHIP_IDENT ioctl.
 
     Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
 
@@ -24,7 +24,7 @@
 #ifndef V4L2_CHIP_IDENT_H_
 #define V4L2_CHIP_IDENT_H_
 
-/* VIDIOC_G_CHIP_IDENT: identifies the actual chip installed on the board */
+/* VIDIOC_DBG_G_CHIP_IDENT: identifies the actual chip installed on the board */
 enum {
         /* general idents: reserved range 0-49 */
         V4L2_IDENT_NONE      = 0,       /* No chip matched */
diff --git a/include/media/v4l2-common.h b/include/media/v4l2-common.h
index f99c866d8c37..95e74f1874e1 100644
--- a/include/media/v4l2-common.h
+++ b/include/media/v4l2-common.h
@@ -114,10 +114,10 @@ u32 v4l2_ctrl_next(const u32 * const *ctrl_classes, u32 id);
 /* Register/chip ident helper function */
 
 struct i2c_client; /* forward reference */
-int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 id_type, u32 chip_id);
-int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
+int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match);
+int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
                 u32 ident, u32 revision);
-int v4l2_chip_match_host(u32 id_type, u32 chip_id);
+int v4l2_chip_match_host(const struct v4l2_dbg_match *match);
 
 /* ------------------------------------------------------------------------- */
 
diff --git a/include/media/v4l2-dev.h b/include/media/v4l2-dev.h
index 0a88d1d17d30..e36faab8459b 100644
--- a/include/media/v4l2-dev.h
+++ b/include/media/v4l2-dev.h
@@ -25,6 +25,7 @@
 #define VFL_TYPE_MAX            4
 
 struct v4l2_ioctl_callbacks;
+struct video_device;
 struct v4l2_device;
 
 /* Flag to mark the video_device struct as unregistered.
@@ -32,6 +33,18 @@ struct v4l2_device;
    device access. It is set by video_unregister_device. */
 #define V4L2_FL_UNREGISTERED    (0)
 
+struct v4l2_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);
+        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
+        int (*mmap) (struct file *, struct vm_area_struct *);
+        int (*open) (struct file *);
+        int (*release) (struct file *);
+};
+
 /*
  * Newer version of video_device, handled by videodev2.c
  *      This version moves redundant code from video device code to
@@ -41,7 +54,7 @@ struct v4l2_device;
 struct video_device
 {
         /* device ops */
-        const struct file_operations *fops;
+        const struct v4l2_file_operations *fops;
 
         /* sysfs */
         struct device dev;              /* v4l device */
diff --git a/include/media/v4l2-device.h b/include/media/v4l2-device.h
index 97b283a04289..9bf4ccc93dbf 100644
--- a/include/media/v4l2-device.h
+++ b/include/media/v4l2-device.h
@@ -80,7 +80,7 @@ void v4l2_device_unregister_subdev(struct v4l2_subdev *sd);
 #define __v4l2_device_call_subdevs_until_err(dev, cond, o, f, args...)  \
 ({                                                                      \
         struct v4l2_subdev *sd;                                         \
-        int err = 0;                                                    \
+        long err = 0;                                                   \
                                                                         \
         list_for_each_entry(sd, &(dev)->subdevs, list) {                \
                 if ((cond) && sd->ops->o && sd->ops->o->f)              \
diff --git a/include/media/v4l2-int-device.h b/include/media/v4l2-int-device.h
index ecda3c725837..fbf585561570 100644
--- a/include/media/v4l2-int-device.h
+++ b/include/media/v4l2-int-device.h
@@ -219,7 +219,7 @@ enum v4l2_int_ioctl_num {
         vidioc_int_reset_num,
         /* VIDIOC_INT_INIT */
         vidioc_int_init_num,
-        /* VIDIOC_INT_G_CHIP_IDENT */
+        /* VIDIOC_DBG_G_CHIP_IDENT */
         vidioc_int_g_chip_ident_num,
 
         /*
diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
index fcdb58c4ce07..b01c044868d0 100644
--- a/include/media/v4l2-ioctl.h
+++ b/include/media/v4l2-ioctl.h
@@ -225,12 +225,12 @@ struct v4l2_ioctl_ops {
         /* Debugging ioctls */
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         int (*vidioc_g_register)       (struct file *file, void *fh,
-                                        struct v4l2_register *reg);
+                                        struct v4l2_dbg_register *reg);
         int (*vidioc_s_register)       (struct file *file, void *fh,
-                                        struct v4l2_register *reg);
+                                        struct v4l2_dbg_register *reg);
 #endif
         int (*vidioc_g_chip_ident)     (struct file *file, void *fh,
-                                        struct v4l2_chip_ident *chip);
+                                        struct v4l2_dbg_chip_ident *chip);
 
         int (*vidioc_enum_framesizes)   (struct file *file, void *fh,
                                          struct v4l2_frmsizeenum *fsize);
@@ -239,7 +239,7 @@ struct v4l2_ioctl_ops {
                                            struct v4l2_frmivalenum *fival);
 
         /* For other private ioctls */
-        int (*vidioc_default)          (struct file *file, void *fh,
+        long (*vidioc_default)         (struct file *file, void *fh,
                                         int cmd, void *arg);
 };
 
@@ -277,36 +277,27 @@ extern const char *v4l2_field_names[];
 extern const char *v4l2_type_names[];
 
 /*  Compatibility layer interface  --  v4l1-compat module */
-typedef int (*v4l2_kioctl)(struct file *file,
+typedef long (*v4l2_kioctl)(struct file *file,
                            unsigned int cmd, void *arg);
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
-int v4l_compat_translate_ioctl(struct file *file,
+long v4l_compat_translate_ioctl(struct file *file,
                                int cmd, void *arg, v4l2_kioctl driver_ioctl);
 #else
 #define v4l_compat_translate_ioctl(file, cmd, arg, ioctl) (-EINVAL)
 #endif
 
+#ifdef CONFIG_COMPAT
 /* 32 Bits compatibility layer for 64 bits processors */
-extern long v4l_compat_ioctl32(struct file *file, unsigned int cmd,
+extern long v4l2_compat_ioctl32(struct file *file, unsigned int cmd,
                                 unsigned long arg);
+#endif
 
 /* Include support for obsoleted stuff */
-extern int video_usercopy(struct file *file, unsigned int cmd,
+extern long video_usercopy(struct file *file, unsigned int cmd,
                                 unsigned long arg, v4l2_kioctl func);
 
 /* Standard handlers for V4L ioctl's */
-
-/* This prototype is used on fops.unlocked_ioctl */
-extern long __video_ioctl2(struct file *file,
-                        unsigned int cmd, unsigned long arg);
-
-/* This prototype is used on fops.ioctl
- * Since fops.ioctl enables Kernel Big Lock, it is preferred
- * to use __video_ioctl2 instead.
- * It should be noticed that there's no lock code inside
- * video_ioctl2().
- */
-extern int video_ioctl2(struct inode *inode, struct file *file,
+extern long video_ioctl2(struct file *file,
                         unsigned int cmd, unsigned long arg);
 
 #endif /* _V4L2_IOCTL_H */
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index ceef016bb0b7..37b09e56e943 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -69,7 +69,7 @@ struct tuner_setup;
    not yet implemented) since ops provide proper type-checking.
  */
 struct v4l2_subdev_core_ops {
-        int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip);
+        int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);
         int (*log_status)(struct v4l2_subdev *sd);
         int (*init)(struct v4l2_subdev *sd, u32 val);
         int (*s_standby)(struct v4l2_subdev *sd, u32 standby);
@@ -79,10 +79,10 @@ struct v4l2_subdev_core_ops {
         int (*g_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
         int (*s_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
         int (*querymenu)(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
-        int (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
+        long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-        int (*g_register)(struct v4l2_subdev *sd, struct v4l2_register *reg);
-        int (*s_register)(struct v4l2_subdev *sd, struct v4l2_register *reg);
+        int (*g_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
+        int (*s_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
 #endif
 };
 
diff --git a/include/sound/tea575x-tuner.h b/include/sound/tea575x-tuner.h
index b6870cbaf2b3..426899e529c5 100644
--- a/include/sound/tea575x-tuner.h
+++ b/include/sound/tea575x-tuner.h
@@ -36,7 +36,7 @@ struct snd_tea575x_ops {
 struct snd_tea575x {
         struct snd_card *card;
         struct video_device vd;         /* video device */
-        struct file_operations fops;
+        struct v4l2_file_operations fops;
         int dev_nr;                     /* requested device number + 1 */
         int vd_registered;              /* video device is registered */
         int tea5759;                    /* 5759 chip is present */
diff --git a/kernel/sched.c b/kernel/sched.c
index 27ba1d642f0f..930bf2e6d714 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4150,13 +4150,17 @@ unsigned long long task_delta_exec(struct task_struct *p)
  * Account user cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @cputime: the cpu time spent in user space since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
-void account_user_time(struct task_struct *p, cputime_t cputime)
+void account_user_time(struct task_struct *p, cputime_t cputime,
+                       cputime_t cputime_scaled)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
         cputime64_t tmp;
 
+        /* Add user time to process. */
         p->utime = cputime_add(p->utime, cputime);
+        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
         account_group_user_time(p, cputime);
 
         /* Add user time to cpustat. */
@@ -4173,51 +4177,48 @@ void account_user_time(struct task_struct *p, cputime_t cputime)
  * Account guest cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @cputime: the cpu time spent in virtual machine since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
-static void account_guest_time(struct task_struct *p, cputime_t cputime)
+static void account_guest_time(struct task_struct *p, cputime_t cputime,
+                               cputime_t cputime_scaled)
 {
         cputime64_t tmp;
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 
         tmp = cputime_to_cputime64(cputime);
 
+        /* Add guest time to process. */
         p->utime = cputime_add(p->utime, cputime);
+        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
         account_group_user_time(p, cputime);
         p->gtime = cputime_add(p->gtime, cputime);
 
+        /* Add guest time to cpustat. */
         cpustat->user = cputime64_add(cpustat->user, tmp);
         cpustat->guest = cputime64_add(cpustat->guest, tmp);
 }
 
 /*
- * Account scaled user cpu time to a process.
- * @p: the process that the cpu time gets accounted to
- * @cputime: the cpu time spent in user space since the last update
- */
-void account_user_time_scaled(struct task_struct *p, cputime_t cputime)
-{
-        p->utimescaled = cputime_add(p->utimescaled, cputime);
-}
-
-/*
  * Account system cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @hardirq_offset: the offset to subtract from hardirq_count()
  * @cputime: the cpu time spent in kernel space since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
 void account_system_time(struct task_struct *p, int hardirq_offset,
-                         cputime_t cputime)
+                         cputime_t cputime, cputime_t cputime_scaled)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        struct rq *rq = this_rq();
         cputime64_t tmp;
 
         if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
-                account_guest_time(p, cputime);
+                account_guest_time(p, cputime, cputime_scaled);
                 return;
         }
 
+        /* Add system time to process. */
         p->stime = cputime_add(p->stime, cputime);
+        p->stimescaled = cputime_add(p->stimescaled, cputime_scaled);
         account_group_system_time(p, cputime);
 
         /* Add system time to cpustat. */
@@ -4226,48 +4227,84 @@ void account_system_time(struct task_struct *p, int hardirq_offset,
                 cpustat->irq = cputime64_add(cpustat->irq, tmp);
         else if (softirq_count())
                 cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
-        else if (p != rq->idle)
-                cpustat->system = cputime64_add(cpustat->system, tmp);
-        else if (atomic_read(&rq->nr_iowait) > 0)
-                cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
         else
-                cpustat->idle = cputime64_add(cpustat->idle, tmp);
+                cpustat->system = cputime64_add(cpustat->system, tmp);
+
         /* Account for system time used */
         acct_update_integrals(p);
 }
 
 /*
- * Account scaled system cpu time to a process.
- * @p: the process that the cpu time gets accounted to
- * @hardirq_offset: the offset to subtract from hardirq_count()
- * @cputime: the cpu time spent in kernel space since the last update
+ * Account for involuntary wait time.
+ * @steal: the cpu time spent in involuntary wait
  */
-void account_system_time_scaled(struct task_struct *p, cputime_t cputime)
+void account_steal_time(cputime_t cputime)
 {
-        p->stimescaled = cputime_add(p->stimescaled, cputime);
+        struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
+        cputime64_t cputime64 = cputime_to_cputime64(cputime);
+
+        cpustat->steal = cputime64_add(cpustat->steal, cputime64);
 }
 
 /*
- * Account for involuntary wait time.
- * @p: the process from which the cpu time has been stolen
- * @steal: the cpu time spent in involuntary wait
+ * Account for idle time.
+ * @cputime: the cpu time spent in idle wait
  */
-void account_steal_time(struct task_struct *p, cputime_t steal)
+void account_idle_time(cputime_t cputime)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        cputime64_t tmp = cputime_to_cputime64(steal);
+        cputime64_t cputime64 = cputime_to_cputime64(cputime);
         struct rq *rq = this_rq();
 
-        if (p == rq->idle) {
-                p->stime = cputime_add(p->stime, steal);
-                if (atomic_read(&rq->nr_iowait) > 0)
-                        cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
-                else
-                        cpustat->idle = cputime64_add(cpustat->idle, tmp);
-        } else
-                cpustat->steal = cputime64_add(cpustat->steal, tmp);
+        if (atomic_read(&rq->nr_iowait) > 0)
+                cpustat->iowait = cputime64_add(cpustat->iowait, cputime64);
+        else
+                cpustat->idle = cputime64_add(cpustat->idle, cputime64);
 }
 
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
+
+/*
+ * Account a single tick of cpu time.
+ * @p: the process that the cpu time gets accounted to
+ * @user_tick: indicates if the tick is a user or a system tick
+ */
+void account_process_tick(struct task_struct *p, int user_tick)
+{
+        cputime_t one_jiffy = jiffies_to_cputime(1);
+        cputime_t one_jiffy_scaled = cputime_to_scaled(one_jiffy);
+        struct rq *rq = this_rq();
+
+        if (user_tick)
+                account_user_time(p, one_jiffy, one_jiffy_scaled);
+        else if (p != rq->idle)
+                account_system_time(p, HARDIRQ_OFFSET, one_jiffy,
+                                    one_jiffy_scaled);
+        else
+                account_idle_time(one_jiffy);
+}
+
+/*
+ * Account multiple ticks of steal time.
+ * @p: the process from which the cpu time has been stolen
+ * @ticks: number of stolen ticks
+ */
+void account_steal_ticks(unsigned long ticks)
+{
+        account_steal_time(jiffies_to_cputime(ticks));
+}
+
+/*
+ * Account multiple ticks of idle time.
+ * @ticks: number of stolen ticks
+ */
+void account_idle_ticks(unsigned long ticks)
+{
+        account_idle_time(jiffies_to_cputime(ticks));
+}
+
+#endif
+
 /*
  * Use precise platform statistics if available:
  */
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 76a574bbef97..1b6c05bd0d0a 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -419,7 +419,9 @@ void tick_nohz_restart_sched_tick(void)
 {
         int cpu = smp_processor_id();
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
         unsigned long ticks;
+#endif
         ktime_t now;
 
         local_irq_disable();
@@ -441,6 +443,7 @@ void tick_nohz_restart_sched_tick(void)
         tick_do_update_jiffies64(now);
         cpumask_clear_cpu(cpu, nohz_cpu_mask);
 
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
         /*
          * We stopped the tick in idle. Update process times would miss the
          * time we slept as update_process_times does only a 1 tick
@@ -450,12 +453,9 @@ void tick_nohz_restart_sched_tick(void)
         /*
          * We might be one off. Do not randomly account a huge number of ticks!
          */
-        if (ticks && ticks < LONG_MAX) {
-                add_preempt_count(HARDIRQ_OFFSET);
-                account_system_time(current, HARDIRQ_OFFSET,
-                                    jiffies_to_cputime(ticks));
-                sub_preempt_count(HARDIRQ_OFFSET);
-        }
+        if (ticks && ticks < LONG_MAX)
+                account_idle_ticks(ticks);
+#endif
 
         touch_softlockup_watchdog();
         /*
diff --git a/kernel/timer.c b/kernel/timer.c
index 566257d1dc10..dee3f641a7a7 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1018,21 +1018,6 @@ unsigned long get_next_timer_interrupt(unsigned long now)
 }
 #endif
 
-#ifndef CONFIG_VIRT_CPU_ACCOUNTING
-void account_process_tick(struct task_struct *p, int user_tick)
-{
-        cputime_t one_jiffy = jiffies_to_cputime(1);
-
-        if (user_tick) {
-                account_user_time(p, one_jiffy);
-                account_user_time_scaled(p, cputime_to_scaled(one_jiffy));
-        } else {
-                account_system_time(p, HARDIRQ_OFFSET, one_jiffy);
-                account_system_time_scaled(p, cputime_to_scaled(one_jiffy));
-        }
-}
-#endif
-
 /*
  * Called from the timer interrupt handler to charge one tick to the current
  * process.  user_tick is 1 if the tick is user time, 0 for system.
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 3b777025d876..98d632277ca8 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -661,6 +661,9 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
  */
 static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field_width, int precision, int flags)
 {
+        if (!ptr)
+                return string(buf, end, "(null)", field_width, precision, flags);
+
         switch (*fmt) {
         case 'F':
                 ptr = dereference_function_descriptor(ptr);
diff --git a/scripts/headers_check.pl b/scripts/headers_check.pl
index 488a3b1f760f..db30fac3083e 100644
--- a/scripts/headers_check.pl
+++ b/scripts/headers_check.pl
@@ -14,7 +14,9 @@
 #    Only include files located in asm* and linux* are checked.
 #    The rest are assumed to be system include files.
 #
-# 2) TODO: check for leaked CONFIG_ symbols
+# 2) It is checked that prototypes does not use "extern"
+#
+# 3) Check for leaked CONFIG_ symbols
 
 use strict;
 
@@ -32,7 +34,11 @@ foreach my $file (@files) {
         $lineno = 0;
         while ($line = <FH>) {
                 $lineno++;
-                check_include();
+                &check_include();
+                &check_asm_types();
+                &check_sizetypes();
+                &check_prototypes();
+                &check_config();
         }
         close FH;
 }
@@ -54,3 +60,63 @@ sub check_include
                 }
         }
 }
+
+sub check_prototypes
+{
+        if ($line =~ m/^\s*extern\b/) {
+                printf STDERR "$filename:$lineno: extern's make no sense in userspace\n";
+        }
+}
+
+sub check_config
+{
+        if ($line =~ m/[^a-zA-Z0-9_]+CONFIG_([a-zA-Z0-9]+)[^a-zA-Z0-9]/) {
+                printf STDERR "$filename:$lineno: leaks CONFIG_$1 to userspace where it is not valid\n";
+        }
+}
+
+my $linux_asm_types;
+sub check_asm_types()
+{
+        if ($filename =~ /types.h|int-l64.h|int-ll64.h/o) {
+                return;
+        }
+        if ($lineno == 1) {
+                $linux_asm_types = 0;
+        } elsif ($linux_asm_types >= 1) {
+                return;
+        }
+        if ($line =~ m/^\s*#\s*include\s+<asm\/types.h>/) {
+                $linux_asm_types = 1;
+                printf STDERR "$filename:$lineno: " .
+                "include of <linux/types.h> is preferred over <asm/types.h>\n"
+                # Warn until headers are all fixed
+                #$ret = 1;
+        }
+}
+
+my $linux_types;
+sub check_sizetypes
+{
+        if ($filename =~ /types.h|int-l64.h|int-ll64.h/o) {
+                return;
+        }
+        if ($lineno == 1) {
+                $linux_types = 0;
+        } elsif ($linux_types >= 1) {
+                return;
+        }
+        if ($line =~ m/^\s*#\s*include\s+<linux\/types.h>/) {
+                $linux_types = 1;
+                return;
+        }
+        if ($line =~ m/__[us](8|16|32|64)\b/) {
+                printf STDERR "$filename:$lineno: " .
+                              "found __[us]{8,16,32,64} type " .
+                              "without #include <linux/types.h>\n";
+                $linux_types = 2;
+                # Warn until headers are all fixed
+                #$ret = 1;
+        }
+}
+
diff --git a/scripts/headers_install.pl b/scripts/headers_install.pl
index 7d2b4146e02f..c6ae4052ab43 100644
--- a/scripts/headers_install.pl
+++ b/scripts/headers_install.pl
@@ -36,6 +36,9 @@ foreach my $file (@files) {
                 $line =~ s/\s__attribute_const__\s/ /g;
                 $line =~ s/\s__attribute_const__$//g;
                 $line =~ s/^#include <linux\/compiler.h>//;
+                $line =~ s/(^|\s)(inline)\b/$1__$2__/g;
+                $line =~ s/(^|\s)(asm)\b(\s|[(]|$)/$1__$2__$3/g;
+                $line =~ s/(^|\s|[(])(volatile)\b(\s|[(]|$)/$1__$2__$3/g;
                 printf OUTFILE "%s", $line;
         }
         close OUTFILE;
diff --git a/scripts/kconfig/expr.h b/scripts/kconfig/expr.h
index 9d4cba1c001d..6408fefae083 100644
--- a/scripts/kconfig/expr.h
+++ b/scripts/kconfig/expr.h
@@ -65,9 +65,13 @@ enum symbol_type {
         S_UNKNOWN, S_BOOLEAN, S_TRISTATE, S_INT, S_HEX, S_STRING, S_OTHER
 };
 
+/* enum values are used as index to symbol.def[] */
 enum {
         S_DEF_USER,             /* main user value */
-        S_DEF_AUTO,
+        S_DEF_AUTO,             /* values read from auto.conf */
+        S_DEF_DEF3,             /* Reserved for UI usage */
+        S_DEF_DEF4,             /* Reserved for UI usage */
+        S_DEF_COUNT
 };
 
 struct symbol {
@@ -75,7 +79,7 @@ struct symbol {
         char *name;
         enum symbol_type type;
         struct symbol_value curr;
-        struct symbol_value def[4];
+        struct symbol_value def[S_DEF_COUNT];
         tristate visible;
         int flags;
         struct property *prop;
@@ -84,42 +88,64 @@ struct symbol {
 
 #define for_all_symbols(i, sym) for (i = 0; i < 257; i++) for (sym = symbol_hash[i]; sym; sym = sym->next) if (sym->type != S_OTHER)
 
-#define SYMBOL_CONST            0x0001
-#define SYMBOL_CHECK            0x0008
-#define SYMBOL_CHOICE           0x0010
-#define SYMBOL_CHOICEVAL        0x0020
-#define SYMBOL_VALID            0x0080
-#define SYMBOL_OPTIONAL         0x0100
-#define SYMBOL_WRITE            0x0200
-#define SYMBOL_CHANGED          0x0400
-#define SYMBOL_AUTO             0x1000
-#define SYMBOL_CHECKED          0x2000
-#define SYMBOL_WARNED           0x8000
-#define SYMBOL_DEF              0x10000
-#define SYMBOL_DEF_USER         0x10000
-#define SYMBOL_DEF_AUTO         0x20000
-#define SYMBOL_DEF3             0x40000
-#define SYMBOL_DEF4             0x80000
+#define SYMBOL_CONST      0x0001  /* symbol is const */
+#define SYMBOL_CHECK      0x0008  /* used during dependency checking */
+#define SYMBOL_CHOICE     0x0010  /* start of a choice block (null name) */
+#define SYMBOL_CHOICEVAL  0x0020  /* used as a value in a choice block */
+#define SYMBOL_VALID      0x0080  /* set when symbol.curr is calculated */
+#define SYMBOL_OPTIONAL   0x0100  /* choice is optional - values can be 'n' */
+#define SYMBOL_WRITE      0x0200  /* ? */
+#define SYMBOL_CHANGED    0x0400  /* ? */
+#define SYMBOL_AUTO       0x1000  /* value from environment variable */
+#define SYMBOL_CHECKED    0x2000  /* used during dependency checking */
+#define SYMBOL_WARNED     0x8000  /* warning has been issued */
+
+/* Set when symbol.def[] is used */
+#define SYMBOL_DEF        0x10000  /* First bit of SYMBOL_DEF */
+#define SYMBOL_DEF_USER   0x10000  /* symbol.def[S_DEF_USER] is valid */
+#define SYMBOL_DEF_AUTO   0x20000  /* symbol.def[S_DEF_AUTO] is valid */
+#define SYMBOL_DEF3       0x40000  /* symbol.def[S_DEF_3] is valid */
+#define SYMBOL_DEF4       0x80000  /* symbol.def[S_DEF_4] is valid */
 
 #define SYMBOL_MAXLENGTH        256
 #define SYMBOL_HASHSIZE         257
 #define SYMBOL_HASHMASK         0xff
 
+/* A property represent the config options that can be associated
+ * with a config "symbol".
+ * Sample:
+ * config FOO
+ *         default y
+ *         prompt "foo prompt"
+ *         select BAR
+ * config BAZ
+ *         int "BAZ Value"
+ *         range 1..255
+ */
 enum prop_type {
-        P_UNKNOWN, P_PROMPT, P_COMMENT, P_MENU, P_DEFAULT, P_CHOICE,
-        P_SELECT, P_RANGE, P_ENV
+        P_UNKNOWN,
+        P_PROMPT,   /* prompt "foo prompt" or "BAZ Value" */
+        P_COMMENT,  /* text associated with a comment */
+        P_MENU,     /* prompt associated with a menuconfig option */
+        P_DEFAULT,  /* default y */
+        P_CHOICE,   /* choice value */
+        P_SELECT,   /* select BAR */
+        P_RANGE,    /* range 7..100 (for a symbol) */
+        P_ENV,      /* value from environment variable */
 };
 
 struct property {
-        struct property *next;
-        struct symbol *sym;
-        enum prop_type type;
-        const char *text;
+        struct property *next;     /* next property - null if last */
+        struct symbol *sym;        /* the symbol for which the property is associated */
+        enum prop_type type;       /* type of property */
+        const char *text;          /* the prompt value - P_PROMPT, P_MENU, P_COMMENT */
         struct expr_value visible;
-        struct expr *expr;
-        struct menu *menu;
-        struct file *file;
-        int lineno;
+        struct expr *expr;         /* the optional conditional part of the property */
+        struct menu *menu;         /* the menu the property are associated with
+                                    * valid for: P_SELECT, P_RANGE, P_CHOICE,
+                                    * P_PROMPT, P_DEFAULT, P_MENU, P_COMMENT */
+        struct file *file;         /* what file was this property defined */
+        int lineno;                /* what lineno was this property defined */
 };
 
 #define for_all_properties(sym, st, tok) \
diff --git a/scripts/kconfig/lex.zconf.c_shipped b/scripts/kconfig/lex.zconf.c_shipped
index 7342ce0a7780..dc3e81807d13 100644
--- a/scripts/kconfig/lex.zconf.c_shipped
+++ b/scripts/kconfig/lex.zconf.c_shipped
@@ -2370,11 +2370,14 @@ void zconf_nextfile(const char *name)
         current_buf = buf;
 
         if (file->flags & FILE_BUSY) {
-                printf("recursive scan (%s)?\n", name);
+                printf("%s:%d: do not source '%s' from itself\n",
+                       zconf_curname(), zconf_lineno(), name);
                 exit(1);
         }
         if (file->flags & FILE_SCANNED) {
-                printf("file %s already scanned?\n", name);
+                printf("%s:%d: file '%s' is already sourced from '%s'\n",
+                       zconf_curname(), zconf_lineno(), name,
+                       file->parent->name);
                 exit(1);
         }
         file->flags |= FILE_BUSY;
diff --git a/scripts/kconfig/zconf.l b/scripts/kconfig/zconf.l
index 5164ef7ce499..21ff69c9ad4e 100644
--- a/scripts/kconfig/zconf.l
+++ b/scripts/kconfig/zconf.l
@@ -314,11 +314,14 @@ void zconf_nextfile(const char *name)
         current_buf = buf;
 
         if (file->flags & FILE_BUSY) {
-                printf("recursive scan (%s)?\n", name);
+                printf("%s:%d: do not source '%s' from itself\n",
+                       zconf_curname(), zconf_lineno(), name);
                 exit(1);
         }
         if (file->flags & FILE_SCANNED) {
-                printf("file %s already scanned?\n", name);
+                printf("%s:%d: file '%s' is already sourced from '%s'\n",
+                       zconf_curname(), zconf_lineno(), name,
+                       file->parent->name);
                 exit(1);
         }
         file->flags |= FILE_BUSY;
diff --git a/scripts/tags.sh b/scripts/tags.sh
index 4e7547209852..9e3451d2c3a1 100755
--- a/scripts/tags.sh
+++ b/scripts/tags.sh
@@ -84,7 +84,6 @@ docscope()
 
 exuberant()
 {
-        all_sources > all
         all_sources | xargs $1 -a                               \
         -I __initdata,__exitdata,__acquires,__releases          \
         -I __read_mostly,____cacheline_aligned                  \
diff --git a/sound/i2c/other/tea575x-tuner.c b/sound/i2c/other/tea575x-tuner.c
index 549b4eba1496..9d98a6658ac9 100644
--- a/sound/i2c/other/tea575x-tuner.c
+++ b/sound/i2c/other/tea575x-tuner.c
@@ -84,7 +84,7 @@ static void snd_tea575x_set_freq(struct snd_tea575x *tea)
  * Linux Video interface
  */
 
-static int snd_tea575x_ioctl(struct inode *inode, struct file *file,
+static long snd_tea575x_ioctl(struct file *file,
                              unsigned int cmd, unsigned long data)
 {
         struct snd_tea575x *tea = video_drvdata(file);
@@ -174,14 +174,14 @@ static void snd_tea575x_release(struct video_device *vfd)
 {
 }
 
-static int snd_tea575x_exclusive_open(struct inode *inode, struct file *file)
+static int snd_tea575x_exclusive_open(struct file *file)
 {
         struct snd_tea575x *tea = video_drvdata(file);
 
         return test_and_set_bit(0, &tea->in_use) ? -EBUSY : 0;
 }
 
-static int snd_tea575x_exclusive_release(struct inode *inode, struct file *file)
+static int snd_tea575x_exclusive_release(struct file *file)
 {
         struct snd_tea575x *tea = video_drvdata(file);