From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Mon, 7 Nov 2011 03:44:47 +0000 (-0800)
Subject: Merge branch 'modsplit-Oct31_2011' of git://git.kernel.org/pub/scm/linux/kernel/git... 
X-Git-Tag: Ubuntu-snapdragon-4.4.0-1050.54~16185
X-Git-Url: https://git.proxmox.com/?a=commitdiff_plain;h=32aaeffbd4a7457bf2f7448b33b5946ff2a960eb;p=mirror_ubuntu-artful-kernel.git

Merge branch 'modsplit-Oct31_2011' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux

* 'modsplit-Oct31_2011' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux: (230 commits)
  Revert "tracing: Include module.h in define_trace.h"
  irq: don't put module.h into irq.h for tracking irqgen modules.
  bluetooth: macroize two small inlines to avoid module.h
  ip_vs.h: fix implicit use of module_get/module_put from module.h
  nf_conntrack.h: fix up fallout from implicit moduleparam.h presence
  include: replace linux/module.h with "struct module" wherever possible
  include: convert various register fcns to macros to avoid include chaining
  crypto.h: remove unused crypto_tfm_alg_modname() inline
  uwb.h: fix implicit use of asm/page.h for PAGE_SIZE
  pm_runtime.h: explicitly requires notifier.h
  linux/dmaengine.h: fix implicit use of bitmap.h and asm/page.h
  miscdevice.h: fix up implicit use of lists and types
  stop_machine.h: fix implicit use of smp.h for smp_processor_id
  of: fix implicit use of errno.h in include/linux/of.h
  of_platform.h: delete needless include <linux/module.h>
  acpi: remove module.h include from platform/aclinux.h
  miscdevice.h: delete unnecessary inclusion of module.h
  device_cgroup.h: delete needless include <linux/module.h>
  net: sch_generic remove redundant use of <linux/module.h>
  net: inet_timewait_sock doesnt need <linux/module.h>
  ...

Fix up trivial conflicts (other header files, and  removal of the ab3550 mfd driver) in
 - drivers/media/dvb/frontends/dibx000_common.c
 - drivers/media/video/{mt9m111.c,ov6650.c}
 - drivers/mfd/ab3550-core.c
 - include/linux/dmaengine.h
---

32aaeffbd4a7457bf2f7448b33b5946ff2a960eb
diff --cc arch/arm/mach-exynos/dev-sysmmu.c
index 3b7cae0fe23e,000000000000..781563fcb156
mode 100644,000000..100644
--- a/arch/arm/mach-exynos/dev-sysmmu.c
+++ b/arch/arm/mach-exynos/dev-sysmmu.c
@@@ -1,232 -1,0 +1,233 @@@
 +/* linux/arch/arm/mach-exynos4/dev-sysmmu.c
 + *
 + * Copyright (c) 2010 Samsung Electronics Co., Ltd.
 + *		http://www.samsung.com
 + *
 + * EXYNOS4 - System MMU support
 + *
 + * This program is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License version 2 as
 + * published by the Free Software Foundation.
 + */
 +
 +#include <linux/platform_device.h>
 +#include <linux/dma-mapping.h>
++#include <linux/export.h>
 +
 +#include <mach/map.h>
 +#include <mach/irqs.h>
 +#include <mach/sysmmu.h>
 +#include <plat/s5p-clock.h>
 +
 +/* These names must be equal to the clock names in mach-exynos4/clock.c */
 +const char *sysmmu_ips_name[EXYNOS4_SYSMMU_TOTAL_IPNUM] = {
 +	"SYSMMU_MDMA"	,
 +	"SYSMMU_SSS"	,
 +	"SYSMMU_FIMC0"	,
 +	"SYSMMU_FIMC1"	,
 +	"SYSMMU_FIMC2"	,
 +	"SYSMMU_FIMC3"	,
 +	"SYSMMU_JPEG"	,
 +	"SYSMMU_FIMD0"	,
 +	"SYSMMU_FIMD1"	,
 +	"SYSMMU_PCIe"	,
 +	"SYSMMU_G2D"	,
 +	"SYSMMU_ROTATOR",
 +	"SYSMMU_MDMA2"	,
 +	"SYSMMU_TV"	,
 +	"SYSMMU_MFC_L"	,
 +	"SYSMMU_MFC_R"	,
 +};
 +
 +static struct resource exynos4_sysmmu_resource[] = {
 +	[0] = {
 +		.start	= EXYNOS4_PA_SYSMMU_MDMA,
 +		.end	= EXYNOS4_PA_SYSMMU_MDMA + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[1] = {
 +		.start	= IRQ_SYSMMU_MDMA0_0,
 +		.end	= IRQ_SYSMMU_MDMA0_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[2] = {
 +		.start	= EXYNOS4_PA_SYSMMU_SSS,
 +		.end	= EXYNOS4_PA_SYSMMU_SSS + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[3] = {
 +		.start	= IRQ_SYSMMU_SSS_0,
 +		.end	= IRQ_SYSMMU_SSS_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[4] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMC0,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMC0 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[5] = {
 +		.start	= IRQ_SYSMMU_FIMC0_0,
 +		.end	= IRQ_SYSMMU_FIMC0_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[6] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMC1,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMC1 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[7] = {
 +		.start	= IRQ_SYSMMU_FIMC1_0,
 +		.end	= IRQ_SYSMMU_FIMC1_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[8] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMC2,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMC2 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[9] = {
 +		.start	= IRQ_SYSMMU_FIMC2_0,
 +		.end	= IRQ_SYSMMU_FIMC2_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[10] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMC3,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMC3 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[11] = {
 +		.start	= IRQ_SYSMMU_FIMC3_0,
 +		.end	= IRQ_SYSMMU_FIMC3_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[12] = {
 +		.start	= EXYNOS4_PA_SYSMMU_JPEG,
 +		.end	= EXYNOS4_PA_SYSMMU_JPEG + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[13] = {
 +		.start	= IRQ_SYSMMU_JPEG_0,
 +		.end	= IRQ_SYSMMU_JPEG_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[14] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMD0,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMD0 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[15] = {
 +		.start	= IRQ_SYSMMU_LCD0_M0_0,
 +		.end	= IRQ_SYSMMU_LCD0_M0_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[16] = {
 +		.start	= EXYNOS4_PA_SYSMMU_FIMD1,
 +		.end	= EXYNOS4_PA_SYSMMU_FIMD1 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[17] = {
 +		.start	= IRQ_SYSMMU_LCD1_M1_0,
 +		.end	= IRQ_SYSMMU_LCD1_M1_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[18] = {
 +		.start	= EXYNOS4_PA_SYSMMU_PCIe,
 +		.end	= EXYNOS4_PA_SYSMMU_PCIe + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[19] = {
 +		.start	= IRQ_SYSMMU_PCIE_0,
 +		.end	= IRQ_SYSMMU_PCIE_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[20] = {
 +		.start	= EXYNOS4_PA_SYSMMU_G2D,
 +		.end	= EXYNOS4_PA_SYSMMU_G2D + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[21] = {
 +		.start	= IRQ_SYSMMU_2D_0,
 +		.end	= IRQ_SYSMMU_2D_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[22] = {
 +		.start	= EXYNOS4_PA_SYSMMU_ROTATOR,
 +		.end	= EXYNOS4_PA_SYSMMU_ROTATOR + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[23] = {
 +		.start	= IRQ_SYSMMU_ROTATOR_0,
 +		.end	= IRQ_SYSMMU_ROTATOR_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[24] = {
 +		.start	= EXYNOS4_PA_SYSMMU_MDMA2,
 +		.end	= EXYNOS4_PA_SYSMMU_MDMA2 + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[25] = {
 +		.start	= IRQ_SYSMMU_MDMA1_0,
 +		.end	= IRQ_SYSMMU_MDMA1_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[26] = {
 +		.start	= EXYNOS4_PA_SYSMMU_TV,
 +		.end	= EXYNOS4_PA_SYSMMU_TV + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[27] = {
 +		.start	= IRQ_SYSMMU_TV_M0_0,
 +		.end	= IRQ_SYSMMU_TV_M0_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[28] = {
 +		.start	= EXYNOS4_PA_SYSMMU_MFC_L,
 +		.end	= EXYNOS4_PA_SYSMMU_MFC_L + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[29] = {
 +		.start	= IRQ_SYSMMU_MFC_M0_0,
 +		.end	= IRQ_SYSMMU_MFC_M0_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +	[30] = {
 +		.start	= EXYNOS4_PA_SYSMMU_MFC_R,
 +		.end	= EXYNOS4_PA_SYSMMU_MFC_R + SZ_64K - 1,
 +		.flags	= IORESOURCE_MEM,
 +	},
 +	[31] = {
 +		.start	= IRQ_SYSMMU_MFC_M1_0,
 +		.end	= IRQ_SYSMMU_MFC_M1_0,
 +		.flags	= IORESOURCE_IRQ,
 +	},
 +};
 +
 +struct platform_device exynos4_device_sysmmu = {
 +	.name		= "s5p-sysmmu",
 +	.id		= 32,
 +	.num_resources	= ARRAY_SIZE(exynos4_sysmmu_resource),
 +	.resource	= exynos4_sysmmu_resource,
 +};
 +EXPORT_SYMBOL(exynos4_device_sysmmu);
 +
 +static struct clk *sysmmu_clk[S5P_SYSMMU_TOTAL_IPNUM];
 +void sysmmu_clk_init(struct device *dev, sysmmu_ips ips)
 +{
 +	sysmmu_clk[ips] = clk_get(dev, sysmmu_ips_name[ips]);
 +	if (IS_ERR(sysmmu_clk[ips]))
 +		sysmmu_clk[ips] = NULL;
 +	else
 +		clk_put(sysmmu_clk[ips]);
 +}
 +
 +void sysmmu_clk_enable(sysmmu_ips ips)
 +{
 +	if (sysmmu_clk[ips])
 +		clk_enable(sysmmu_clk[ips]);
 +}
 +
 +void sysmmu_clk_disable(sysmmu_ips ips)
 +{
 +	if (sysmmu_clk[ips])
 +		clk_disable(sysmmu_clk[ips]);
 +}
diff --cc arch/arm/mach-omap2/voltage.c
index 64070ac1e761,e964cfd3a3d0..1f8fdf736e63
--- a/arch/arm/mach-omap2/voltage.c
+++ b/arch/arm/mach-omap2/voltage.c
@@@ -21,10 -21,11 +21,11 @@@
  
  #include <linux/delay.h>
  #include <linux/io.h>
 -#include <linux/clk.h>
  #include <linux/err.h>
+ #include <linux/export.h>
  #include <linux/debugfs.h>
  #include <linux/slab.h>
 +#include <linux/clk.h>
  
  #include <plat/common.h>
  
diff --cc arch/arm/plat-samsung/dev-backlight.c
index 2adbeaed4c04,a976c023b286..e657305644cc
--- a/arch/arm/plat-samsung/dev-backlight.c
+++ b/arch/arm/plat-samsung/dev-backlight.c
@@@ -12,9 -12,9 +12,10 @@@
  
  #include <linux/gpio.h>
  #include <linux/platform_device.h>
+ #include <linux/slab.h>
  #include <linux/io.h>
  #include <linux/pwm_backlight.h>
 +#include <linux/slab.h>
  
  #include <plat/devs.h>
  #include <plat/gpio-cfg.h>
diff --cc arch/microblaze/kernel/dma.c
index dc6416d265d6,b159b8a847d6..65a4af4cbbbe
--- a/arch/microblaze/kernel/dma.c
+++ b/arch/microblaze/kernel/dma.c
@@@ -10,7 -10,9 +10,8 @@@
  #include <linux/dma-mapping.h>
  #include <linux/gfp.h>
  #include <linux/dma-debug.h>
+ #include <linux/export.h>
  #include <asm/bug.h>
 -#include <asm/cacheflush.h>
  
  /*
   * Generic direct DMA implementation
diff --cc arch/sh/kernel/topology.c
index ecc2d3d0f54a,ab37955b453a..4649a6ff0cfe
--- a/arch/sh/kernel/topology.c
+++ b/arch/sh/kernel/topology.c
@@@ -11,9 -11,9 +11,10 @@@
  #include <linux/cpumask.h>
  #include <linux/init.h>
  #include <linux/percpu.h>
 +#include <linux/topology.h>
  #include <linux/node.h>
  #include <linux/nodemask.h>
+ #include <linux/export.h>
  
  static DEFINE_PER_CPU(struct cpu, cpu_devices);
  
diff --cc arch/x86/crypto/aes_glue.c
index b0b6950cc8c8,bdce3eeeaa37..8efcf42a9d7e
--- a/arch/x86/crypto/aes_glue.c
+++ b/arch/x86/crypto/aes_glue.c
@@@ -3,8 -3,8 +3,9 @@@
   *
   */
  
+ #include <linux/module.h>
  #include <crypto/aes.h>
 +#include <asm/aes.h>
  
  asmlinkage void aes_enc_blk(struct crypto_aes_ctx *ctx, u8 *out, const u8 *in);
  asmlinkage void aes_dec_blk(struct crypto_aes_ctx *ctx, u8 *out, const u8 *in);
diff --cc arch/x86/kernel/cpu/mcheck/mce.c
index 864830e1dd65,537c89e00095..362056aefeb4
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce.c
@@@ -36,7 -36,9 +36,8 @@@
  #include <linux/fs.h>
  #include <linux/mm.h>
  #include <linux/debugfs.h>
 -#include <linux/edac_mce.h>
  #include <linux/irq_work.h>
+ #include <linux/export.h>
  
  #include <asm/processor.h>
  #include <asm/mce.h>
diff --cc drivers/infiniband/core/verbs.c
index 42517500b223,a8923ffc6459..602b1bd723a9
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@@ -38,8 -38,8 +38,9 @@@
  
  #include <linux/errno.h>
  #include <linux/err.h>
+ #include <linux/export.h>
  #include <linux/string.h>
 +#include <linux/slab.h>
  
  #include <rdma/ib_verbs.h>
  #include <rdma/ib_cache.h>
diff --cc drivers/media/common/saa7146_core.c
index f5d53a202344,31e53b6a881a..d6b1cf66042d
--- a/drivers/media/common/saa7146_core.c
+++ b/drivers/media/common/saa7146_core.c
@@@ -18,9 -18,8 +18,10 @@@
      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
  
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
  #include <media/saa7146.h>
+ #include <linux/module.h>
  
  LIST_HEAD(saa7146_devices);
  DEFINE_MUTEX(saa7146_devices_lock);
diff --cc drivers/media/common/saa7146_fops.c
index a92546144eaa,e4547afcfa88..71f8e018e564
--- a/drivers/media/common/saa7146_fops.c
+++ b/drivers/media/common/saa7146_fops.c
@@@ -1,6 -1,5 +1,7 @@@
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
  #include <media/saa7146_vv.h>
+ #include <linux/module.h>
  
  /****************************************************************************/
  /* resource management functions, shamelessly stolen from saa7134 driver */
diff --cc drivers/media/common/saa7146_hlp.c
index 79ad73accb27,c9c6e9a6c31d..bc1f545c95cb
--- a/drivers/media/common/saa7146_hlp.c
+++ b/drivers/media/common/saa7146_hlp.c
@@@ -1,6 -1,5 +1,7 @@@
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
  #include <linux/kernel.h>
+ #include <linux/export.h>
  #include <media/saa7146_vv.h>
  
  static void calculate_output_format_register(struct saa7146_dev* saa, u32 palette, u32* clip_format)
diff --cc drivers/media/common/saa7146_video.c
index 384b358d3037,3a00253fe1ee..ce30533fd972
--- a/drivers/media/common/saa7146_video.c
+++ b/drivers/media/common/saa7146_video.c
@@@ -1,7 -1,6 +1,8 @@@
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
  #include <media/saa7146_vv.h>
  #include <media/v4l2-chip-ident.h>
+ #include <linux/module.h>
  
  static int max_memory = 32;
  
diff --cc drivers/media/dvb/frontends/dibx000_common.c
index 774d507b66cc,977211fec137..43be7238311e
--- a/drivers/media/dvb/frontends/dibx000_common.c
+++ b/drivers/media/dvb/frontends/dibx000_common.c
@@@ -1,5 -1,5 +1,6 @@@
  #include <linux/i2c.h>
 +#include <linux/mutex.h>
+ #include <linux/module.h>
  
  #include "dibx000_common.h"
  
diff --cc drivers/media/video/adp1653.c
index 5914390211ff,c2594948ca3f..12eedf4d515a
--- a/drivers/media/video/adp1653.c
+++ b/drivers/media/video/adp1653.c
@@@ -31,8 -31,8 +31,9 @@@
   */
  
  #include <linux/delay.h>
+ #include <linux/module.h>
  #include <linux/i2c.h>
 +#include <linux/module.h>
  #include <linux/slab.h>
  #include <linux/version.h>
  #include <media/adp1653.h>
diff --cc drivers/media/video/imx074.c
index 8775e262bb6e,3319b40c87a4..eec75bb57203
--- a/drivers/media/video/imx074.c
+++ b/drivers/media/video/imx074.c
@@@ -12,11 -12,12 +12,12 @@@
  
  #include <linux/delay.h>
  #include <linux/i2c.h>
 +#include <linux/v4l2-mediabus.h>
  #include <linux/slab.h>
  #include <linux/videodev2.h>
+ #include <linux/module.h>
  
  #include <media/soc_camera.h>
 -#include <media/soc_mediabus.h>
  #include <media/v4l2-subdev.h>
  #include <media/v4l2-chip-ident.h>
  
diff --cc drivers/media/video/mt9m001.c
index 63ae5c61c9bf,6866a9ef3f60..e2b1029b16cd
--- a/drivers/media/video/mt9m001.c
+++ b/drivers/media/video/mt9m001.c
@@@ -12,12 -12,11 +12,13 @@@
  #include <linux/slab.h>
  #include <linux/i2c.h>
  #include <linux/log2.h>
+ #include <linux/module.h>
  
 +#include <media/soc_camera.h>
 +#include <media/soc_mediabus.h>
  #include <media/v4l2-subdev.h>
  #include <media/v4l2-chip-ident.h>
 -#include <media/soc_camera.h>
 +#include <media/v4l2-ctrls.h>
  
  /*
   * mt9m001 i2c address 0x5d
diff --cc drivers/media/video/mt9m111.c
index f023cc092c2b,66e3c3c2e606..cf2c0fb95f2f
--- a/drivers/media/video/mt9m111.c
+++ b/drivers/media/video/mt9m111.c
@@@ -13,12 -13,11 +13,13 @@@
  #include <linux/log2.h>
  #include <linux/gpio.h>
  #include <linux/delay.h>
 +#include <linux/v4l2-mediabus.h>
+ #include <linux/module.h>
  
 +#include <media/soc_camera.h>
  #include <media/v4l2-common.h>
 +#include <media/v4l2-ctrls.h>
  #include <media/v4l2-chip-ident.h>
 -#include <media/soc_camera.h>
  
  /*
   * MT9M111, MT9M112 and MT9M131:
diff --cc drivers/media/video/mt9t031.c
index 7ee84cc578b9,e6e0238eca16..0e78477452ff
--- a/drivers/media/video/mt9t031.c
+++ b/drivers/media/video/mt9t031.c
@@@ -13,8 -13,8 +13,9 @@@
  #include <linux/log2.h>
  #include <linux/pm.h>
  #include <linux/slab.h>
 +#include <linux/v4l2-mediabus.h>
  #include <linux/videodev2.h>
+ #include <linux/module.h>
  
  #include <media/soc_camera.h>
  #include <media/v4l2-chip-ident.h>
diff --cc drivers/media/video/mt9v022.c
index b6a29f7de82c,c74d6604598e..690ee0d42eeb
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@@ -13,12 -13,11 +13,13 @@@
  #include <linux/i2c.h>
  #include <linux/delay.h>
  #include <linux/log2.h>
+ #include <linux/module.h>
  
 +#include <media/soc_camera.h>
 +#include <media/soc_mediabus.h>
  #include <media/v4l2-subdev.h>
  #include <media/v4l2-chip-ident.h>
 -#include <media/soc_camera.h>
 +#include <media/v4l2-ctrls.h>
  
  /*
   * mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c
diff --cc drivers/media/video/ov6650.c
index d5b057207a7b,2e1680631f0f..9f2d26b1d4cb
--- a/drivers/media/video/ov6650.c
+++ b/drivers/media/video/ov6650.c
@@@ -28,7 -28,7 +28,8 @@@
  #include <linux/delay.h>
  #include <linux/i2c.h>
  #include <linux/slab.h>
 +#include <linux/v4l2-mediabus.h>
+ #include <linux/module.h>
  
  #include <media/soc_camera.h>
  #include <media/v4l2-chip-ident.h>
diff --cc drivers/media/video/rj54n1cb0c.c
index 6afc61689549,985965f744ff..9937386a3bae
--- a/drivers/media/video/rj54n1cb0c.c
+++ b/drivers/media/video/rj54n1cb0c.c
@@@ -11,8 -11,8 +11,9 @@@
  #include <linux/delay.h>
  #include <linux/i2c.h>
  #include <linux/slab.h>
 +#include <linux/v4l2-mediabus.h>
  #include <linux/videodev2.h>
+ #include <linux/module.h>
  
  #include <media/rj54n1cb0c.h>
  #include <media/soc_camera.h>
diff --cc drivers/media/video/v4l2-device.c
index 9fc0ae8a526a,c742b1f5e73e..0edd618b9ddf
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@@ -20,8 -20,8 +20,9 @@@
  
  #include <linux/types.h>
  #include <linux/ioctl.h>
+ #include <linux/module.h>
  #include <linux/i2c.h>
 +#include <linux/slab.h>
  #if defined(CONFIG_SPI)
  #include <linux/spi/spi.h>
  #endif
diff --cc drivers/mfd/max8997.c
index dc58750bb71b,50ad93bb49dd..5be53ae9b61c
--- a/drivers/mfd/max8997.c
+++ b/drivers/mfd/max8997.c
@@@ -23,8 -23,8 +23,9 @@@
  
  #include <linux/slab.h>
  #include <linux/i2c.h>
 +#include <linux/interrupt.h>
  #include <linux/pm_runtime.h>
+ #include <linux/module.h>
  #include <linux/mutex.h>
  #include <linux/mfd/core.h>
  #include <linux/mfd/max8997.h>
diff --cc drivers/s390/char/vmur.c
index d291a54acfad,b95cbdccc11a..85f4a9a5d12e
--- a/drivers/s390/char/vmur.c
+++ b/drivers/s390/char/vmur.c
@@@ -11,8 -11,10 +11,9 @@@
  #define KMSG_COMPONENT "vmur"
  #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  
 -#include <linux/kernel_stat.h>
  #include <linux/cdev.h>
  #include <linux/slab.h>
+ #include <linux/module.h>
  
  #include <asm/uaccess.h>
  #include <asm/cio.h>
diff --cc drivers/staging/media/solo6x10/g723.c
index 59274bfca95b,000000000000..2cd0de28a633
mode 100644,000000..100644
--- a/drivers/staging/media/solo6x10/g723.c
+++ b/drivers/staging/media/solo6x10/g723.c
@@@ -1,399 -1,0 +1,400 @@@
 +/*
 + * Copyright (C) 2010 Bluecherry, LLC www.bluecherrydvr.com
 + * Copyright (C) 2010 Ben Collins <bcollins@bluecherry.net>
 + *
 + * 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.
 + */
 +
 +#include <linux/kernel.h>
 +#include <linux/mempool.h>
 +#include <linux/poll.h>
 +#include <linux/kthread.h>
 +#include <linux/slab.h>
 +#include <linux/freezer.h>
++#include <linux/export.h>
 +#include <sound/core.h>
 +#include <sound/initval.h>
 +#include <sound/pcm.h>
 +#include <sound/control.h>
 +#include "solo6x10.h"
 +#include "tw28.h"
 +
 +#define G723_INTR_ORDER		0
 +#define G723_FDMA_PAGES		32
 +#define G723_PERIOD_BYTES	48
 +#define G723_PERIOD_BLOCK	1024
 +#define G723_FRAMES_PER_PAGE	48
 +
 +/* Sets up channels 16-19 for decoding and 0-15 for encoding */
 +#define OUTMODE_MASK		0x300
 +
 +#define SAMPLERATE		8000
 +#define BITRATE			25
 +
 +/* The solo writes to 1k byte pages, 32 pages, in the dma. Each 1k page
 + * is broken down to 20 * 48 byte regions (one for each channel possible)
 + * with the rest of the page being dummy data. */
 +#define MAX_BUFFER		(G723_PERIOD_BYTES * PERIODS_MAX)
 +#define IRQ_PAGES		4 /* 0 - 4 */
 +#define PERIODS_MIN		(1 << IRQ_PAGES)
 +#define PERIODS_MAX		G723_FDMA_PAGES
 +
 +struct solo_snd_pcm {
 +	int		on;
 +	spinlock_t	lock;
 +	struct solo_dev	*solo_dev;
 +	unsigned char	g723_buf[G723_PERIOD_BYTES];
 +};
 +
 +static void solo_g723_config(struct solo_dev *solo_dev)
 +{
 +	int clk_div;
 +
 +	clk_div = SOLO_CLOCK_MHZ / (SAMPLERATE * (BITRATE * 2) * 2);
 +
 +	solo_reg_write(solo_dev, SOLO_AUDIO_SAMPLE,
 +		       SOLO_AUDIO_BITRATE(BITRATE) |
 +		       SOLO_AUDIO_CLK_DIV(clk_div));
 +
 +	solo_reg_write(solo_dev, SOLO_AUDIO_FDMA_INTR,
 +		      SOLO_AUDIO_FDMA_INTERVAL(IRQ_PAGES) |
 +		      SOLO_AUDIO_INTR_ORDER(G723_INTR_ORDER) |
 +		      SOLO_AUDIO_FDMA_BASE(SOLO_G723_EXT_ADDR(solo_dev) >> 16));
 +
 +	solo_reg_write(solo_dev, SOLO_AUDIO_CONTROL,
 +		       SOLO_AUDIO_ENABLE | SOLO_AUDIO_I2S_MODE |
 +		       SOLO_AUDIO_I2S_MULTI(3) | SOLO_AUDIO_MODE(OUTMODE_MASK));
 +}
 +
 +void solo_g723_isr(struct solo_dev *solo_dev)
 +{
 +	struct snd_pcm_str *pstr =
 +		&solo_dev->snd_pcm->streams[SNDRV_PCM_STREAM_CAPTURE];
 +	struct snd_pcm_substream *ss;
 +	struct solo_snd_pcm *solo_pcm;
 +
 +	solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_G723);
 +
 +	for (ss = pstr->substream; ss != NULL; ss = ss->next) {
 +		if (snd_pcm_substream_chip(ss) == NULL)
 +			continue;
 +
 +		/* This means open() hasn't been called on this one */
 +		if (snd_pcm_substream_chip(ss) == solo_dev)
 +			continue;
 +
 +		/* Haven't triggered a start yet */
 +		solo_pcm = snd_pcm_substream_chip(ss);
 +		if (!solo_pcm->on)
 +			continue;
 +
 +		snd_pcm_period_elapsed(ss);
 +	}
 +}
 +
 +static int snd_solo_hw_params(struct snd_pcm_substream *ss,
 +			      struct snd_pcm_hw_params *hw_params)
 +{
 +	return snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw_params));
 +}
 +
 +static int snd_solo_hw_free(struct snd_pcm_substream *ss)
 +{
 +	return snd_pcm_lib_free_pages(ss);
 +}
 +
 +static struct snd_pcm_hardware snd_solo_pcm_hw = {
 +	.info			= (SNDRV_PCM_INFO_MMAP |
 +				   SNDRV_PCM_INFO_INTERLEAVED |
 +				   SNDRV_PCM_INFO_BLOCK_TRANSFER |
 +				   SNDRV_PCM_INFO_MMAP_VALID),
 +	.formats		= SNDRV_PCM_FMTBIT_U8,
 +	.rates			= SNDRV_PCM_RATE_8000,
 +	.rate_min		= 8000,
 +	.rate_max		= 8000,
 +	.channels_min		= 1,
 +	.channels_max		= 1,
 +	.buffer_bytes_max	= MAX_BUFFER,
 +	.period_bytes_min	= G723_PERIOD_BYTES,
 +	.period_bytes_max	= G723_PERIOD_BYTES,
 +	.periods_min		= PERIODS_MIN,
 +	.periods_max		= PERIODS_MAX,
 +};
 +
 +static int snd_solo_pcm_open(struct snd_pcm_substream *ss)
 +{
 +	struct solo_dev *solo_dev = snd_pcm_substream_chip(ss);
 +	struct solo_snd_pcm *solo_pcm;
 +
 +	solo_pcm = kzalloc(sizeof(*solo_pcm), GFP_KERNEL);
 +	if (solo_pcm == NULL)
 +		return -ENOMEM;
 +
 +	spin_lock_init(&solo_pcm->lock);
 +	solo_pcm->solo_dev = solo_dev;
 +	ss->runtime->hw = snd_solo_pcm_hw;
 +
 +	snd_pcm_substream_chip(ss) = solo_pcm;
 +
 +	return 0;
 +}
 +
 +static int snd_solo_pcm_close(struct snd_pcm_substream *ss)
 +{
 +	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
 +
 +	snd_pcm_substream_chip(ss) = solo_pcm->solo_dev;
 +	kfree(solo_pcm);
 +
 +	return 0;
 +}
 +
 +static int snd_solo_pcm_trigger(struct snd_pcm_substream *ss, int cmd)
 +{
 +	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
 +	struct solo_dev *solo_dev = solo_pcm->solo_dev;
 +	int ret = 0;
 +
 +	spin_lock(&solo_pcm->lock);
 +
 +	switch (cmd) {
 +	case SNDRV_PCM_TRIGGER_START:
 +		if (solo_pcm->on == 0) {
 +			/* If this is the first user, switch on interrupts */
 +			if (atomic_inc_return(&solo_dev->snd_users) == 1)
 +				solo_irq_on(solo_dev, SOLO_IRQ_G723);
 +			solo_pcm->on = 1;
 +		}
 +		break;
 +	case SNDRV_PCM_TRIGGER_STOP:
 +		if (solo_pcm->on) {
 +			/* If this was our last user, switch them off */
 +			if (atomic_dec_return(&solo_dev->snd_users) == 0)
 +				solo_irq_off(solo_dev, SOLO_IRQ_G723);
 +			solo_pcm->on = 0;
 +		}
 +		break;
 +	default:
 +		ret = -EINVAL;
 +	}
 +
 +	spin_unlock(&solo_pcm->lock);
 +
 +	return ret;
 +}
 +
 +static int snd_solo_pcm_prepare(struct snd_pcm_substream *ss)
 +{
 +	return 0;
 +}
 +
 +static snd_pcm_uframes_t snd_solo_pcm_pointer(struct snd_pcm_substream *ss)
 +{
 +	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
 +	struct solo_dev *solo_dev = solo_pcm->solo_dev;
 +	snd_pcm_uframes_t idx = solo_reg_read(solo_dev, SOLO_AUDIO_STA) & 0x1f;
 +
 +	return idx * G723_FRAMES_PER_PAGE;
 +}
 +
 +static int snd_solo_pcm_copy(struct snd_pcm_substream *ss, int channel,
 +			     snd_pcm_uframes_t pos, void __user *dst,
 +			     snd_pcm_uframes_t count)
 +{
 +	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
 +	struct solo_dev *solo_dev = solo_pcm->solo_dev;
 +	int err, i;
 +
 +	for (i = 0; i < (count / G723_FRAMES_PER_PAGE); i++) {
 +		int page = (pos / G723_FRAMES_PER_PAGE) + i;
 +
 +		err = solo_p2m_dma(solo_dev, SOLO_P2M_DMA_ID_G723E, 0,
 +				   solo_pcm->g723_buf,
 +				   SOLO_G723_EXT_ADDR(solo_dev) +
 +				   (page * G723_PERIOD_BLOCK) +
 +				   (ss->number * G723_PERIOD_BYTES),
 +				   G723_PERIOD_BYTES);
 +		if (err)
 +			return err;
 +
 +		err = copy_to_user(dst + (i * G723_PERIOD_BYTES),
 +				   solo_pcm->g723_buf, G723_PERIOD_BYTES);
 +
 +		if (err)
 +			return -EFAULT;
 +	}
 +
 +	return 0;
 +}
 +
 +static struct snd_pcm_ops snd_solo_pcm_ops = {
 +	.open = snd_solo_pcm_open,
 +	.close = snd_solo_pcm_close,
 +	.ioctl = snd_pcm_lib_ioctl,
 +	.hw_params = snd_solo_hw_params,
 +	.hw_free = snd_solo_hw_free,
 +	.prepare = snd_solo_pcm_prepare,
 +	.trigger = snd_solo_pcm_trigger,
 +	.pointer = snd_solo_pcm_pointer,
 +	.copy = snd_solo_pcm_copy,
 +};
 +
 +static int snd_solo_capture_volume_info(struct snd_kcontrol *kcontrol,
 +					struct snd_ctl_elem_info *info)
 +{
 +	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 +	info->count = 1;
 +	info->value.integer.min = 0;
 +	info->value.integer.max = 15;
 +	info->value.integer.step = 1;
 +
 +	return 0;
 +}
 +
 +static int snd_solo_capture_volume_get(struct snd_kcontrol *kcontrol,
 +				       struct snd_ctl_elem_value *value)
 +{
 +	struct solo_dev *solo_dev = snd_kcontrol_chip(kcontrol);
 +	u8 ch = value->id.numid - 1;
 +
 +	value->value.integer.value[0] = tw28_get_audio_gain(solo_dev, ch);
 +
 +	return 0;
 +}
 +
 +static int snd_solo_capture_volume_put(struct snd_kcontrol *kcontrol,
 +				       struct snd_ctl_elem_value *value)
 +{
 +	struct solo_dev *solo_dev = snd_kcontrol_chip(kcontrol);
 +	u8 ch = value->id.numid - 1;
 +	u8 old_val;
 +
 +	old_val = tw28_get_audio_gain(solo_dev, ch);
 +	if (old_val == value->value.integer.value[0])
 +		return 0;
 +
 +	tw28_set_audio_gain(solo_dev, ch, value->value.integer.value[0]);
 +
 +	return 1;
 +}
 +
 +static struct snd_kcontrol_new snd_solo_capture_volume = {
 +	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 +	.name = "Capture Volume",
 +	.info = snd_solo_capture_volume_info,
 +	.get = snd_solo_capture_volume_get,
 +	.put = snd_solo_capture_volume_put,
 +};
 +
 +static int solo_snd_pcm_init(struct solo_dev *solo_dev)
 +{
 +	struct snd_card *card = solo_dev->snd_card;
 +	struct snd_pcm *pcm;
 +	struct snd_pcm_substream *ss;
 +	int ret;
 +	int i;
 +
 +	ret = snd_pcm_new(card, card->driver, 0, 0, solo_dev->nr_chans,
 +			  &pcm);
 +	if (ret < 0)
 +		return ret;
 +
 +	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 +			&snd_solo_pcm_ops);
 +
 +	snd_pcm_chip(pcm) = solo_dev;
 +	pcm->info_flags = 0;
 +	strcpy(pcm->name, card->shortname);
 +
 +	for (i = 0, ss = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
 +	     ss; ss = ss->next, i++)
 +		sprintf(ss->name, "Camera #%d Audio", i);
 +
 +	ret = snd_pcm_lib_preallocate_pages_for_all(pcm,
 +					SNDRV_DMA_TYPE_CONTINUOUS,
 +					snd_dma_continuous_data(GFP_KERNEL),
 +					MAX_BUFFER, MAX_BUFFER);
 +	if (ret < 0)
 +		return ret;
 +
 +	solo_dev->snd_pcm = pcm;
 +
 +	return 0;
 +}
 +
 +int solo_g723_init(struct solo_dev *solo_dev)
 +{
 +	static struct snd_device_ops ops = { NULL };
 +	struct snd_card *card;
 +	struct snd_kcontrol_new kctl;
 +	char name[32];
 +	int ret;
 +
 +	atomic_set(&solo_dev->snd_users, 0);
 +
 +	/* Allows for easier mapping between video and audio */
 +	sprintf(name, "Softlogic%d", solo_dev->vfd->num);
 +
 +	ret = snd_card_create(SNDRV_DEFAULT_IDX1, name, THIS_MODULE, 0,
 +			      &solo_dev->snd_card);
 +	if (ret < 0)
 +		return ret;
 +
 +	card = solo_dev->snd_card;
 +
 +	strcpy(card->driver, SOLO6X10_NAME);
 +	strcpy(card->shortname, "SOLO-6x10 Audio");
 +	sprintf(card->longname, "%s on %s IRQ %d", card->shortname,
 +		pci_name(solo_dev->pdev), solo_dev->pdev->irq);
 +	snd_card_set_dev(card, &solo_dev->pdev->dev);
 +
 +	ret = snd_device_new(card, SNDRV_DEV_LOWLEVEL, solo_dev, &ops);
 +	if (ret < 0)
 +		goto snd_error;
 +
 +	/* Mixer controls */
 +	strcpy(card->mixername, "SOLO-6x10");
 +	kctl = snd_solo_capture_volume;
 +	kctl.count = solo_dev->nr_chans;
 +	ret = snd_ctl_add(card, snd_ctl_new1(&kctl, solo_dev));
 +	if (ret < 0)
 +		return ret;
 +
 +	ret = solo_snd_pcm_init(solo_dev);
 +	if (ret < 0)
 +		goto snd_error;
 +
 +	ret = snd_card_register(card);
 +	if (ret < 0)
 +		goto snd_error;
 +
 +	solo_g723_config(solo_dev);
 +
 +	dev_info(&solo_dev->pdev->dev, "Alsa sound card as %s\n", name);
 +
 +	return 0;
 +
 +snd_error:
 +	snd_card_free(card);
 +	return ret;
 +}
 +
 +void solo_g723_exit(struct solo_dev *solo_dev)
 +{
 +	solo_reg_write(solo_dev, SOLO_AUDIO_CONTROL, 0);
 +	solo_irq_off(solo_dev, SOLO_IRQ_G723);
 +
 +	snd_card_free(solo_dev->snd_card);
 +}
diff --cc include/linux/dmaengine.h
index ace51af4369f,1ceff5ae9d31..75f53f874b24
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@@ -24,8 -24,11 +24,10 @@@
  #include <linux/device.h>
  #include <linux/uio.h>
  #include <linux/dma-direction.h>
 +#include <linux/scatterlist.h>
+ #include <linux/bitmap.h>
+ #include <asm/page.h>
  
 -struct scatterlist;
 -
  /**
   * typedef dma_cookie_t - an opaque DMA cookie
   *
diff --cc net/8021q/vlan_core.c
index 163397f1fd5a,1f64cc9da1b0..f5ffc02729d6
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@@ -2,9 -2,10 +2,10 @@@
  #include <linux/netdevice.h>
  #include <linux/if_vlan.h>
  #include <linux/netpoll.h>
+ #include <linux/export.h>
  #include "vlan.h"
  
 -bool vlan_do_receive(struct sk_buff **skbp)
 +bool vlan_do_receive(struct sk_buff **skbp, bool last_handler)
  {
  	struct sk_buff *skb = *skbp;
  	u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK;