kernel: remove linux 3.13 support

Signed-off-by: Felix Fietkau <nbd@openwrt.org> SVN-Revision: 44804
2015-03-16 05:52:02 +00:00 · 2015-03-16 05:52:02 +00:00 · 7f7e0a21b8
commit 7f7e0a21b8
parent f26bb532cf
170 changed files with 0 additions and 35633 deletions
--- a/target/linux/generic/config-3.13
+++ b/target/linux/generic/config-3.13
--- a/target/linux/generic/patches-3.13/000-keep_initrafs_the_default.patch
+++ b/target/linux/generic/patches-3.13/000-keep_initrafs_the_default.patch
@ -1,25 +0,0 @@
 Upstream changed the default rootfs to tmpfs when none has been passed
 to the kernel - this doesn't fit our purposes, so change it back.
 Signed-off-by: Imre Kaloz <kaloz@openwrt.org>
 --- a/init/do_mounts.c
 +++ b/init/do_mounts.c
@@ -622,6 +622,7 @@ int __init init_rootfs(void)
 	if (err)
 		return err;
 +#if 0
 	if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
 		(!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
 		err = shmem_init();
@@ -629,6 +630,9 @@ int __init init_rootfs(void)
 	} else {
 		err = init_ramfs_fs();
 	}
 +#else
 +	err = init_ramfs_fs();
 +#endif
 	if (err)
 		unregister_filesystem(&rootfs_fs_type);
--- a/target/linux/generic/patches-3.13/020-ssb_update.patch
+++ b/target/linux/generic/patches-3.13/020-ssb_update.patch
@ -1,686 +0,0 @@
 --- a/drivers/ssb/Kconfig
 +++ b/drivers/ssb/Kconfig
@@ -168,6 +168,7 @@ config SSB_DRIVER_GIGE
 config SSB_DRIVER_GPIO
 	bool "SSB GPIO driver"
 	depends on SSB && GPIOLIB
 +	select IRQ_DOMAIN if SSB_EMBEDDED
 	help
 	  Driver to provide access to the GPIO pins on the bus.
 --- a/drivers/ssb/driver_chipcommon_sflash.c
 +++ b/drivers/ssb/driver_chipcommon_sflash.c
@@ -37,7 +37,7 @@ static const struct ssb_sflash_tbl_e ssb
 	{ "M25P32", 0x15, 0x10000, 64, },
 	{ "M25P64", 0x16, 0x10000, 128, },
 	{ "M25FL128", 0x17, 0x10000, 256, },
 -	{ 0 },
 +	{ NULL },
 };
 static const struct ssb_sflash_tbl_e ssb_sflash_sst_tbl[] = {
@@ -55,7 +55,7 @@ static const struct ssb_sflash_tbl_e ssb
 	{ "SST25VF016", 0x41, 0x1000, 512, },
 	{ "SST25VF032", 0x4a, 0x1000, 1024, },
 	{ "SST25VF064", 0x4b, 0x1000, 2048, },
 -	{ 0 },
 +	{ NULL },
 };
 static const struct ssb_sflash_tbl_e ssb_sflash_at_tbl[] = {
@@ -66,7 +66,7 @@ static const struct ssb_sflash_tbl_e ssb
 	{ "AT45DB161", 0x2c, 512, 4096, },
 	{ "AT45DB321", 0x34, 512, 8192, },
 	{ "AT45DB642", 0x3c, 1024, 8192, },
 -	{ 0 },
 +	{ NULL },
 };
 static void ssb_sflash_cmd(struct ssb_chipcommon *cc, u32 opcode)
 --- a/drivers/ssb/driver_gpio.c
 +++ b/drivers/ssb/driver_gpio.c
@@ -9,16 +9,40 @@
  */
 #include <linux/gpio.h>
 +#include <linux/irq.h>
 +#include <linux/interrupt.h>
 +#include <linux/irqdomain.h>
 #include <linux/export.h>
 #include <linux/ssb/ssb.h>
 #include "ssb_private.h"
 +
 +/**************************************************
 + * Shared
 + **************************************************/
 +
 static struct ssb_bus *ssb_gpio_get_bus(struct gpio_chip *chip)
 {
 	return container_of(chip, struct ssb_bus, gpio);
 }
 +#if IS_ENABLED(CONFIG_SSB_EMBEDDED)
 +static int ssb_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
 +{
 +	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 +
 +	if (bus->bustype == SSB_BUSTYPE_SSB)
 +		return irq_find_mapping(bus->irq_domain, gpio);
 +	else
 +		return -EINVAL;
 +}
 +#endif
 +
 +/**************************************************
 + * ChipCommon
 + **************************************************/
 +
 static int ssb_gpio_chipco_get_value(struct gpio_chip *chip, unsigned gpio)
 {
 	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
@@ -74,19 +98,129 @@ static void ssb_gpio_chipco_free(struct
 	ssb_chipco_gpio_pullup(&bus->chipco, 1 << gpio, 0);
 }
 -static int ssb_gpio_chipco_to_irq(struct gpio_chip *chip, unsigned gpio)
 +#if IS_ENABLED(CONFIG_SSB_EMBEDDED)
 +static void ssb_gpio_irq_chipco_mask(struct irq_data *d)
 {
 -	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 +	struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 -	if (bus->bustype == SSB_BUSTYPE_SSB)
 -		return ssb_mips_irq(bus->chipco.dev) + 2;
 -	else
 -		return -EINVAL;
 +	ssb_chipco_gpio_intmask(&bus->chipco, BIT(gpio), 0);
 +}
 +
 +static void ssb_gpio_irq_chipco_unmask(struct irq_data *d)
 +{
 +	struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 +	u32 val = ssb_chipco_gpio_in(&bus->chipco, BIT(gpio));
 +
 +	ssb_chipco_gpio_polarity(&bus->chipco, BIT(gpio), val);
 +	ssb_chipco_gpio_intmask(&bus->chipco, BIT(gpio), BIT(gpio));
 +}
 +
 +static struct irq_chip ssb_gpio_irq_chipco_chip = {
 +	.name		= "SSB-GPIO-CC",
 +	.irq_mask	= ssb_gpio_irq_chipco_mask,
 +	.irq_unmask	= ssb_gpio_irq_chipco_unmask,
 +};
 +
 +static irqreturn_t ssb_gpio_irq_chipco_handler(int irq, void *dev_id)
 +{
 +	struct ssb_bus *bus = dev_id;
 +	struct ssb_chipcommon *chipco = &bus->chipco;
 +	u32 val = chipco_read32(chipco, SSB_CHIPCO_GPIOIN);
 +	u32 mask = chipco_read32(chipco, SSB_CHIPCO_GPIOIRQ);
 +	u32 pol = chipco_read32(chipco, SSB_CHIPCO_GPIOPOL);
 +	unsigned long irqs = (val ^ pol) & mask;
 +	int gpio;
 +
 +	if (!irqs)
 +		return IRQ_NONE;
 +
 +	for_each_set_bit(gpio, &irqs, bus->gpio.ngpio)
 +		generic_handle_irq(ssb_gpio_to_irq(&bus->gpio, gpio));
 +	ssb_chipco_gpio_polarity(chipco, irqs, val & irqs);
 +
 +	return IRQ_HANDLED;
 +}
 +
 +static int ssb_gpio_irq_chipco_domain_init(struct ssb_bus *bus)
 +{
 +	struct ssb_chipcommon *chipco = &bus->chipco;
 +	struct gpio_chip *chip = &bus->gpio;
 +	int gpio, hwirq, err;
 +
 +	if (bus->bustype != SSB_BUSTYPE_SSB)
 +		return 0;
 +
 +	bus->irq_domain = irq_domain_add_linear(NULL, chip->ngpio,
 +						&irq_domain_simple_ops, chipco);
 +	if (!bus->irq_domain) {
 +		err = -ENODEV;
 +		goto err_irq_domain;
 +	}
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_create_mapping(bus->irq_domain, gpio);
 +
 +		irq_set_chip_data(irq, bus);
 +		irq_set_chip_and_handler(irq, &ssb_gpio_irq_chipco_chip,
 +					 handle_simple_irq);
 +	}
 +
 +	hwirq = ssb_mips_irq(bus->chipco.dev) + 2;
 +	err = request_irq(hwirq, ssb_gpio_irq_chipco_handler, IRQF_SHARED,
 +			  "gpio", bus);
 +	if (err)
 +		goto err_req_irq;
 +
 +	ssb_chipco_gpio_intmask(&bus->chipco, ~0, 0);
 +	chipco_set32(chipco, SSB_CHIPCO_IRQMASK, SSB_CHIPCO_IRQ_GPIO);
 +
 +	return 0;
 +
 +err_req_irq:
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(bus->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(bus->irq_domain);
 +err_irq_domain:
 +	return err;
 +}
 +
 +static void ssb_gpio_irq_chipco_domain_exit(struct ssb_bus *bus)
 +{
 +	struct ssb_chipcommon *chipco = &bus->chipco;
 +	struct gpio_chip *chip = &bus->gpio;
 +	int gpio;
 +
 +	if (bus->bustype != SSB_BUSTYPE_SSB)
 +		return;
 +
 +	chipco_mask32(chipco, SSB_CHIPCO_IRQMASK, ~SSB_CHIPCO_IRQ_GPIO);
 +	free_irq(ssb_mips_irq(bus->chipco.dev) + 2, chipco);
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(bus->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(bus->irq_domain);
 +}
 +#else
 +static int ssb_gpio_irq_chipco_domain_init(struct ssb_bus *bus)
 +{
 +	return 0;
 +}
 +
 +static void ssb_gpio_irq_chipco_domain_exit(struct ssb_bus *bus)
 +{
 }
 +#endif
 static int ssb_gpio_chipco_init(struct ssb_bus *bus)
 {
 	struct gpio_chip *chip = &bus->gpio;
 +	int err;
 	chip->label		= "ssb_chipco_gpio";
 	chip->owner		= THIS_MODULE;
@@ -96,7 +230,9 @@ static int ssb_gpio_chipco_init(struct s
 	chip->set		= ssb_gpio_chipco_set_value;
 	chip->direction_input	= ssb_gpio_chipco_direction_input;
 	chip->direction_output	= ssb_gpio_chipco_direction_output;
 -	chip->to_irq		= ssb_gpio_chipco_to_irq;
 +#if IS_ENABLED(CONFIG_SSB_EMBEDDED)
 +	chip->to_irq		= ssb_gpio_to_irq;
 +#endif
 	chip->ngpio		= 16;
 	/* There is just one SoC in one device and its GPIO addresses should be
 	 * deterministic to address them more easily. The other buses could get
@@ -106,9 +242,23 @@ static int ssb_gpio_chipco_init(struct s
 	else
 		chip->base		= -1;
 -	return gpiochip_add(chip);
 +	err = ssb_gpio_irq_chipco_domain_init(bus);
 +	if (err)
 +		return err;
 +
 +	err = gpiochip_add(chip);
 +	if (err) {
 +		ssb_gpio_irq_chipco_domain_exit(bus);
 +		return err;
 +	}
 +
 +	return 0;
 }
 +/**************************************************
 + * EXTIF
 + **************************************************/
 +
 #ifdef CONFIG_SSB_DRIVER_EXTIF
 static int ssb_gpio_extif_get_value(struct gpio_chip *chip, unsigned gpio)
@@ -145,19 +295,127 @@ static int ssb_gpio_extif_direction_outp
 	return 0;
 }
 -static int ssb_gpio_extif_to_irq(struct gpio_chip *chip, unsigned gpio)
 +#if IS_ENABLED(CONFIG_SSB_EMBEDDED)
 +static void ssb_gpio_irq_extif_mask(struct irq_data *d)
 {
 -	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 +	struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 -	if (bus->bustype == SSB_BUSTYPE_SSB)
 -		return ssb_mips_irq(bus->extif.dev) + 2;
 -	else
 -		return -EINVAL;
 +	ssb_extif_gpio_intmask(&bus->extif, BIT(gpio), 0);
 +}
 +
 +static void ssb_gpio_irq_extif_unmask(struct irq_data *d)
 +{
 +	struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 +	u32 val = ssb_extif_gpio_in(&bus->extif, BIT(gpio));
 +
 +	ssb_extif_gpio_polarity(&bus->extif, BIT(gpio), val);
 +	ssb_extif_gpio_intmask(&bus->extif, BIT(gpio), BIT(gpio));
 +}
 +
 +static struct irq_chip ssb_gpio_irq_extif_chip = {
 +	.name		= "SSB-GPIO-EXTIF",
 +	.irq_mask	= ssb_gpio_irq_extif_mask,
 +	.irq_unmask	= ssb_gpio_irq_extif_unmask,
 +};
 +
 +static irqreturn_t ssb_gpio_irq_extif_handler(int irq, void *dev_id)
 +{
 +	struct ssb_bus *bus = dev_id;
 +	struct ssb_extif *extif = &bus->extif;
 +	u32 val = ssb_read32(extif->dev, SSB_EXTIF_GPIO_IN);
 +	u32 mask = ssb_read32(extif->dev, SSB_EXTIF_GPIO_INTMASK);
 +	u32 pol = ssb_read32(extif->dev, SSB_EXTIF_GPIO_INTPOL);
 +	unsigned long irqs = (val ^ pol) & mask;
 +	int gpio;
 +
 +	if (!irqs)
 +		return IRQ_NONE;
 +
 +	for_each_set_bit(gpio, &irqs, bus->gpio.ngpio)
 +		generic_handle_irq(ssb_gpio_to_irq(&bus->gpio, gpio));
 +	ssb_extif_gpio_polarity(extif, irqs, val & irqs);
 +
 +	return IRQ_HANDLED;
 +}
 +
 +static int ssb_gpio_irq_extif_domain_init(struct ssb_bus *bus)
 +{
 +	struct ssb_extif *extif = &bus->extif;
 +	struct gpio_chip *chip = &bus->gpio;
 +	int gpio, hwirq, err;
 +
 +	if (bus->bustype != SSB_BUSTYPE_SSB)
 +		return 0;
 +
 +	bus->irq_domain = irq_domain_add_linear(NULL, chip->ngpio,
 +						&irq_domain_simple_ops, extif);
 +	if (!bus->irq_domain) {
 +		err = -ENODEV;
 +		goto err_irq_domain;
 +	}
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_create_mapping(bus->irq_domain, gpio);
 +
 +		irq_set_chip_data(irq, bus);
 +		irq_set_chip_and_handler(irq, &ssb_gpio_irq_extif_chip,
 +					 handle_simple_irq);
 +	}
 +
 +	hwirq = ssb_mips_irq(bus->extif.dev) + 2;
 +	err = request_irq(hwirq, ssb_gpio_irq_extif_handler, IRQF_SHARED,
 +			  "gpio", bus);
 +	if (err)
 +		goto err_req_irq;
 +
 +	ssb_extif_gpio_intmask(&bus->extif, ~0, 0);
 +
 +	return 0;
 +
 +err_req_irq:
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(bus->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(bus->irq_domain);
 +err_irq_domain:
 +	return err;
 }
 +static void ssb_gpio_irq_extif_domain_exit(struct ssb_bus *bus)
 +{
 +	struct ssb_extif *extif = &bus->extif;
 +	struct gpio_chip *chip = &bus->gpio;
 +	int gpio;
 +
 +	if (bus->bustype != SSB_BUSTYPE_SSB)
 +		return;
 +
 +	free_irq(ssb_mips_irq(bus->extif.dev) + 2, extif);
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(bus->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(bus->irq_domain);
 +}
 +#else
 +static int ssb_gpio_irq_extif_domain_init(struct ssb_bus *bus)
 +{
 +	return 0;
 +}
 +
 +static void ssb_gpio_irq_extif_domain_exit(struct ssb_bus *bus)
 +{
 +}
 +#endif
 +
 static int ssb_gpio_extif_init(struct ssb_bus *bus)
 {
 	struct gpio_chip *chip = &bus->gpio;
 +	int err;
 	chip->label		= "ssb_extif_gpio";
 	chip->owner		= THIS_MODULE;
@@ -165,7 +423,9 @@ static int ssb_gpio_extif_init(struct ss
 	chip->set		= ssb_gpio_extif_set_value;
 	chip->direction_input	= ssb_gpio_extif_direction_input;
 	chip->direction_output	= ssb_gpio_extif_direction_output;
 -	chip->to_irq		= ssb_gpio_extif_to_irq;
 +#if IS_ENABLED(CONFIG_SSB_EMBEDDED)
 +	chip->to_irq		= ssb_gpio_to_irq;
 +#endif
 	chip->ngpio		= 5;
 	/* There is just one SoC in one device and its GPIO addresses should be
 	 * deterministic to address them more easily. The other buses could get
@@ -175,7 +435,17 @@ static int ssb_gpio_extif_init(struct ss
 	else
 		chip->base		= -1;
 -	return gpiochip_add(chip);
 +	err = ssb_gpio_irq_extif_domain_init(bus);
 +	if (err)
 +		return err;
 +
 +	err = gpiochip_add(chip);
 +	if (err) {
 +		ssb_gpio_irq_extif_domain_exit(bus);
 +		return err;
 +	}
 +
 +	return 0;
 }
 #else
@@ -185,6 +455,10 @@ static int ssb_gpio_extif_init(struct ss
 }
 #endif
 +/**************************************************
 + * Init
 + **************************************************/
 +
 int ssb_gpio_init(struct ssb_bus *bus)
 {
 	if (ssb_chipco_available(&bus->chipco))
 --- a/drivers/ssb/main.c
 +++ b/drivers/ssb/main.c
@@ -593,6 +593,13 @@ static int ssb_attach_queued_buses(void)
 		ssb_pcicore_init(&bus->pcicore);
 		if (bus->bustype == SSB_BUSTYPE_SSB)
 			ssb_watchdog_register(bus);
 +
 +		err = ssb_gpio_init(bus);
 +		if (err == -ENOTSUPP)
 +			ssb_dbg("GPIO driver not activated\n");
 +		else if (err)
 +			ssb_dbg("Error registering GPIO driver: %i\n", err);
 +
 		ssb_bus_may_powerdown(bus);
 		err = ssb_devices_register(bus);
@@ -830,11 +837,6 @@ static int ssb_bus_register(struct ssb_b
 	ssb_chipcommon_init(&bus->chipco);
 	ssb_extif_init(&bus->extif);
 	ssb_mipscore_init(&bus->mipscore);
 -	err = ssb_gpio_init(bus);
 -	if (err == -ENOTSUPP)
 -		ssb_dbg("GPIO driver not activated\n");
 -	else if (err)
 -		ssb_dbg("Error registering GPIO driver: %i\n", err);
 	err = ssb_fetch_invariants(bus, get_invariants);
 	if (err) {
 		ssb_bus_may_powerdown(bus);
 --- a/drivers/ssb/pci.c
 +++ b/drivers/ssb/pci.c
@@ -326,13 +326,13 @@ err_ctlreg:
 	return err;
 }
 -static s8 r123_extract_antgain(u8 sprom_revision, const u16 *in,
 -			       u16 mask, u16 shift)
 +static s8 sprom_extract_antgain(u8 sprom_revision, const u16 *in, u16 offset,
 +				u16 mask, u16 shift)
 {
 	u16 v;
 	u8 gain;
 -	v = in[SPOFF(SSB_SPROM1_AGAIN)];
 +	v = in[SPOFF(offset)];
 	gain = (v & mask) >> shift;
 	if (gain == 0xFF)
 		gain = 2; /* If unset use 2dBm */
@@ -416,12 +416,14 @@ static void sprom_extract_r123(struct ss
 	SPEX(alpha2[1], SSB_SPROM1_CCODE, 0x00ff, 0);
 	/* Extract the antenna gain values. */
 -	out->antenna_gain.a0 = r123_extract_antgain(out->revision, in,
 -						    SSB_SPROM1_AGAIN_BG,
 -						    SSB_SPROM1_AGAIN_BG_SHIFT);
 -	out->antenna_gain.a1 = r123_extract_antgain(out->revision, in,
 -						    SSB_SPROM1_AGAIN_A,
 -						    SSB_SPROM1_AGAIN_A_SHIFT);
 +	out->antenna_gain.a0 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM1_AGAIN,
 +						     SSB_SPROM1_AGAIN_BG,
 +						     SSB_SPROM1_AGAIN_BG_SHIFT);
 +	out->antenna_gain.a1 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM1_AGAIN,
 +						     SSB_SPROM1_AGAIN_A,
 +						     SSB_SPROM1_AGAIN_A_SHIFT);
 	if (out->revision >= 2)
 		sprom_extract_r23(out, in);
 }
@@ -468,7 +470,15 @@ static void sprom_extract_r458(struct ss
 static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in)
 {
 +	static const u16 pwr_info_offset[] = {
 +		SSB_SPROM4_PWR_INFO_CORE0, SSB_SPROM4_PWR_INFO_CORE1,
 +		SSB_SPROM4_PWR_INFO_CORE2, SSB_SPROM4_PWR_INFO_CORE3
 +	};
 	u16 il0mac_offset;
 +	int i;
 +
 +	BUILD_BUG_ON(ARRAY_SIZE(pwr_info_offset) !=
 +		     ARRAY_SIZE(out->core_pwr_info));
 	if (out->revision == 4)
 		il0mac_offset = SSB_SPROM4_IL0MAC;
@@ -524,14 +534,59 @@ static void sprom_extract_r45(struct ssb
 	}
 	/* Extract the antenna gain values. */
 -	SPEX(antenna_gain.a0, SSB_SPROM4_AGAIN01,
 -	     SSB_SPROM4_AGAIN0, SSB_SPROM4_AGAIN0_SHIFT);
 -	SPEX(antenna_gain.a1, SSB_SPROM4_AGAIN01,
 -	     SSB_SPROM4_AGAIN1, SSB_SPROM4_AGAIN1_SHIFT);
 -	SPEX(antenna_gain.a2, SSB_SPROM4_AGAIN23,
 -	     SSB_SPROM4_AGAIN2, SSB_SPROM4_AGAIN2_SHIFT);
 -	SPEX(antenna_gain.a3, SSB_SPROM4_AGAIN23,
 -	     SSB_SPROM4_AGAIN3, SSB_SPROM4_AGAIN3_SHIFT);
 +	out->antenna_gain.a0 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM4_AGAIN01,
 +						     SSB_SPROM4_AGAIN0,
 +						     SSB_SPROM4_AGAIN0_SHIFT);
 +	out->antenna_gain.a1 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM4_AGAIN01,
 +						     SSB_SPROM4_AGAIN1,
 +						     SSB_SPROM4_AGAIN1_SHIFT);
 +	out->antenna_gain.a2 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM4_AGAIN23,
 +						     SSB_SPROM4_AGAIN2,
 +						     SSB_SPROM4_AGAIN2_SHIFT);
 +	out->antenna_gain.a3 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM4_AGAIN23,
 +						     SSB_SPROM4_AGAIN3,
 +						     SSB_SPROM4_AGAIN3_SHIFT);
 +
 +	/* Extract cores power info info */
 +	for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
 +		u16 o = pwr_info_offset[i];
 +
 +		SPEX(core_pwr_info[i].itssi_2g, o + SSB_SPROM4_2G_MAXP_ITSSI,
 +			SSB_SPROM4_2G_ITSSI, SSB_SPROM4_2G_ITSSI_SHIFT);
 +		SPEX(core_pwr_info[i].maxpwr_2g, o + SSB_SPROM4_2G_MAXP_ITSSI,
 +			SSB_SPROM4_2G_MAXP, 0);
 +
 +		SPEX(core_pwr_info[i].pa_2g[0], o + SSB_SPROM4_2G_PA_0, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_2g[1], o + SSB_SPROM4_2G_PA_1, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_2g[2], o + SSB_SPROM4_2G_PA_2, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_2g[3], o + SSB_SPROM4_2G_PA_3, ~0, 0);
 +
 +		SPEX(core_pwr_info[i].itssi_5g, o + SSB_SPROM4_5G_MAXP_ITSSI,
 +			SSB_SPROM4_5G_ITSSI, SSB_SPROM4_5G_ITSSI_SHIFT);
 +		SPEX(core_pwr_info[i].maxpwr_5g, o + SSB_SPROM4_5G_MAXP_ITSSI,
 +			SSB_SPROM4_5G_MAXP, 0);
 +		SPEX(core_pwr_info[i].maxpwr_5gh, o + SSB_SPROM4_5GHL_MAXP,
 +			SSB_SPROM4_5GH_MAXP, 0);
 +		SPEX(core_pwr_info[i].maxpwr_5gl, o + SSB_SPROM4_5GHL_MAXP,
 +			SSB_SPROM4_5GL_MAXP, SSB_SPROM4_5GL_MAXP_SHIFT);
 +
 +		SPEX(core_pwr_info[i].pa_5gl[0], o + SSB_SPROM4_5GL_PA_0, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gl[1], o + SSB_SPROM4_5GL_PA_1, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gl[2], o + SSB_SPROM4_5GL_PA_2, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gl[3], o + SSB_SPROM4_5GL_PA_3, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5g[0], o + SSB_SPROM4_5G_PA_0, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5g[1], o + SSB_SPROM4_5G_PA_1, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5g[2], o + SSB_SPROM4_5G_PA_2, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5g[3], o + SSB_SPROM4_5G_PA_3, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gh[0], o + SSB_SPROM4_5GH_PA_0, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gh[1], o + SSB_SPROM4_5GH_PA_1, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gh[2], o + SSB_SPROM4_5GH_PA_2, ~0, 0);
 +		SPEX(core_pwr_info[i].pa_5gh[3], o + SSB_SPROM4_5GH_PA_3, ~0, 0);
 +	}
 	sprom_extract_r458(out, in);
@@ -621,14 +676,22 @@ static void sprom_extract_r8(struct ssb_
 	SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, 0xFFFFFFFF, 0);
 	/* Extract the antenna gain values. */
 -	SPEX(antenna_gain.a0, SSB_SPROM8_AGAIN01,
 -	     SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT);
 -	SPEX(antenna_gain.a1, SSB_SPROM8_AGAIN01,
 -	     SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT);
 -	SPEX(antenna_gain.a2, SSB_SPROM8_AGAIN23,
 -	     SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT);
 -	SPEX(antenna_gain.a3, SSB_SPROM8_AGAIN23,
 -	     SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT);
 +	out->antenna_gain.a0 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM8_AGAIN01,
 +						     SSB_SPROM8_AGAIN0,
 +						     SSB_SPROM8_AGAIN0_SHIFT);
 +	out->antenna_gain.a1 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM8_AGAIN01,
 +						     SSB_SPROM8_AGAIN1,
 +						     SSB_SPROM8_AGAIN1_SHIFT);
 +	out->antenna_gain.a2 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM8_AGAIN23,
 +						     SSB_SPROM8_AGAIN2,
 +						     SSB_SPROM8_AGAIN2_SHIFT);
 +	out->antenna_gain.a3 = sprom_extract_antgain(out->revision, in,
 +						     SSB_SPROM8_AGAIN23,
 +						     SSB_SPROM8_AGAIN3,
 +						     SSB_SPROM8_AGAIN3_SHIFT);
 	/* Extract cores power info info */
 	for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
 --- a/include/linux/ssb/ssb.h
 +++ b/include/linux/ssb/ssb.h
@@ -33,6 +33,7 @@ struct ssb_sprom {
 	u8 et1phyaddr;		/* MII address for enet1 */
 	u8 et0mdcport;		/* MDIO for enet0 */
 	u8 et1mdcport;		/* MDIO for enet1 */
 +	u16 dev_id;		/* Device ID overriding e.g. PCI ID */
 	u16 board_rev;		/* Board revision number from SPROM. */
 	u16 board_num;		/* Board number from SPROM. */
 	u16 board_type;		/* Board type from SPROM. */
@@ -486,6 +487,7 @@ struct ssb_bus {
 #endif /* EMBEDDED */
 #ifdef CONFIG_SSB_DRIVER_GPIO
 	struct gpio_chip gpio;
 +	struct irq_domain *irq_domain;
 #endif /* DRIVER_GPIO */
 	/* Internal-only stuff follows. Do not touch. */
 --- a/include/linux/ssb/ssb_regs.h
 +++ b/include/linux/ssb/ssb_regs.h
@@ -345,6 +345,43 @@
 #define  SSB_SPROM4_TXPID5GH2_SHIFT	0
 #define  SSB_SPROM4_TXPID5GH3		0xFF00
 #define  SSB_SPROM4_TXPID5GH3_SHIFT	8
 +
 +/* There are 4 blocks with power info sharing the same layout */
 +#define SSB_SPROM4_PWR_INFO_CORE0	0x0080
 +#define SSB_SPROM4_PWR_INFO_CORE1	0x00AE
 +#define SSB_SPROM4_PWR_INFO_CORE2	0x00DC
 +#define SSB_SPROM4_PWR_INFO_CORE3	0x010A
 +
 +#define SSB_SPROM4_2G_MAXP_ITSSI	0x00	/* 2 GHz ITSSI and 2 GHz Max Power */
 +#define  SSB_SPROM4_2G_MAXP		0x00FF
 +#define  SSB_SPROM4_2G_ITSSI		0xFF00
 +#define  SSB_SPROM4_2G_ITSSI_SHIFT	8
 +#define SSB_SPROM4_2G_PA_0		0x02	/* 2 GHz power amp */
 +#define SSB_SPROM4_2G_PA_1		0x04
 +#define SSB_SPROM4_2G_PA_2		0x06
 +#define SSB_SPROM4_2G_PA_3		0x08
 +#define SSB_SPROM4_5G_MAXP_ITSSI	0x0A	/* 5 GHz ITSSI and 5.3 GHz Max Power */
 +#define  SSB_SPROM4_5G_MAXP		0x00FF
 +#define  SSB_SPROM4_5G_ITSSI		0xFF00
 +#define  SSB_SPROM4_5G_ITSSI_SHIFT	8
 +#define SSB_SPROM4_5GHL_MAXP		0x0C	/* 5.2 GHz and 5.8 GHz Max Power */
 +#define  SSB_SPROM4_5GH_MAXP		0x00FF
 +#define  SSB_SPROM4_5GL_MAXP		0xFF00
 +#define  SSB_SPROM4_5GL_MAXP_SHIFT	8
 +#define SSB_SPROM4_5G_PA_0		0x0E	/* 5.3 GHz power amp */
 +#define SSB_SPROM4_5G_PA_1		0x10
 +#define SSB_SPROM4_5G_PA_2		0x12
 +#define SSB_SPROM4_5G_PA_3		0x14
 +#define SSB_SPROM4_5GL_PA_0		0x16	/* 5.2 GHz power amp */
 +#define SSB_SPROM4_5GL_PA_1		0x18
 +#define SSB_SPROM4_5GL_PA_2		0x1A
 +#define SSB_SPROM4_5GL_PA_3		0x1C
 +#define SSB_SPROM4_5GH_PA_0		0x1E	/* 5.8 GHz power amp */
 +#define SSB_SPROM4_5GH_PA_1		0x20
 +#define SSB_SPROM4_5GH_PA_2		0x22
 +#define SSB_SPROM4_5GH_PA_3		0x24
 +
 +/* TODO: Make it deprecated */
 #define SSB_SPROM4_MAXP_BG		0x0080  /* Max Power BG in path 1 */
 #define  SSB_SPROM4_MAXP_BG_MASK	0x00FF  /* Mask for Max Power BG */
 #define  SSB_SPROM4_ITSSI_BG		0xFF00	/* Mask for path 1 itssi_bg */
 --- a/arch/mips/bcm47xx/sprom.c
 +++ b/arch/mips/bcm47xx/sprom.c
@@ -168,6 +168,7 @@ static void nvram_read_alpha2(const char
 static void bcm47xx_fill_sprom_r1234589(struct ssb_sprom *sprom,
 					const char *prefix, bool fallback)
 {
 +	nvram_read_u16(prefix, NULL, "devid", &sprom->dev_id, 0, fallback);
 	nvram_read_u8(prefix, NULL, "ledbh0", &sprom->gpio0, 0xff, fallback);
 	nvram_read_u8(prefix, NULL, "ledbh1", &sprom->gpio1, 0xff, fallback);
 	nvram_read_u8(prefix, NULL, "ledbh2", &sprom->gpio2, 0xff, fallback);
--- a/target/linux/generic/patches-3.13/025-bcma_backport.patch
+++ b/target/linux/generic/patches-3.13/025-bcma_backport.patch
@ -1,870 +0,0 @@
 --- a/drivers/bcma/Kconfig
 +++ b/drivers/bcma/Kconfig
@@ -75,6 +75,7 @@ config BCMA_DRIVER_GMAC_CMN
 config BCMA_DRIVER_GPIO
 	bool "BCMA GPIO driver"
 	depends on BCMA && GPIOLIB
 +	select IRQ_DOMAIN if BCMA_HOST_SOC
 	help
 	  Driver to provide access to the GPIO pins of the bcma bus.
 --- a/drivers/bcma/Makefile
 +++ b/drivers/bcma/Makefile
@@ -3,6 +3,7 @@ bcma-y					+= driver_chipcommon.o driver
 bcma-$(CONFIG_BCMA_SFLASH)		+= driver_chipcommon_sflash.o
 bcma-$(CONFIG_BCMA_NFLASH)		+= driver_chipcommon_nflash.o
 bcma-y					+= driver_pci.o
 +bcma-y					+= driver_pcie2.o
 bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE)	+= driver_pci_host.o
 bcma-$(CONFIG_BCMA_DRIVER_MIPS)		+= driver_mips.o
 bcma-$(CONFIG_BCMA_DRIVER_GMAC_CMN)	+= driver_gmac_cmn.o
 --- a/drivers/bcma/bcma_private.h
 +++ b/drivers/bcma/bcma_private.h
@@ -33,8 +33,6 @@ int __init bcma_bus_early_register(struc
 int bcma_bus_suspend(struct bcma_bus *bus);
 int bcma_bus_resume(struct bcma_bus *bus);
 #endif
 -struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
 -					u8 unit);
 /* scan.c */
 int bcma_bus_scan(struct bcma_bus *bus);
 --- a/drivers/bcma/driver_chipcommon_pmu.c
 +++ b/drivers/bcma/driver_chipcommon_pmu.c
@@ -603,6 +603,8 @@ void bcma_pmu_spuravoid_pllupdate(struct
 		tmp = BCMA_CC_PMU_CTL_PLL_UPD | BCMA_CC_PMU_CTL_NOILPONW;
 		break;
 +	case BCMA_CHIP_ID_BCM43131:
 +	case BCMA_CHIP_ID_BCM43217:
 	case BCMA_CHIP_ID_BCM43227:
 	case BCMA_CHIP_ID_BCM43228:
 	case BCMA_CHIP_ID_BCM43428:
 --- a/drivers/bcma/driver_chipcommon_sflash.c
 +++ b/drivers/bcma/driver_chipcommon_sflash.c
@@ -38,7 +38,7 @@ static const struct bcma_sflash_tbl_e bc
 	{ "M25P32", 0x15, 0x10000, 64, },
 	{ "M25P64", 0x16, 0x10000, 128, },
 	{ "M25FL128", 0x17, 0x10000, 256, },
 -	{ 0 },
 +	{ NULL },
 };
 static const struct bcma_sflash_tbl_e bcma_sflash_sst_tbl[] = {
@@ -56,7 +56,7 @@ static const struct bcma_sflash_tbl_e bc
 	{ "SST25VF016", 0x41, 0x1000, 512, },
 	{ "SST25VF032", 0x4a, 0x1000, 1024, },
 	{ "SST25VF064", 0x4b, 0x1000, 2048, },
 -	{ 0 },
 +	{ NULL },
 };
 static const struct bcma_sflash_tbl_e bcma_sflash_at_tbl[] = {
@@ -67,7 +67,7 @@ static const struct bcma_sflash_tbl_e bc
 	{ "AT45DB161", 0x2c, 512, 4096, },
 	{ "AT45DB321", 0x34, 512, 8192, },
 	{ "AT45DB642", 0x3c, 1024, 8192, },
 -	{ 0 },
 +	{ NULL },
 };
 static void bcma_sflash_cmd(struct bcma_drv_cc *cc, u32 opcode)
 --- a/drivers/bcma/driver_gpio.c
 +++ b/drivers/bcma/driver_gpio.c
@@ -9,6 +9,9 @@
  */
 #include <linux/gpio.h>
 +#include <linux/irq.h>
 +#include <linux/interrupt.h>
 +#include <linux/irqdomain.h>
 #include <linux/export.h>
 #include <linux/bcma/bcma.h>
@@ -73,19 +76,136 @@ static void bcma_gpio_free(struct gpio_c
 	bcma_chipco_gpio_pullup(cc, 1 << gpio, 0);
 }
 +#if IS_BUILTIN(CONFIG_BCMA_HOST_SOC)
 static int bcma_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
 {
 	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 	if (cc->core->bus->hosttype == BCMA_HOSTTYPE_SOC)
 -		return bcma_core_irq(cc->core);
 +		return irq_find_mapping(cc->irq_domain, gpio);
 	else
 		return -EINVAL;
 }
 +static void bcma_gpio_irq_unmask(struct irq_data *d)
 +{
 +	struct bcma_drv_cc *cc = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 +	u32 val = bcma_chipco_gpio_in(cc, BIT(gpio));
 +
 +	bcma_chipco_gpio_polarity(cc, BIT(gpio), val);
 +	bcma_chipco_gpio_intmask(cc, BIT(gpio), BIT(gpio));
 +}
 +
 +static void bcma_gpio_irq_mask(struct irq_data *d)
 +{
 +	struct bcma_drv_cc *cc = irq_data_get_irq_chip_data(d);
 +	int gpio = irqd_to_hwirq(d);
 +
 +	bcma_chipco_gpio_intmask(cc, BIT(gpio), 0);
 +}
 +
 +static struct irq_chip bcma_gpio_irq_chip = {
 +	.name		= "BCMA-GPIO",
 +	.irq_mask	= bcma_gpio_irq_mask,
 +	.irq_unmask	= bcma_gpio_irq_unmask,
 +};
 +
 +static irqreturn_t bcma_gpio_irq_handler(int irq, void *dev_id)
 +{
 +	struct bcma_drv_cc *cc = dev_id;
 +	u32 val = bcma_cc_read32(cc, BCMA_CC_GPIOIN);
 +	u32 mask = bcma_cc_read32(cc, BCMA_CC_GPIOIRQ);
 +	u32 pol = bcma_cc_read32(cc, BCMA_CC_GPIOPOL);
 +	unsigned long irqs = (val ^ pol) & mask;
 +	int gpio;
 +
 +	if (!irqs)
 +		return IRQ_NONE;
 +
 +	for_each_set_bit(gpio, &irqs, cc->gpio.ngpio)
 +		generic_handle_irq(bcma_gpio_to_irq(&cc->gpio, gpio));
 +	bcma_chipco_gpio_polarity(cc, irqs, val & irqs);
 +
 +	return IRQ_HANDLED;
 +}
 +
 +static int bcma_gpio_irq_domain_init(struct bcma_drv_cc *cc)
 +{
 +	struct gpio_chip *chip = &cc->gpio;
 +	int gpio, hwirq, err;
 +
 +	if (cc->core->bus->hosttype != BCMA_HOSTTYPE_SOC)
 +		return 0;
 +
 +	cc->irq_domain = irq_domain_add_linear(NULL, chip->ngpio,
 +					       &irq_domain_simple_ops, cc);
 +	if (!cc->irq_domain) {
 +		err = -ENODEV;
 +		goto err_irq_domain;
 +	}
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_create_mapping(cc->irq_domain, gpio);
 +
 +		irq_set_chip_data(irq, cc);
 +		irq_set_chip_and_handler(irq, &bcma_gpio_irq_chip,
 +					 handle_simple_irq);
 +	}
 +
 +	hwirq = bcma_core_irq(cc->core);
 +	err = request_irq(hwirq, bcma_gpio_irq_handler, IRQF_SHARED, "gpio",
 +			  cc);
 +	if (err)
 +		goto err_req_irq;
 +
 +	bcma_chipco_gpio_intmask(cc, ~0, 0);
 +	bcma_cc_set32(cc, BCMA_CC_IRQMASK, BCMA_CC_IRQ_GPIO);
 +
 +	return 0;
 +
 +err_req_irq:
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(cc->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(cc->irq_domain);
 +err_irq_domain:
 +	return err;
 +}
 +
 +static void bcma_gpio_irq_domain_exit(struct bcma_drv_cc *cc)
 +{
 +	struct gpio_chip *chip = &cc->gpio;
 +	int gpio;
 +
 +	if (cc->core->bus->hosttype != BCMA_HOSTTYPE_SOC)
 +		return;
 +
 +	bcma_cc_mask32(cc, BCMA_CC_IRQMASK, ~BCMA_CC_IRQ_GPIO);
 +	free_irq(bcma_core_irq(cc->core), cc);
 +	for (gpio = 0; gpio < chip->ngpio; gpio++) {
 +		int irq = irq_find_mapping(cc->irq_domain, gpio);
 +
 +		irq_dispose_mapping(irq);
 +	}
 +	irq_domain_remove(cc->irq_domain);
 +}
 +#else
 +static int bcma_gpio_irq_domain_init(struct bcma_drv_cc *cc)
 +{
 +	return 0;
 +}
 +
 +static void bcma_gpio_irq_domain_exit(struct bcma_drv_cc *cc)
 +{
 +}
 +#endif
 +
 int bcma_gpio_init(struct bcma_drv_cc *cc)
 {
 	struct gpio_chip *chip = &cc->gpio;
 +	int err;
 	chip->label		= "bcma_gpio";
 	chip->owner		= THIS_MODULE;
@@ -95,8 +215,18 @@ int bcma_gpio_init(struct bcma_drv_cc *c
 	chip->set		= bcma_gpio_set_value;
 	chip->direction_input	= bcma_gpio_direction_input;
 	chip->direction_output	= bcma_gpio_direction_output;
 +#if IS_BUILTIN(CONFIG_BCMA_HOST_SOC)
 	chip->to_irq		= bcma_gpio_to_irq;
 -	chip->ngpio		= 16;
 +#endif
 +	switch (cc->core->bus->chipinfo.id) {
 +	case BCMA_CHIP_ID_BCM5357:
 +	case BCMA_CHIP_ID_BCM53572:
 +		chip->ngpio	= 32;
 +		break;
 +	default:
 +		chip->ngpio	= 16;
 +	}
 +
 	/* There is just one SoC in one device and its GPIO addresses should be
 	 * deterministic to address them more easily. The other buses could get
 	 * a random base number. */
@@ -105,10 +235,21 @@ int bcma_gpio_init(struct bcma_drv_cc *c
 	else
 		chip->base		= -1;
 -	return gpiochip_add(chip);
 +	err = bcma_gpio_irq_domain_init(cc);
 +	if (err)
 +		return err;
 +
 +	err = gpiochip_add(chip);
 +	if (err) {
 +		bcma_gpio_irq_domain_exit(cc);
 +		return err;
 +	}
 +
 +	return 0;
 }
 int bcma_gpio_unregister(struct bcma_drv_cc *cc)
 {
 +	bcma_gpio_irq_domain_exit(cc);
 	return gpiochip_remove(&cc->gpio);
 }
 --- /dev/null
 +++ b/drivers/bcma/driver_pcie2.c
@@ -0,0 +1,175 @@
 +/*
 + * Broadcom specific AMBA
 + * PCIe Gen 2 Core
 + *
 + * Copyright 2014, Broadcom Corporation
 + * Copyright 2014, Rafał Miłecki <zajec5@gmail.com>
 + *
 + * Licensed under the GNU/GPL. See COPYING for details.
 + */
 +
 +#include "bcma_private.h"
 +#include <linux/bcma/bcma.h>
 +
 +/**************************************************
 + * R/W ops.
 + **************************************************/
 +
 +#if 0
 +static u32 bcma_core_pcie2_cfg_read(struct bcma_drv_pcie2 *pcie2, u32 addr)
 +{
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, addr);
 +	pcie2_read32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR);
 +	return pcie2_read32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA);
 +}
 +#endif
 +
 +static void bcma_core_pcie2_cfg_write(struct bcma_drv_pcie2 *pcie2, u32 addr,
 +				      u32 val)
 +{
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, addr);
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, val);
 +}
 +
 +/**************************************************
 + * Init.
 + **************************************************/
 +
 +static u32 bcma_core_pcie2_war_delay_perst_enab(struct bcma_drv_pcie2 *pcie2,
 +						bool enable)
 +{
 +	u32 val;
 +
 +	/* restore back to default */
 +	val = pcie2_read32(pcie2, BCMA_CORE_PCIE2_CLK_CONTROL);
 +	val |= PCIE2_CLKC_DLYPERST;
 +	val &= ~PCIE2_CLKC_DISSPROMLD;
 +	if (enable) {
 +		val &= ~PCIE2_CLKC_DLYPERST;
 +		val |= PCIE2_CLKC_DISSPROMLD;
 +	}
 +	pcie2_write32(pcie2, (BCMA_CORE_PCIE2_CLK_CONTROL), val);
 +	/* flush */
 +	return pcie2_read32(pcie2, BCMA_CORE_PCIE2_CLK_CONTROL);
 +}
 +
 +static void bcma_core_pcie2_set_ltr_vals(struct bcma_drv_pcie2 *pcie2)
 +{
 +	/* LTR0 */
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, 0x844);
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, 0x883c883c);
 +	/* LTR1 */
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, 0x848);
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, 0x88648864);
 +	/* LTR2 */
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, 0x84C);
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, 0x90039003);
 +}
 +
 +static void bcma_core_pcie2_hw_ltr_war(struct bcma_drv_pcie2 *pcie2)
 +{
 +	u8 core_rev = pcie2->core->id.rev;
 +	u32 devstsctr2;
 +
 +	if (core_rev < 2 || core_rev == 10 || core_rev > 13)
 +		return;
 +
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR,
 +		      PCIE2_CAP_DEVSTSCTRL2_OFFSET);
 +	devstsctr2 = pcie2_read32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA);
 +	if (devstsctr2 & PCIE2_CAP_DEVSTSCTRL2_LTRENAB) {
 +		/* force the right LTR values */
 +		bcma_core_pcie2_set_ltr_vals(pcie2);
 +
 +		/* TODO:
 +		si_core_wrapperreg(pcie2, 3, 0x60, 0x8080, 0); */
 +
 +		/* enable the LTR */
 +		devstsctr2 |= PCIE2_CAP_DEVSTSCTRL2_LTRENAB;
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR,
 +			      PCIE2_CAP_DEVSTSCTRL2_OFFSET);
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, devstsctr2);
 +
 +		/* set the LTR state to be active */
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_LTR_STATE,
 +			      PCIE2_LTR_ACTIVE);
 +		usleep_range(1000, 2000);
 +
 +		/* set the LTR state to be sleep */
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_LTR_STATE,
 +			      PCIE2_LTR_SLEEP);
 +		usleep_range(1000, 2000);
 +	}
 +}
 +
 +static void pciedev_crwlpciegen2(struct bcma_drv_pcie2 *pcie2)
 +{
 +	u8 core_rev = pcie2->core->id.rev;
 +	bool pciewar160, pciewar162;
 +
 +	pciewar160 = core_rev == 7 || core_rev == 9 || core_rev == 11;
 +	pciewar162 = core_rev == 5 || core_rev == 7 || core_rev == 8 ||
 +		     core_rev == 9 || core_rev == 11;
 +
 +	if (!pciewar160 && !pciewar162)
 +		return;
 +
 +/* TODO */
 +#if 0
 +	pcie2_set32(pcie2, BCMA_CORE_PCIE2_CLK_CONTROL,
 +		    PCIE_DISABLE_L1CLK_GATING);
 +#if 0
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR,
 +		      PCIEGEN2_COE_PVT_TL_CTRL_0);
 +	pcie2_mask32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA,
 +		     ~(1 << COE_PVT_TL_CTRL_0_PM_DIS_L1_REENTRY_BIT));
 +#endif
 +#endif
 +}
 +
 +static void pciedev_crwlpciegen2_180(struct bcma_drv_pcie2 *pcie2)
 +{
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, PCIE2_PMCR_REFUP);
 +	pcie2_set32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, 0x1f);
 +}
 +
 +static void pciedev_crwlpciegen2_182(struct bcma_drv_pcie2 *pcie2)
 +{
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR, PCIE2_SBMBX);
 +	pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, 1 << 0);
 +}
 +
 +static void pciedev_reg_pm_clk_period(struct bcma_drv_pcie2 *pcie2)
 +{
 +	struct bcma_drv_cc *drv_cc = &pcie2->core->bus->drv_cc;
 +	u8 core_rev = pcie2->core->id.rev;
 +	u32 alp_khz, pm_value;
 +
 +	if (core_rev <= 13) {
 +		alp_khz = bcma_pmu_get_alp_clock(drv_cc) / 1000;
 +		pm_value = (1000000 * 2) / alp_khz;
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDADDR,
 +			      PCIE2_PVT_REG_PM_CLK_PERIOD);
 +		pcie2_write32(pcie2, BCMA_CORE_PCIE2_CONFIGINDDATA, pm_value);
 +	}
 +}
 +
 +void bcma_core_pcie2_init(struct bcma_drv_pcie2 *pcie2)
 +{
 +	struct bcma_chipinfo *ci = &pcie2->core->bus->chipinfo;
 +	u32 tmp;
 +
 +	tmp = pcie2_read32(pcie2, BCMA_CORE_PCIE2_SPROM(54));
 +	if ((tmp & 0xe) >> 1 == 2)
 +		bcma_core_pcie2_cfg_write(pcie2, 0x4e0, 0x17);
 +
 +	/* TODO: Do we need pcie_reqsize? */
 +
 +	if (ci->id == BCMA_CHIP_ID_BCM4360 && ci->rev > 3)
 +		bcma_core_pcie2_war_delay_perst_enab(pcie2, true);
 +	bcma_core_pcie2_hw_ltr_war(pcie2);
 +	pciedev_crwlpciegen2(pcie2);
 +	pciedev_reg_pm_clk_period(pcie2);
 +	pciedev_crwlpciegen2_180(pcie2);
 +	pciedev_crwlpciegen2_182(pcie2);
 +}
 --- a/drivers/bcma/host_pci.c
 +++ b/drivers/bcma/host_pci.c
@@ -238,7 +238,6 @@ static void bcma_host_pci_remove(struct
 	pci_release_regions(dev);
 	pci_disable_device(dev);
 	kfree(bus);
 -	pci_set_drvdata(dev, NULL);
 }
 #ifdef CONFIG_PM_SLEEP
@@ -270,7 +269,7 @@ static SIMPLE_DEV_PM_OPS(bcma_pm_ops, bc
 #endif /* CONFIG_PM_SLEEP */
 -static DEFINE_PCI_DEVICE_TABLE(bcma_pci_bridge_tbl) = {
 +static const struct pci_device_id bcma_pci_bridge_tbl[] = {
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4313) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 43224) },
@@ -280,6 +279,8 @@ static DEFINE_PCI_DEVICE_TABLE(bcma_pci_
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4358) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4359) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4365) },
 +	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x43a9) },
 +	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x43aa) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4727) },
 	{ 0, },
 };
 --- a/drivers/bcma/main.c
 +++ b/drivers/bcma/main.c
@@ -78,18 +78,6 @@ static u16 bcma_cc_core_id(struct bcma_b
 	return BCMA_CORE_CHIPCOMMON;
 }
 -struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
 -{
 -	struct bcma_device *core;
 -
 -	list_for_each_entry(core, &bus->cores, list) {
 -		if (core->id.id == coreid)
 -			return core;
 -	}
 -	return NULL;
 -}
 -EXPORT_SYMBOL_GPL(bcma_find_core);
 -
 struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
 					u8 unit)
 {
@@ -101,6 +89,7 @@ struct bcma_device *bcma_find_core_unit(
 	}
 	return NULL;
 }
 +EXPORT_SYMBOL_GPL(bcma_find_core_unit);
 bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
 		     int timeout)
@@ -143,6 +132,7 @@ static int bcma_register_cores(struct bc
 		case BCMA_CORE_CHIPCOMMON:
 		case BCMA_CORE_PCI:
 		case BCMA_CORE_PCIE:
 +		case BCMA_CORE_PCIE2:
 		case BCMA_CORE_MIPS_74K:
 		case BCMA_CORE_4706_MAC_GBIT_COMMON:
 			continue;
@@ -176,6 +166,7 @@ static int bcma_register_cores(struct bc
 			bcma_err(bus,
 				 "Could not register dev for core 0x%03X\n",
 				 core->id.id);
 +			put_device(&core->dev);
 			continue;
 		}
 		core->dev_registered = true;
@@ -291,6 +282,13 @@ int bcma_bus_register(struct bcma_bus *b
 		bcma_core_pci_init(&bus->drv_pci[1]);
 	}
 +	/* Init PCIe Gen 2 core */
 +	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE2, 0);
 +	if (core) {
 +		bus->drv_pcie2.core = core;
 +		bcma_core_pcie2_init(&bus->drv_pcie2);
 +	}
 +
 	/* Init GBIT MAC COMMON core */
 	core = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON);
 	if (core) {
 --- a/drivers/bcma/sprom.c
 +++ b/drivers/bcma/sprom.c
@@ -201,6 +201,23 @@ static int bcma_sprom_valid(struct bcma_
 		SPEX(_field[7], _offset + 14, _mask, _shift);	\
 	} while (0)
 +static s8 sprom_extract_antgain(const u16 *in, u16 offset, u16 mask, u16 shift)
 +{
 +	u16 v;
 +	u8 gain;
 +
 +	v = in[SPOFF(offset)];
 +	gain = (v & mask) >> shift;
 +	if (gain == 0xFF) {
 +		gain = 8; /* If unset use 2dBm */
 +	} else {
 +		/* Q5.2 Fractional part is stored in 0xC0 */
 +		gain = ((gain & 0xC0) >> 6) | ((gain & 0x3F) << 2);
 +	}
 +
 +	return (s8)gain;
 +}
 +
 static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
 {
 	u16 v, o;
@@ -381,14 +398,22 @@ static void bcma_sprom_extract_r8(struct
 	SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, ~0, 0);
 	/* Extract the antenna gain values. */
 -	SPEX(antenna_gain.a0, SSB_SPROM8_AGAIN01,
 -	     SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT);
 -	SPEX(antenna_gain.a1, SSB_SPROM8_AGAIN01,
 -	     SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT);
 -	SPEX(antenna_gain.a2, SSB_SPROM8_AGAIN23,
 -	     SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT);
 -	SPEX(antenna_gain.a3, SSB_SPROM8_AGAIN23,
 -	     SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT);
 +	bus->sprom.antenna_gain.a0 = sprom_extract_antgain(sprom,
 +							   SSB_SPROM8_AGAIN01,
 +							   SSB_SPROM8_AGAIN0,
 +							   SSB_SPROM8_AGAIN0_SHIFT);
 +	bus->sprom.antenna_gain.a1 = sprom_extract_antgain(sprom,
 +							   SSB_SPROM8_AGAIN01,
 +							   SSB_SPROM8_AGAIN1,
 +							   SSB_SPROM8_AGAIN1_SHIFT);
 +	bus->sprom.antenna_gain.a2 = sprom_extract_antgain(sprom,
 +							   SSB_SPROM8_AGAIN23,
 +							   SSB_SPROM8_AGAIN2,
 +							   SSB_SPROM8_AGAIN2_SHIFT);
 +	bus->sprom.antenna_gain.a3 = sprom_extract_antgain(sprom,
 +							   SSB_SPROM8_AGAIN23,
 +							   SSB_SPROM8_AGAIN3,
 +							   SSB_SPROM8_AGAIN3_SHIFT);
 	SPEX(leddc_on_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_ON,
 	     SSB_SPROM8_LEDDC_ON_SHIFT);
@@ -509,6 +534,8 @@ static bool bcma_sprom_onchip_available(
 		/* for these chips OTP is always available */
 		present = true;
 		break;
 +	case BCMA_CHIP_ID_BCM43131:
 +	case BCMA_CHIP_ID_BCM43217:
 	case BCMA_CHIP_ID_BCM43227:
 	case BCMA_CHIP_ID_BCM43228:
 	case BCMA_CHIP_ID_BCM43428:
 --- a/include/linux/bcma/bcma.h
 +++ b/include/linux/bcma/bcma.h
@@ -6,6 +6,7 @@
 #include <linux/bcma/bcma_driver_chipcommon.h>
 #include <linux/bcma/bcma_driver_pci.h>
 +#include <linux/bcma/bcma_driver_pcie2.h>
 #include <linux/bcma/bcma_driver_mips.h>
 #include <linux/bcma/bcma_driver_gmac_cmn.h>
 #include <linux/ssb/ssb.h> /* SPROM sharing */
@@ -72,17 +73,17 @@ struct bcma_host_ops {
 /* Core-ID values. */
 #define BCMA_CORE_OOB_ROUTER		0x367	/* Out of band */
 #define BCMA_CORE_4706_CHIPCOMMON	0x500
 -#define BCMA_CORE_PCIEG2		0x501
 -#define BCMA_CORE_DMA			0x502
 -#define BCMA_CORE_SDIO3			0x503
 -#define BCMA_CORE_USB20			0x504
 -#define BCMA_CORE_USB30			0x505
 -#define BCMA_CORE_A9JTAG		0x506
 -#define BCMA_CORE_DDR23			0x507
 -#define BCMA_CORE_ROM			0x508
 -#define BCMA_CORE_NAND			0x509
 -#define BCMA_CORE_QSPI			0x50A
 -#define BCMA_CORE_CHIPCOMMON_B		0x50B
 +#define BCMA_CORE_NS_PCIEG2		0x501
 +#define BCMA_CORE_NS_DMA		0x502
 +#define BCMA_CORE_NS_SDIO3		0x503
 +#define BCMA_CORE_NS_USB20		0x504
 +#define BCMA_CORE_NS_USB30		0x505
 +#define BCMA_CORE_NS_A9JTAG		0x506
 +#define BCMA_CORE_NS_DDR23		0x507
 +#define BCMA_CORE_NS_ROM		0x508
 +#define BCMA_CORE_NS_NAND		0x509
 +#define BCMA_CORE_NS_QSPI		0x50A
 +#define BCMA_CORE_NS_CHIPCOMMON_B	0x50B
 #define BCMA_CORE_4706_SOC_RAM		0x50E
 #define BCMA_CORE_ARMCA9		0x510
 #define BCMA_CORE_4706_MAC_GBIT		0x52D
@@ -157,6 +158,9 @@ struct bcma_host_ops {
 /* Chip IDs of PCIe devices */
 #define BCMA_CHIP_ID_BCM4313	0x4313
 #define BCMA_CHIP_ID_BCM43142	43142
 +#define BCMA_CHIP_ID_BCM43131	43131
 +#define BCMA_CHIP_ID_BCM43217	43217
 +#define BCMA_CHIP_ID_BCM43222	43222
 #define BCMA_CHIP_ID_BCM43224	43224
 #define  BCMA_PKG_ID_BCM43224_FAB_CSM	0x8
 #define  BCMA_PKG_ID_BCM43224_FAB_SMIC	0xa
@@ -333,6 +337,7 @@ struct bcma_bus {
 	struct bcma_drv_cc drv_cc;
 	struct bcma_drv_pci drv_pci[2];
 +	struct bcma_drv_pcie2 drv_pcie2;
 	struct bcma_drv_mips drv_mips;
 	struct bcma_drv_gmac_cmn drv_gmac_cmn;
@@ -418,7 +423,14 @@ static inline void bcma_maskset16(struct
 	bcma_write16(cc, offset, (bcma_read16(cc, offset) & mask) | set);
 }
 -extern struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid);
 +extern struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
 +					       u8 unit);
 +static inline struct bcma_device *bcma_find_core(struct bcma_bus *bus,
 +						 u16 coreid)
 +{
 +	return bcma_find_core_unit(bus, coreid, 0);
 +}
 +
 extern bool bcma_core_is_enabled(struct bcma_device *core);
 extern void bcma_core_disable(struct bcma_device *core, u32 flags);
 extern int bcma_core_enable(struct bcma_device *core, u32 flags);
 --- a/include/linux/bcma/bcma_driver_chipcommon.h
 +++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -640,6 +640,7 @@ struct bcma_drv_cc {
 	spinlock_t gpio_lock;
 #ifdef CONFIG_BCMA_DRIVER_GPIO
 	struct gpio_chip gpio;
 +	struct irq_domain *irq_domain;
 #endif
 };
 --- /dev/null
 +++ b/include/linux/bcma/bcma_driver_pcie2.h
@@ -0,0 +1,158 @@
 +#ifndef LINUX_BCMA_DRIVER_PCIE2_H_
 +#define LINUX_BCMA_DRIVER_PCIE2_H_
 +
 +#define BCMA_CORE_PCIE2_CLK_CONTROL		0x0000
 +#define  PCIE2_CLKC_RST_OE			0x0001 /* When set, drives PCI_RESET out to pin */
 +#define  PCIE2_CLKC_RST				0x0002 /* Value driven out to pin */
 +#define  PCIE2_CLKC_SPERST			0x0004 /* SurvivePeRst */
 +#define  PCIE2_CLKC_DISABLE_L1CLK_GATING	0x0010
 +#define  PCIE2_CLKC_DLYPERST			0x0100 /* Delay PeRst to CoE Core */
 +#define  PCIE2_CLKC_DISSPROMLD			0x0200 /* DisableSpromLoadOnPerst */
 +#define  PCIE2_CLKC_WAKE_MODE_L2		0x1000 /* Wake on L2 */
 +#define BCMA_CORE_PCIE2_RC_PM_CONTROL		0x0004
 +#define BCMA_CORE_PCIE2_RC_PM_STATUS		0x0008
 +#define BCMA_CORE_PCIE2_EP_PM_CONTROL		0x000C
 +#define BCMA_CORE_PCIE2_EP_PM_STATUS		0x0010
 +#define BCMA_CORE_PCIE2_EP_LTR_CONTROL		0x0014
 +#define BCMA_CORE_PCIE2_EP_LTR_STATUS		0x0018
 +#define BCMA_CORE_PCIE2_EP_OBFF_STATUS		0x001C
 +#define BCMA_CORE_PCIE2_PCIE_ERR_STATUS		0x0020
 +#define BCMA_CORE_PCIE2_RC_AXI_CONFIG		0x0100
 +#define BCMA_CORE_PCIE2_EP_AXI_CONFIG		0x0104
 +#define BCMA_CORE_PCIE2_RXDEBUG_STATUS0		0x0108
 +#define BCMA_CORE_PCIE2_RXDEBUG_CONTROL0	0x010C
 +#define BCMA_CORE_PCIE2_CONFIGINDADDR		0x0120
 +#define BCMA_CORE_PCIE2_CONFIGINDDATA		0x0124
 +#define BCMA_CORE_PCIE2_MDIOCONTROL		0x0128
 +#define BCMA_CORE_PCIE2_MDIOWRDATA		0x012C
 +#define BCMA_CORE_PCIE2_MDIORDDATA		0x0130
 +#define BCMA_CORE_PCIE2_DATAINTF		0x0180
 +#define BCMA_CORE_PCIE2_D2H_INTRLAZY_0		0x0188
 +#define BCMA_CORE_PCIE2_H2D_INTRLAZY_0		0x018c
 +#define BCMA_CORE_PCIE2_H2D_INTSTAT_0		0x0190
 +#define BCMA_CORE_PCIE2_H2D_INTMASK_0		0x0194
 +#define BCMA_CORE_PCIE2_D2H_INTSTAT_0		0x0198
 +#define BCMA_CORE_PCIE2_D2H_INTMASK_0		0x019c
 +#define BCMA_CORE_PCIE2_LTR_STATE		0x01A0 /* Latency Tolerance Reporting */
 +#define  PCIE2_LTR_ACTIVE			2
 +#define  PCIE2_LTR_ACTIVE_IDLE			1
 +#define  PCIE2_LTR_SLEEP			0
 +#define  PCIE2_LTR_FINAL_MASK			0x300
 +#define  PCIE2_LTR_FINAL_SHIFT			8
 +#define BCMA_CORE_PCIE2_PWR_INT_STATUS		0x01A4
 +#define BCMA_CORE_PCIE2_PWR_INT_MASK		0x01A8
 +#define BCMA_CORE_PCIE2_CFG_ADDR		0x01F8
 +#define BCMA_CORE_PCIE2_CFG_DATA		0x01FC
 +#define BCMA_CORE_PCIE2_SYS_EQ_PAGE		0x0200
 +#define BCMA_CORE_PCIE2_SYS_MSI_PAGE		0x0204
 +#define BCMA_CORE_PCIE2_SYS_MSI_INTREN		0x0208
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL0		0x0210
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL1		0x0214
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL2		0x0218
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL3		0x021C
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL4		0x0220
 +#define BCMA_CORE_PCIE2_SYS_MSI_CTRL5		0x0224
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD0		0x0250
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL0		0x0254
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD1		0x0258
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL1		0x025C
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD2		0x0260
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL2		0x0264
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD3		0x0268
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL3		0x026C
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD4		0x0270
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL4		0x0274
 +#define BCMA_CORE_PCIE2_SYS_EQ_HEAD5		0x0278
 +#define BCMA_CORE_PCIE2_SYS_EQ_TAIL5		0x027C
 +#define BCMA_CORE_PCIE2_SYS_RC_INTX_EN		0x0330
 +#define BCMA_CORE_PCIE2_SYS_RC_INTX_CSR		0x0334
 +#define BCMA_CORE_PCIE2_SYS_MSI_REQ		0x0340
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR_EN	0x0344
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR_CSR	0x0348
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR0		0x0350
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR1		0x0354
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR2		0x0358
 +#define BCMA_CORE_PCIE2_SYS_HOST_INTR3		0x035C
 +#define BCMA_CORE_PCIE2_SYS_EP_INT_EN0		0x0360
 +#define BCMA_CORE_PCIE2_SYS_EP_INT_EN1		0x0364
 +#define BCMA_CORE_PCIE2_SYS_EP_INT_CSR0		0x0370
 +#define BCMA_CORE_PCIE2_SYS_EP_INT_CSR1		0x0374
 +#define BCMA_CORE_PCIE2_SPROM(wordoffset)	(0x0800 + ((wordoffset) * 2))
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_0		0x0C00
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_1		0x0C04
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_2		0x0C08
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_3		0x0C0C
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_4		0x0C10
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_5		0x0C14
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_6		0x0C18
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP0_7		0x0C1C
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_0		0x0C20
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_1		0x0C24
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_2		0x0C28
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_3		0x0C2C
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_4		0x0C30
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_5		0x0C34
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_6		0x0C38
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP0_7		0x0C3C
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP1		0x0C80
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP1		0x0C88
 +#define BCMA_CORE_PCIE2_FUNC0_IMAP2		0x0CC0
 +#define BCMA_CORE_PCIE2_FUNC1_IMAP2		0x0CC8
 +#define BCMA_CORE_PCIE2_IARR0_LOWER		0x0D00
 +#define BCMA_CORE_PCIE2_IARR0_UPPER		0x0D04
 +#define BCMA_CORE_PCIE2_IARR1_LOWER		0x0D08
 +#define BCMA_CORE_PCIE2_IARR1_UPPER		0x0D0C
 +#define BCMA_CORE_PCIE2_IARR2_LOWER		0x0D10
 +#define BCMA_CORE_PCIE2_IARR2_UPPER		0x0D14
 +#define BCMA_CORE_PCIE2_OARR0			0x0D20
 +#define BCMA_CORE_PCIE2_OARR1			0x0D28
 +#define BCMA_CORE_PCIE2_OARR2			0x0D30
 +#define BCMA_CORE_PCIE2_OMAP0_LOWER		0x0D40
 +#define BCMA_CORE_PCIE2_OMAP0_UPPER		0x0D44
 +#define BCMA_CORE_PCIE2_OMAP1_LOWER		0x0D48
 +#define BCMA_CORE_PCIE2_OMAP1_UPPER		0x0D4C
 +#define BCMA_CORE_PCIE2_OMAP2_LOWER		0x0D50
 +#define BCMA_CORE_PCIE2_OMAP2_UPPER		0x0D54
 +#define BCMA_CORE_PCIE2_FUNC1_IARR1_SIZE	0x0D58
 +#define BCMA_CORE_PCIE2_FUNC1_IARR2_SIZE	0x0D5C
 +#define BCMA_CORE_PCIE2_MEM_CONTROL		0x0F00
 +#define BCMA_CORE_PCIE2_MEM_ECC_ERRLOG0		0x0F04
 +#define BCMA_CORE_PCIE2_MEM_ECC_ERRLOG1		0x0F08
 +#define BCMA_CORE_PCIE2_LINK_STATUS		0x0F0C
 +#define BCMA_CORE_PCIE2_STRAP_STATUS		0x0F10
 +#define BCMA_CORE_PCIE2_RESET_STATUS		0x0F14
 +#define BCMA_CORE_PCIE2_RESETEN_IN_LINKDOWN	0x0F18
 +#define BCMA_CORE_PCIE2_MISC_INTR_EN		0x0F1C
 +#define BCMA_CORE_PCIE2_TX_DEBUG_CFG		0x0F20
 +#define BCMA_CORE_PCIE2_MISC_CONFIG		0x0F24
 +#define BCMA_CORE_PCIE2_MISC_STATUS		0x0F28
 +#define BCMA_CORE_PCIE2_INTR_EN			0x0F30
 +#define BCMA_CORE_PCIE2_INTR_CLEAR		0x0F34
 +#define BCMA_CORE_PCIE2_INTR_STATUS		0x0F38
 +
 +/* PCIE gen2 config regs */
 +#define PCIE2_INTSTATUS				0x090
 +#define PCIE2_INTMASK				0x094
 +#define PCIE2_SBMBX				0x098
 +
 +#define PCIE2_PMCR_REFUP			0x1814 /* Trefup time */
 +
 +#define PCIE2_CAP_DEVSTSCTRL2_OFFSET		0xD4
 +#define PCIE2_CAP_DEVSTSCTRL2_LTRENAB		0x400
 +#define PCIE2_PVT_REG_PM_CLK_PERIOD		0x184c
 +
 +struct bcma_drv_pcie2 {
 +	struct bcma_device *core;
 +};
 +
 +#define pcie2_read16(pcie2, offset)		bcma_read16((pcie2)->core, offset)
 +#define pcie2_read32(pcie2, offset)		bcma_read32((pcie2)->core, offset)
 +#define pcie2_write16(pcie2, offset, val)	bcma_write16((pcie2)->core, offset, val)
 +#define pcie2_write32(pcie2, offset, val)	bcma_write32((pcie2)->core, offset, val)
 +
 +#define pcie2_set32(pcie2, offset, set)		bcma_set32((pcie2)->core, offset, set)
 +#define pcie2_mask32(pcie2, offset, mask)	bcma_mask32((pcie2)->core, offset, mask)
 +
 +void bcma_core_pcie2_init(struct bcma_drv_pcie2 *pcie2);
 +
 +#endif /* LINUX_BCMA_DRIVER_PCIE2_H_ */
 --- a/drivers/bcma/scan.c
 +++ b/drivers/bcma/scan.c
@@ -32,17 +32,17 @@ static const struct bcma_device_id_name
 	{ BCMA_CORE_4706_CHIPCOMMON, "BCM4706 ChipCommon" },
 	{ BCMA_CORE_4706_SOC_RAM, "BCM4706 SOC RAM" },
 	{ BCMA_CORE_4706_MAC_GBIT, "BCM4706 GBit MAC" },
 -	{ BCMA_CORE_PCIEG2, "PCIe Gen 2" },
 -	{ BCMA_CORE_DMA, "DMA" },
 -	{ BCMA_CORE_SDIO3, "SDIO3" },
 -	{ BCMA_CORE_USB20, "USB 2.0" },
 -	{ BCMA_CORE_USB30, "USB 3.0" },
 -	{ BCMA_CORE_A9JTAG, "ARM Cortex A9 JTAG" },
 -	{ BCMA_CORE_DDR23, "Denali DDR2/DDR3 memory controller" },
 -	{ BCMA_CORE_ROM, "ROM" },
 -	{ BCMA_CORE_NAND, "NAND flash controller" },
 -	{ BCMA_CORE_QSPI, "SPI flash controller" },
 -	{ BCMA_CORE_CHIPCOMMON_B, "Chipcommon B" },
 +	{ BCMA_CORE_NS_PCIEG2, "PCIe Gen 2" },
 +	{ BCMA_CORE_NS_DMA, "DMA" },
 +	{ BCMA_CORE_NS_SDIO3, "SDIO3" },
 +	{ BCMA_CORE_NS_USB20, "USB 2.0" },
 +	{ BCMA_CORE_NS_USB30, "USB 3.0" },
 +	{ BCMA_CORE_NS_A9JTAG, "ARM Cortex A9 JTAG" },
 +	{ BCMA_CORE_NS_DDR23, "Denali DDR2/DDR3 memory controller" },
 +	{ BCMA_CORE_NS_ROM, "ROM" },
 +	{ BCMA_CORE_NS_NAND, "NAND flash controller" },
 +	{ BCMA_CORE_NS_QSPI, "SPI flash controller" },
 +	{ BCMA_CORE_NS_CHIPCOMMON_B, "Chipcommon B" },
 	{ BCMA_CORE_ARMCA9, "ARM Cortex A9 core (ihost)" },
 	{ BCMA_CORE_AMEMC, "AMEMC (DDR)" },
 	{ BCMA_CORE_ALTA, "ALTA (I2S)" },
--- a/target/linux/generic/patches-3.13/060-hso_devices.patch
+++ b/target/linux/generic/patches-3.13/060-hso_devices.patch
@ -1,36 +0,0 @@
 --- a/drivers/net/usb/hso.c
 +++ b/drivers/net/usb/hso.c
@@ -467,8 +467,10 @@ static const struct usb_device_id hso_id
 	{USB_DEVICE(0x0af0, 0x8400)},
 	{USB_DEVICE(0x0af0, 0x8600)},
 	{USB_DEVICE(0x0af0, 0x8800)},
 -	{USB_DEVICE(0x0af0, 0x8900)},
 -	{USB_DEVICE(0x0af0, 0x9000)},
 +	{USB_DEVICE(0x0af0, 0x8900)},  /* GTM 67xx */
 +	{USB_DEVICE(0x0af0, 0x9000)},  /* GTM 66xx */
 +	{USB_DEVICE(0x0af0, 0x9200)},  /* GTM 67xxWFS */
 +	{USB_DEVICE(0x0af0, 0x9300)},  /* GTM 66xxWFS */
 	{USB_DEVICE(0x0af0, 0xd035)},
 	{USB_DEVICE(0x0af0, 0xd055)},
 	{USB_DEVICE(0x0af0, 0xd155)},
 --- a/drivers/usb/storage/unusual_devs.h
 +++ b/drivers/usb/storage/unusual_devs.h
@@ -1266,6 +1266,18 @@ UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0
 		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 		0 ),
 +UNUSUAL_DEV( 0x0af0, 0x9200, 0x0000, 0x0000,
 +		"Option",
 +		"Globetrotter 67xxWFS SD-Card",
 +		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 +		0 ),
 +
 +UNUSUAL_DEV( 0x0af0, 0x9300, 0x0000, 0x0000,
 +		"Option",
 +		"Globetrotter 66xxWFS SD-Card",
 +		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 +		0 ),
 +
 UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000,
 		"Option",
 		"GI 070x SD-Card",
--- a/target/linux/generic/patches-3.13/061-arm_xz_decompressor_build_fix.patch
+++ b/target/linux/generic/patches-3.13/061-arm_xz_decompressor_build_fix.patch
@ -1,10 +0,0 @@
 --- a/arch/arm/boot/compressed/decompress.c
 +++ b/arch/arm/boot/compressed/decompress.c
@@ -48,6 +48,7 @@ extern char * strstr(const char * s1, co
 #ifdef CONFIG_KERNEL_XZ
 #define memmove memmove
 #define memcpy memcpy
 +extern char * strstr(const char *, const char *);
 #include "../../../../lib/decompress_unxz.c"
 #endif
--- a/target/linux/generic/patches-3.13/062-mips_decompressor_build_fix.patch
+++ b/target/linux/generic/patches-3.13/062-mips_decompressor_build_fix.patch
@ -1,66 +0,0 @@
 From 0db3db45f5bd6df4bdc03bbd5dec672e16164c4e Mon Sep 17 00:00:00 2001
 From: Florian Fainelli <florian@openwrt.org>
 Date: Mon, 12 Nov 2012 12:31:55 +0100
 Subject: [PATCH] MIPS: decompressor: fix build failure on memcpy() in
 decompress.c
 The decompress.c file includes linux/kernel.h which causes the following
 inclusion chain to be pulled:
 linux/kernel.h ->
 	linux/dynamic_debug.h ->
 		linux/string.h ->
 			asm/string.h
 We end up having a the GCC builtin + architecture specific memcpy() expanding
 into this:
 void *({ size_t __len = (size_t n); void *__ret; if
 (__builtin_constant_p(size_t n) && __len >= 64) __ret = memcpy((void *dest),
 (const void *src), __len); else __ret = __builtin_memcpy((void *dest), (const
 void *src), __len); __ret; })
 {
 [memcpy implementation in decompress.c starts here]
 int i;
 const char *s = src;
 char *d = dest;
 for (i = 0; i < n; i++)
  d[i] = s[i];
 return dest;
 }
 raising the following compilation error:
 arch/mips/boot/compressed/decompress.c:46:8: error: expected identifier or '('
 before '{' token
 There are at least three possibilities to fix this issue:
 1) define _LINUX_STRING_H_ at the beginning of decompress.c to prevent
   further linux/string.h definitions and declarations from being used, and add
   an explicit strstr() declaration for linux/dynamic_debug.h
 2) remove the inclusion of linux/kernel.h because we actually use no definition
   or declaration from this header file
 3) undefine memcpy or re-define memcpy to memcpy thus resulting in picking up
   the local memcpy() implementation to this compilation unit
 This patch uses the second option which is the less intrusive one.
 Signed-off-by: Florian Fainelli <florian@openwrt.org>
 ---
 arch/mips/boot/compressed/decompress.c |    2 --
 1 file changed, 2 deletions(-)
 --- a/arch/mips/boot/compressed/decompress.c
 +++ b/arch/mips/boot/compressed/decompress.c
@@ -10,9 +10,7 @@
  * Free Software Foundation;  either version 2 of the  License, or (at your
  * option) any later version.
  */
 -
 #include <linux/types.h>
 -#include <linux/kernel.h>
 #include <asm/addrspace.h>
--- a/target/linux/generic/patches-3.13/065-iio_ad799x_backport_fixes.patch
+++ b/target/linux/generic/patches-3.13/065-iio_ad799x_backport_fixes.patch
@ -1,138 +0,0 @@
 Backport essential fixes from 3.15
 From Linux 3.10 on this driver required platform data to load, which makes it
 unusable in OpenWRT. This commit backports the following fixes:
  * Move to regulator framework for scaling
  * Set endianness of the ADC to Big endian
  * Fix device-removal path
 This commit should not be moved to newer kernel versions!
 Signed-off-by: Hartmut Knaack <knaack.h@gmx.de>
 ---
 --- a/drivers/staging/iio/adc/ad799x_core.c
 +++ b/drivers/staging/iio/adc/ad799x_core.c
@@ -179,7 +179,10 @@ static int ad799x_read_raw(struct iio_de
 			RES_MASK(chan->scan_type.realbits);
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_SCALE:
 -		*val = st->int_vref_mv;
 +		ret = regulator_get_voltage(st->vref);
 +		if (ret < 0)
 +			return ret;
 +		*val =  ret / 1000;
 		*val2 = chan->scan_type.realbits;
 		return IIO_VAL_FRACTIONAL_LOG2;
 	}
@@ -409,7 +412,13 @@ static const struct iio_event_spec ad799
 	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 	.scan_index = (_index), \
 -	.scan_type = IIO_ST('u', _realbits, 16, 12 - (_realbits)), \
 +	.scan_type = { \
 +		.sign = 'u', \
 +		.realbits = (_realbits), \
 +		.storagebits = 16, \
 +		.shift = 12 - (_realbits), \
 +		.endianness = IIO_BE, \
 +		}, \
 	.event_spec = _ev_spec, \
 	.num_event_specs = _num_ev_spec, \
 }
@@ -527,7 +536,6 @@ static int ad799x_probe(struct i2c_clien
 				   const struct i2c_device_id *id)
 {
 	int ret;
 -	struct ad799x_platform_data *pdata = client->dev.platform_data;
 	struct ad799x_state *st;
 	struct iio_dev *indio_dev;
@@ -545,17 +553,21 @@ static int ad799x_probe(struct i2c_clien
 	/* TODO: Add pdata options for filtering and bit delay */
 -	if (!pdata)
 -		return -EINVAL;
 -
 -	st->int_vref_mv = pdata->vref_mv;
 -
 	st->reg = devm_regulator_get(&client->dev, "vcc");
 -	if (!IS_ERR(st->reg)) {
 -		ret = regulator_enable(st->reg);
 -		if (ret)
 -			return ret;
 +	if (IS_ERR(st->reg))
 +		return PTR_ERR(st->reg);
 +	ret = regulator_enable(st->reg);
 +	if (ret)
 +		return ret;
 +	st->vref = devm_regulator_get(&client->dev, "vref");
 +	if (IS_ERR(st->vref)) {
 +		ret = PTR_ERR(st->vref);
 +		goto error_disable_reg;
 	}
 +	ret = regulator_enable(st->vref);
 +	if (ret)
 +		goto error_disable_reg;
 +
 	st->client = client;
 	indio_dev->dev.parent = &client->dev;
@@ -568,7 +580,7 @@ static int ad799x_probe(struct i2c_clien
 	ret = ad799x_register_ring_funcs_and_init(indio_dev);
 	if (ret)
 -		goto error_disable_reg;
 +		goto error_disable_vref;
 	if (client->irq > 0) {
 		ret = request_threaded_irq(client->irq,
@@ -592,9 +604,10 @@ error_free_irq:
 		free_irq(client->irq, indio_dev);
 error_cleanup_ring:
 	ad799x_ring_cleanup(indio_dev);
 +error_disable_vref:
 +	regulator_disable(st->vref);
 error_disable_reg:
 -	if (!IS_ERR(st->reg))
 -		regulator_disable(st->reg);
 +	regulator_disable(st->reg);
 	return ret;
 }
@@ -609,8 +622,8 @@ static int ad799x_remove(struct i2c_clie
 		free_irq(client->irq, indio_dev);
 	ad799x_ring_cleanup(indio_dev);
 -	if (!IS_ERR(st->reg))
 -		regulator_disable(st->reg);
 +	regulator_disable(st->vref);
 +	regulator_disable(st->reg);
 	kfree(st->rx_buf);
 	return 0;
 --- a/drivers/staging/iio/adc/ad799x.h
 +++ b/drivers/staging/iio/adc/ad799x.h
@@ -95,7 +95,7 @@ struct ad799x_state {
 	struct i2c_client		*client;
 	const struct ad799x_chip_info	*chip_info;
 	struct regulator		*reg;
 -	u16				int_vref_mv;
 +	struct regulator		*vref;
 	unsigned			id;
 	u16				config;
@@ -103,14 +103,6 @@ struct ad799x_state {
 	unsigned int			transfer_size;
 };
 -/*
 - * TODO: struct ad799x_platform_data needs to go into include/linux/iio
 - */
 -
 -struct ad799x_platform_data {
 -	u16				vref_mv;
 -};
 -
 #ifdef CONFIG_AD799X_RING_BUFFER
 int ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev);
 void ad799x_ring_cleanup(struct iio_dev *indio_dev);
--- a/target/linux/generic/patches-3.13/100-overlayfs.patch
+++ b/target/linux/generic/patches-3.13/100-overlayfs.patch
--- a/target/linux/generic/patches-3.13/102-ehci_hcd_ignore_oc.patch
+++ b/target/linux/generic/patches-3.13/102-ehci_hcd_ignore_oc.patch
@ -1,81 +0,0 @@
 From 1e311820ec3055e3f08e687de6564692a7cec675 Mon Sep 17 00:00:00 2001
 From: Florian Fainelli <florian@openwrt.org>
 Date: Mon, 28 Jan 2013 20:06:29 +0100
 Subject: [PATCH 11/12] USB: EHCI: add ignore_oc flag to disable overcurrent
 checking
 This patch adds an ignore_oc flag which can be set by EHCI controller
 not supporting or wanting to disable overcurrent checking. The EHCI
 platform data in include/linux/usb/ehci_pdriver.h is also augmented to
 take advantage of this new flag.
 Signed-off-by: Florian Fainelli <florian@openwrt.org>
 ---
 drivers/usb/host/ehci-hcd.c      |    2 +-
 drivers/usb/host/ehci-hub.c      |    4 ++--
 drivers/usb/host/ehci-platform.c |    1 +
 drivers/usb/host/ehci.h          |    1 +
 include/linux/usb/ehci_pdriver.h |    1 +
 5 files changed, 6 insertions(+), 3 deletions(-)
 --- a/drivers/usb/host/ehci-hcd.c
 +++ b/drivers/usb/host/ehci-hcd.c
@@ -634,7 +634,7 @@ static int ehci_run (struct usb_hcd *hcd
 		"USB %x.%x started, EHCI %x.%02x%s\n",
 		((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
 		temp >> 8, temp & 0xff,
 -		ignore_oc ? ", overcurrent ignored" : "");
 +		(ignore_oc || ehci->ignore_oc) ? ", overcurrent ignored" : "");
 	ehci_writel(ehci, INTR_MASK,
 		    &ehci->regs->intr_enable); /* Turn On Interrupts */
 --- a/drivers/usb/host/ehci-hub.c
 +++ b/drivers/usb/host/ehci-hub.c
@@ -641,7 +641,7 @@ ehci_hub_status_data (struct usb_hcd *hc
 	 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
 	 * PORT_POWER; that's surprising, but maybe within-spec.
 	 */
 -	if (!ignore_oc)
 +	if (!ignore_oc && !ehci->ignore_oc)
 		mask = PORT_CSC | PORT_PEC | PORT_OCC;
 	else
 		mask = PORT_CSC | PORT_PEC;
@@ -1001,7 +1001,7 @@ static int ehci_hub_control (
 		if (temp & PORT_PEC)
 			status |= USB_PORT_STAT_C_ENABLE << 16;
 -		if ((temp & PORT_OCC) && !ignore_oc){
 +		if ((temp & PORT_OCC) && (!ignore_oc && !ehci->ignore_oc)){
 			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
 			/*
 --- a/drivers/usb/host/ehci-platform.c
 +++ b/drivers/usb/host/ehci-platform.c
@@ -47,6 +47,7 @@ static int ehci_platform_reset(struct us
 	ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
 	ehci->big_endian_desc = pdata->big_endian_desc;
 	ehci->big_endian_mmio = pdata->big_endian_mmio;
 +	ehci->ignore_oc = pdata->ignore_oc;
 	if (pdata->pre_setup) {
 		retval = pdata->pre_setup(hcd);
 --- a/drivers/usb/host/ehci.h
 +++ b/drivers/usb/host/ehci.h
@@ -226,6 +226,7 @@ struct ehci_hcd {			/* one per controlle
 	unsigned		frame_index_bug:1; /* MosChip (AKA NetMos) */
 	unsigned		need_oc_pp_cycle:1; /* MPC834X port power */
 	unsigned		imx28_write_fix:1; /* For Freescale i.MX28 */
 +	unsigned		ignore_oc:1;
 	/* required for usb32 quirk */
 	#define OHCI_CTRL_HCFS          (3 << 6)
 --- a/include/linux/usb/ehci_pdriver.h
 +++ b/include/linux/usb/ehci_pdriver.h
@@ -45,6 +45,7 @@ struct usb_ehci_pdata {
 	unsigned	big_endian_desc:1;
 	unsigned	big_endian_mmio:1;
 	unsigned	no_io_watchdog:1;
 +	unsigned	ignore_oc:1;
 	/* Turn on all power and clocks */
 	int (*power_on)(struct platform_device *pdev);
--- a/target/linux/generic/patches-3.13/120-bridge_allow_receiption_on_disabled_port.patch
+++ b/target/linux/generic/patches-3.13/120-bridge_allow_receiption_on_disabled_port.patch
@ -1,54 +0,0 @@
 From: Stephen Hemminger <stephen@networkplumber.org>
 Subject: bridge: allow receiption on disabled port
 When an ethernet device is enslaved to a bridge, and the bridge STP
 detects loss of carrier (or operational state down), then normally
 packet receiption is blocked.
 This breaks control applications like WPA which maybe expecting to
 receive packets to negotiate to bring link up. The bridge needs to
 block forwarding packets from these disabled ports, but there is no
 hard requirement to not allow local packet delivery.
 Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 --- a/net/bridge/br_input.c
 +++ b/net/bridge/br_input.c
@@ -144,11 +144,13 @@ drop:
 static int br_handle_local_finish(struct sk_buff *skb)
 {
 	struct net_bridge_port *p = br_port_get_rcu(skb->dev);
 -	u16 vid = 0;
 +	if (p->state != BR_STATE_DISABLED) {
 +		u16 vid = 0;
 -	br_vlan_get_tag(skb, &vid);
 -	if (p->flags & BR_LEARNING)
 -		br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid);
 +		br_vlan_get_tag(skb, &vid);
 +		if (p->flags & BR_LEARNING)
 +			br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid);
 +	}
 	return 0;	 /* process further */
 }
@@ -218,6 +220,18 @@ rx_handler_result_t br_handle_frame(stru
 forward:
 	switch (p->state) {
 +	case BR_STATE_DISABLED:
 +		if (ether_addr_equal(p->br->dev->dev_addr, dest))
 +			skb->pkt_type = PACKET_HOST;
 +
 +		if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
 +			br_handle_local_finish))
 +			break;
 +
 +		BR_INPUT_SKB_CB(skb)->brdev = p->br->dev;
 +		br_pass_frame_up(skb);
 +		break;
 +
 	case BR_STATE_FORWARDING:
 		rhook = rcu_dereference(br_should_route_hook);
 		if (rhook) {
--- a/target/linux/generic/patches-3.13/131-improve_noncoherent_dma_checks.patch
+++ b/target/linux/generic/patches-3.13/131-improve_noncoherent_dma_checks.patch
@ -1,91 +0,0 @@
 From d593f8fc627f8cdaee9c14e4d22b0770a09baaf1 Mon Sep 17 00:00:00 2001
 From: Felix Fietkau <nbd@openwrt.org>
 Date: Thu, 15 Aug 2013 10:47:47 +0200
 Subject: [PATCH] MIPS: improve checks for noncoherent DMA
 Only one MIPS development board actually supports enabling/disabling DMA
 coherency at runtime, so it's not a good idea to push the overhead of
 checking that configuration setting onto every other supported target as
 well.
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 ---
 arch/mips/Kconfig                                  | 6 +++++-
 arch/mips/include/asm/dma-coherence.h              | 7 +++++++
 arch/mips/include/asm/mach-generic/dma-coherence.h | 4 ----
 arch/mips/mm/dma-default.c                         | 2 ++
 4 files changed, 14 insertions(+), 5 deletions(-)
 --- a/arch/mips/Kconfig
 +++ b/arch/mips/Kconfig
@@ -303,7 +303,7 @@ config MIPS_MALTA
 	select CEVT_R4K
 	select CSRC_R4K
 	select CSRC_GIC
 -	select DMA_NONCOHERENT
 +	select DMA_MAYBE_COHERENT
 	select GENERIC_ISA_DMA
 	select HAVE_PCSPKR_PLATFORM
 	select IRQ_CPU
@@ -895,6 +895,10 @@ config FW_CFE
 config ARCH_DMA_ADDR_T_64BIT
 	def_bool (HIGHMEM && 64BIT_PHYS_ADDR) || 64BIT
 +config DMA_MAYBE_COHERENT
 +	select DMA_NONCOHERENT
 +	bool
 +
 config DMA_COHERENT
 	bool
 --- a/arch/mips/include/asm/dma-coherence.h
 +++ b/arch/mips/include/asm/dma-coherence.h
@@ -9,7 +9,16 @@
 #ifndef __ASM_DMA_COHERENCE_H
 #define __ASM_DMA_COHERENCE_H
 +#ifdef CONFIG_DMA_MAYBE_COHERENT
 extern int coherentio;
 extern int hw_coherentio;
 +#else
 +#ifdef CONFIG_DMA_COHERENT
 +#define coherentio	1
 +#else
 +#define coherentio	0
 +#endif
 +#define hw_coherentio	0
 +#endif /* CONFIG_DMA_MAYBE_COHERENT */
 #endif
 --- a/arch/mips/include/asm/mach-generic/dma-coherence.h
 +++ b/arch/mips/include/asm/mach-generic/dma-coherence.h
@@ -49,11 +49,7 @@ static inline int plat_dma_supported(str
 static inline int plat_device_is_coherent(struct device *dev)
 {
 -#ifdef CONFIG_DMA_COHERENT
 -	return 1;
 -#else
 	return coherentio;
 -#endif
 }
 #ifdef CONFIG_SWIOTLB
 --- a/arch/mips/mm/dma-default.c
 +++ b/arch/mips/mm/dma-default.c
@@ -23,6 +23,7 @@
 #include <dma-coherence.h>
 +#ifdef CONFIG_DMA_MAYBE_COHERENT
 int coherentio = 0;	/* User defined DMA coherency from command line. */
 EXPORT_SYMBOL_GPL(coherentio);
 int hw_coherentio = 0;	/* Actual hardware supported DMA coherency setting. */
@@ -42,6 +43,7 @@ static int __init setnocoherentio(char *
 	return 0;
 }
 early_param("nocoherentio", setnocoherentio);
 +#endif
 static inline struct page *dma_addr_to_page(struct device *dev,
 	dma_addr_t dma_addr)
--- a/target/linux/generic/patches-3.13/132-mips_inline_dma_ops.patch
+++ b/target/linux/generic/patches-3.13/132-mips_inline_dma_ops.patch
@ -1,687 +0,0 @@
 From 2c58080407554e1bac8fd50d23cb02420524caed Mon Sep 17 00:00:00 2001
 From: Felix Fietkau <nbd@openwrt.org>
 Date: Mon, 12 Aug 2013 12:50:22 +0200
 Subject: [PATCH] MIPS: partially inline dma ops
 Several DMA ops are no-op on many platforms, and the indirection through
 the mips_dma_map_ops function table is causing the compiler to emit
 unnecessary code.
 Inlining visibly improves network performance in my tests (on a 24Kc
 based system), and also slightly reduces code size of a few drivers.
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 ---
 arch/mips/Kconfig                   |   4 +
 arch/mips/include/asm/dma-mapping.h | 360 +++++++++++++++++++++++++++++++++++-
 arch/mips/mm/dma-default.c          | 163 ++--------------
 3 files changed, 373 insertions(+), 154 deletions(-)
 --- a/arch/mips/Kconfig
 +++ b/arch/mips/Kconfig
@@ -1377,6 +1377,7 @@ config CPU_CAVIUM_OCTEON
 	select LIBFDT
 	select USE_OF
 	select USB_EHCI_BIG_ENDIAN_MMIO
 +	select SYS_HAS_DMA_OPS
 	help
 	  The Cavium Octeon processor is a highly integrated chip containing
 	  many ethernet hardware widgets for networking tasks. The processor
@@ -1599,6 +1600,9 @@ config SYS_HAS_CPU_XLR
 config SYS_HAS_CPU_XLP
 	bool
 +config SYS_HAS_DMA_OPS
 +	bool
 +
 #
 # CPU may reorder R->R, R->W, W->R, W->W
 # Reordering beyond LL and SC is handled in WEAK_REORDERING_BEYOND_LLSC
 --- a/arch/mips/include/asm/dma-mapping.h
 +++ b/arch/mips/include/asm/dma-mapping.h
@@ -1,9 +1,16 @@
 #ifndef _ASM_DMA_MAPPING_H
 #define _ASM_DMA_MAPPING_H
 +#include <linux/kmemcheck.h>
 +#include <linux/bug.h>
 +#include <linux/scatterlist.h>
 +#include <linux/dma-debug.h>
 +#include <linux/dma-attrs.h>
 +
 #include <asm/scatterlist.h>
 #include <asm/dma-coherence.h>
 #include <asm/cache.h>
 +#include <asm/cpu-type.h>
 #include <asm-generic/dma-coherent.h>
 #ifndef CONFIG_SGI_IP27 /* Kludge to fix 2.6.39 build for IP27 */
@@ -12,12 +19,48 @@
 extern struct dma_map_ops *mips_dma_map_ops;
 +void __dma_sync(struct page *page, unsigned long offset, size_t size,
 +		enum dma_data_direction direction);
 +void *mips_dma_alloc_coherent(struct device *dev, size_t size,
 +			      dma_addr_t *dma_handle, gfp_t gfp,
 +			      struct dma_attrs *attrs);
 +void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 +			    dma_addr_t dma_handle, struct dma_attrs *attrs);
 +
 static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 {
 +#ifdef CONFIG_SYS_HAS_DMA_OPS
 	if (dev && dev->archdata.dma_ops)
 		return dev->archdata.dma_ops;
 	else
 		return mips_dma_map_ops;
 +#else
 +	return NULL;
 +#endif
 +}
 +
 +/*
 + * Warning on the terminology - Linux calls an uncached area coherent;
 + * MIPS terminology calls memory areas with hardware maintained coherency
 + * coherent.
 + */
 +
 +static inline int cpu_needs_post_dma_flush(struct device *dev)
 +{
 +#ifndef CONFIG_SYS_HAS_CPU_R10000
 +	return 0;
 +#endif
 +	return !plat_device_is_coherent(dev) &&
 +	       (boot_cpu_type() == CPU_R10000 ||
 +		boot_cpu_type() == CPU_R12000 ||
 +		boot_cpu_type() == CPU_BMIPS5000);
 +}
 +
 +static inline struct page *dma_addr_to_page(struct device *dev,
 +	dma_addr_t dma_addr)
 +{
 +	return pfn_to_page(
 +		plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT);
 }
 static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
@@ -30,12 +73,312 @@ static inline bool dma_capable(struct de
 static inline void dma_mark_clean(void *addr, size_t size) {}
 -#include <asm-generic/dma-mapping-common.h>
 +static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
 +					      size_t size,
 +					      enum dma_data_direction dir,
 +					      struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	unsigned long offset = (unsigned long)ptr & ~PAGE_MASK;
 +	struct page *page = virt_to_page(ptr);
 +	dma_addr_t addr;
 +
 +	kmemcheck_mark_initialized(ptr, size);
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops) {
 +		addr = ops->map_page(dev, page, offset, size, dir, attrs);
 +	} else {
 +		if (!plat_device_is_coherent(dev))
 +			__dma_sync(page, offset, size, dir);
 +
 +		addr = plat_map_dma_mem_page(dev, page) + offset;
 +	}
 +	debug_dma_map_page(dev, page, offset, size, dir, addr, true);
 +	return addr;
 +}
 +
 +static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
 +					  size_t size,
 +					  enum dma_data_direction dir,
 +					  struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops) {
 +		ops->unmap_page(dev, addr, size, dir, attrs);
 +	} else {
 +		if (cpu_needs_post_dma_flush(dev))
 +			__dma_sync(dma_addr_to_page(dev, addr),
 +				   addr & ~PAGE_MASK, size, dir);
 +
 +		plat_unmap_dma_mem(dev, addr, size, dir);
 +	}
 +	debug_dma_unmap_page(dev, addr, size, dir, true);
 +}
 +
 +static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
 +				   int nents, enum dma_data_direction dir,
 +				   struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	int i, ents;
 +	struct scatterlist *s;
 +
 +	for_each_sg(sg, s, nents, i)
 +		kmemcheck_mark_initialized(sg_virt(s), s->length);
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops) {
 +		ents = ops->map_sg(dev, sg, nents, dir, attrs);
 +	} else {
 +		for_each_sg(sg, s, nents, i) {
 +			struct page *page = sg_page(s);
 +
 +			if (!plat_device_is_coherent(dev))
 +				__dma_sync(page, s->offset, s->length, dir);
 +#ifdef CONFIG_NEED_SG_DMA_LENGTH
 +			s->dma_length = s->length;
 +#endif
 +			s->dma_address =
 +				plat_map_dma_mem_page(dev, page) + s->offset;
 +		}
 +		ents = nents;
 +	}
 +	debug_dma_map_sg(dev, sg, nents, ents, dir);
 +
 +	return ents;
 +}
 +
 +static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
 +				      int nents, enum dma_data_direction dir,
 +				      struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	struct scatterlist *s;
 +	int i;
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	debug_dma_unmap_sg(dev, sg, nents, dir);
 +	if (ops) {
 +		ops->unmap_sg(dev, sg, nents, dir, attrs);
 +		return;
 +	}
 +
 +	for_each_sg(sg, s, nents, i) {
 +		if (!plat_device_is_coherent(dev) && dir != DMA_TO_DEVICE)
 +			__dma_sync(sg_page(s), s->offset, s->length, dir);
 +		plat_unmap_dma_mem(dev, s->dma_address, s->length, dir);
 +	}
 +}
 +
 +static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
 +				      size_t offset, size_t size,
 +				      enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	dma_addr_t addr;
 +
 +	kmemcheck_mark_initialized(page_address(page) + offset, size);
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops) {
 +		addr = ops->map_page(dev, page, offset, size, dir, NULL);
 +	} else {
 +		if (!plat_device_is_coherent(dev))
 +			__dma_sync(page, offset, size, dir);
 +
 +		addr = plat_map_dma_mem_page(dev, page) + offset;
 +	}
 +	debug_dma_map_page(dev, page, offset, size, dir, addr, false);
 +
 +	return addr;
 +}
 +
 +static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
 +				  size_t size, enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops) {
 +		ops->unmap_page(dev, addr, size, dir, NULL);
 +	} else {
 +		if (cpu_needs_post_dma_flush(dev))
 +			__dma_sync(dma_addr_to_page(dev, addr),
 +				   addr & ~PAGE_MASK, size, dir);
 +
 +		plat_unmap_dma_mem(dev, addr, size, dir);
 +	}
 +	debug_dma_unmap_page(dev, addr, size, dir, false);
 +}
 +
 +static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
 +					   size_t size,
 +					   enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_single_for_cpu(dev, addr, size, dir);
 +	else if (cpu_needs_post_dma_flush(dev))
 +		__dma_sync(dma_addr_to_page(dev, addr),
 +			   addr & ~PAGE_MASK, size, dir);
 +	debug_dma_sync_single_for_cpu(dev, addr, size, dir);
 +}
 +
 +static inline void dma_sync_single_for_device(struct device *dev,
 +					      dma_addr_t addr, size_t size,
 +					      enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_single_for_device(dev, addr, size, dir);
 +	else if (!plat_device_is_coherent(dev))
 +		__dma_sync(dma_addr_to_page(dev, addr),
 +			   addr & ~PAGE_MASK, size, dir);
 +	debug_dma_sync_single_for_device(dev, addr, size, dir);
 +}
 +
 +static inline void dma_sync_single_range_for_cpu(struct device *dev,
 +						 dma_addr_t addr,
 +						 unsigned long offset,
 +						 size_t size,
 +						 enum dma_data_direction dir)
 +{
 +	const struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_single_for_cpu(dev, addr + offset, size, dir);
 +	else if (cpu_needs_post_dma_flush(dev))
 +		__dma_sync(dma_addr_to_page(dev, addr + offset),
 +			   (addr + offset) & ~PAGE_MASK, size, dir);
 +	debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
 +}
 +
 +static inline void dma_sync_single_range_for_device(struct device *dev,
 +						    dma_addr_t addr,
 +						    unsigned long offset,
 +						    size_t size,
 +						    enum dma_data_direction dir)
 +{
 +	const struct dma_map_ops *ops = get_dma_ops(dev);
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_single_for_device(dev, addr + offset, size, dir);
 +	else if (!plat_device_is_coherent(dev))
 +		__dma_sync(dma_addr_to_page(dev, addr + offset),
 +			   (addr + offset) & ~PAGE_MASK, size, dir);
 +	debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
 +}
 +
 +static inline void
 +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
 +		    int nelems, enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	struct scatterlist *s;
 +	int i;
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_sg_for_cpu(dev, sg, nelems, dir);
 +	else if (cpu_needs_post_dma_flush(dev)) {
 +		for_each_sg(sg, s, nelems, i)
 +			__dma_sync(sg_page(s), s->offset, s->length, dir);
 +	}
 +	debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
 +}
 +
 +static inline void
 +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
 +		       int nelems, enum dma_data_direction dir)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	struct scatterlist *s;
 +	int i;
 +
 +	BUG_ON(!valid_dma_direction(dir));
 +	if (ops)
 +		ops->sync_sg_for_device(dev, sg, nelems, dir);
 +	else if (!plat_device_is_coherent(dev)) {
 +		for_each_sg(sg, s, nelems, i)
 +			__dma_sync(sg_page(s), s->offset, s->length, dir);
 +	}
 +	debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
 +
 +}
 +
 +#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
 +#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
 +#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
 +#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
 +
 +extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
 +			   void *cpu_addr, dma_addr_t dma_addr, size_t size);
 +
 +/**
 + * dma_mmap_attrs - map a coherent DMA allocation into user space
 + * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
 + * @vma: vm_area_struct describing requested user mapping
 + * @cpu_addr: kernel CPU-view address returned from dma_alloc_attrs
 + * @handle: device-view address returned from dma_alloc_attrs
 + * @size: size of memory originally requested in dma_alloc_attrs
 + * @attrs: attributes of mapping properties requested in dma_alloc_attrs
 + *
 + * Map a coherent DMA buffer previously allocated by dma_alloc_attrs
 + * into user space.  The coherent DMA buffer must not be freed by the
 + * driver until the user space mapping has been released.
 + */
 +static inline int
 +dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
 +	       dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	BUG_ON(!ops);
 +	if (ops && ops->mmap)
 +		return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
 +	return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
 +}
 +
 +#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
 +
 +static inline int dma_mmap_writecombine(struct device *dev, struct vm_area_struct *vma,
 +		      void *cpu_addr, dma_addr_t dma_addr, size_t size)
 +{
 +	DEFINE_DMA_ATTRS(attrs);
 +	dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
 +	return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
 +}
 +
 +int
 +dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
 +		       void *cpu_addr, dma_addr_t dma_addr, size_t size);
 +
 +static inline int
 +dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
 +		      dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
 +{
 +	struct dma_map_ops *ops = get_dma_ops(dev);
 +	BUG_ON(!ops);
 +	if (ops && ops->get_sgtable)
 +		return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
 +					attrs);
 +	return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
 +}
 +
 +#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL)
 +
 static inline int dma_supported(struct device *dev, u64 mask)
 {
 	struct dma_map_ops *ops = get_dma_ops(dev);
 -	return ops->dma_supported(dev, mask);
 +	if (ops)
 +		return ops->dma_supported(dev, mask);
 +	return plat_dma_supported(dev, mask);
 }
 static inline int dma_mapping_error(struct device *dev, u64 mask)
@@ -43,7 +386,9 @@ static inline int dma_mapping_error(stru
 	struct dma_map_ops *ops = get_dma_ops(dev);
 	debug_dma_mapping_error(dev, mask);
 -	return ops->mapping_error(dev, mask);
 +	if (ops)
 +		return ops->mapping_error(dev, mask);
 +	return 0;
 }
 static inline int
@@ -69,7 +414,11 @@ static inline void *dma_alloc_attrs(stru
 	void *ret;
 	struct dma_map_ops *ops = get_dma_ops(dev);
 -	ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
 +	if (ops)
 +		ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
 +	else
 +		ret = mips_dma_alloc_coherent(dev, size, dma_handle, gfp,
 +					      attrs);
 	debug_dma_alloc_coherent(dev, size, *dma_handle, ret);
@@ -84,7 +433,10 @@ static inline void dma_free_attrs(struct
 {
 	struct dma_map_ops *ops = get_dma_ops(dev);
 -	ops->free(dev, size, vaddr, dma_handle, attrs);
 +	if (ops)
 +		ops->free(dev, size, vaddr, dma_handle, attrs);
 +	else
 +		mips_dma_free_coherent(dev, size, vaddr, dma_handle, attrs);
 	debug_dma_free_coherent(dev, size, vaddr, dma_handle);
 }
 --- a/arch/mips/mm/dma-default.c
 +++ b/arch/mips/mm/dma-default.c
@@ -25,7 +25,7 @@
 #ifdef CONFIG_DMA_MAYBE_COHERENT
 int coherentio = 0;	/* User defined DMA coherency from command line. */
 -EXPORT_SYMBOL_GPL(coherentio);
 +EXPORT_SYMBOL(coherentio);
 int hw_coherentio = 0;	/* Actual hardware supported DMA coherency setting. */
 static int __init setcoherentio(char *str)
@@ -45,30 +45,6 @@ static int __init setnocoherentio(char *
 early_param("nocoherentio", setnocoherentio);
 #endif
 -static inline struct page *dma_addr_to_page(struct device *dev,
 -	dma_addr_t dma_addr)
 -{
 -	return pfn_to_page(
 -		plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT);
 -}
 -
 -/*
 - * The affected CPUs below in 'cpu_needs_post_dma_flush()' can
 - * speculatively fill random cachelines with stale data at any time,
 - * requiring an extra flush post-DMA.
 - *
 - * Warning on the terminology - Linux calls an uncached area coherent;
 - * MIPS terminology calls memory areas with hardware maintained coherency
 - * coherent.
 - */
 -static inline int cpu_needs_post_dma_flush(struct device *dev)
 -{
 -	return !plat_device_is_coherent(dev) &&
 -	       (boot_cpu_type() == CPU_R10000 ||
 -		boot_cpu_type() == CPU_R12000 ||
 -		boot_cpu_type() == CPU_BMIPS5000);
 -}
 -
 static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp)
 {
 	gfp_t dma_flag;
@@ -124,8 +100,9 @@ void *dma_alloc_noncoherent(struct devic
 }
 EXPORT_SYMBOL(dma_alloc_noncoherent);
 -static void *mips_dma_alloc_coherent(struct device *dev, size_t size,
 -	dma_addr_t * dma_handle, gfp_t gfp, struct dma_attrs *attrs)
 +void *mips_dma_alloc_coherent(struct device *dev, size_t size,
 +			      dma_addr_t *dma_handle, gfp_t gfp,
 +			      struct dma_attrs *attrs)
 {
 	void *ret;
@@ -149,6 +126,7 @@ static void *mips_dma_alloc_coherent(str
 	return ret;
 }
 +EXPORT_SYMBOL(mips_dma_alloc_coherent);
 void dma_free_noncoherent(struct device *dev, size_t size, void *vaddr,
@@ -159,8 +137,8 @@ void dma_free_noncoherent(struct device
 }
 EXPORT_SYMBOL(dma_free_noncoherent);
 -static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 -	dma_addr_t dma_handle, struct dma_attrs *attrs)
 +void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 +			    dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
 	unsigned long addr = (unsigned long) vaddr;
 	int order = get_order(size);
@@ -175,6 +153,7 @@ static void mips_dma_free_coherent(struc
 	free_pages(addr, get_order(size));
 }
 +EXPORT_SYMBOL(mips_dma_free_coherent);
 static inline void __dma_sync_virtual(void *addr, size_t size,
 	enum dma_data_direction direction)
@@ -203,8 +182,8 @@ static inline void __dma_sync_virtual(vo
  * If highmem is not configured then the bulk of this loop gets
  * optimized out.
  */
 -static inline void __dma_sync(struct page *page,
 -	unsigned long offset, size_t size, enum dma_data_direction direction)
 +void __dma_sync(struct page *page, unsigned long offset, size_t size,
 +		enum dma_data_direction direction)
 {
 	size_t left = size;
@@ -233,108 +212,7 @@ static inline void __dma_sync(struct pag
 		left -= len;
 	} while (left);
 }
 -
 -static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
 -	size_t size, enum dma_data_direction direction, struct dma_attrs *attrs)
 -{
 -	if (cpu_needs_post_dma_flush(dev))
 -		__dma_sync(dma_addr_to_page(dev, dma_addr),
 -			   dma_addr & ~PAGE_MASK, size, direction);
 -
 -	plat_unmap_dma_mem(dev, dma_addr, size, direction);
 -}
 -
 -static int mips_dma_map_sg(struct device *dev, struct scatterlist *sg,
 -	int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
 -{
 -	int i;
 -
 -	for (i = 0; i < nents; i++, sg++) {
 -		if (!plat_device_is_coherent(dev))
 -			__dma_sync(sg_page(sg), sg->offset, sg->length,
 -				   direction);
 -#ifdef CONFIG_NEED_SG_DMA_LENGTH
 -		sg->dma_length = sg->length;
 -#endif
 -		sg->dma_address = plat_map_dma_mem_page(dev, sg_page(sg)) +
 -				  sg->offset;
 -	}
 -
 -	return nents;
 -}
 -
 -static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page,
 -	unsigned long offset, size_t size, enum dma_data_direction direction,
 -	struct dma_attrs *attrs)
 -{
 -	if (!plat_device_is_coherent(dev))
 -		__dma_sync(page, offset, size, direction);
 -
 -	return plat_map_dma_mem_page(dev, page) + offset;
 -}
 -
 -static void mips_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
 -	int nhwentries, enum dma_data_direction direction,
 -	struct dma_attrs *attrs)
 -{
 -	int i;
 -
 -	for (i = 0; i < nhwentries; i++, sg++) {
 -		if (!plat_device_is_coherent(dev) &&
 -		    direction != DMA_TO_DEVICE)
 -			__dma_sync(sg_page(sg), sg->offset, sg->length,
 -				   direction);
 -		plat_unmap_dma_mem(dev, sg->dma_address, sg->length, direction);
 -	}
 -}
 -
 -static void mips_dma_sync_single_for_cpu(struct device *dev,
 -	dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
 -{
 -	if (cpu_needs_post_dma_flush(dev))
 -		__dma_sync(dma_addr_to_page(dev, dma_handle),
 -			   dma_handle & ~PAGE_MASK, size, direction);
 -}
 -
 -static void mips_dma_sync_single_for_device(struct device *dev,
 -	dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
 -{
 -	if (!plat_device_is_coherent(dev))
 -		__dma_sync(dma_addr_to_page(dev, dma_handle),
 -			   dma_handle & ~PAGE_MASK, size, direction);
 -}
 -
 -static void mips_dma_sync_sg_for_cpu(struct device *dev,
 -	struct scatterlist *sg, int nelems, enum dma_data_direction direction)
 -{
 -	int i;
 -
 -	if (cpu_needs_post_dma_flush(dev))
 -		for (i = 0; i < nelems; i++, sg++)
 -			__dma_sync(sg_page(sg), sg->offset, sg->length,
 -				   direction);
 -}
 -
 -static void mips_dma_sync_sg_for_device(struct device *dev,
 -	struct scatterlist *sg, int nelems, enum dma_data_direction direction)
 -{
 -	int i;
 -
 -	if (!plat_device_is_coherent(dev))
 -		for (i = 0; i < nelems; i++, sg++)
 -			__dma_sync(sg_page(sg), sg->offset, sg->length,
 -				   direction);
 -}
 -
 -int mips_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 -{
 -	return 0;
 -}
 -
 -int mips_dma_supported(struct device *dev, u64 mask)
 -{
 -	return plat_dma_supported(dev, mask);
 -}
 +EXPORT_SYMBOL(__dma_sync);
 void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 			 enum dma_data_direction direction)
@@ -347,23 +225,10 @@ void dma_cache_sync(struct device *dev,
 EXPORT_SYMBOL(dma_cache_sync);
 -static struct dma_map_ops mips_default_dma_map_ops = {
 -	.alloc = mips_dma_alloc_coherent,
 -	.free = mips_dma_free_coherent,
 -	.map_page = mips_dma_map_page,
 -	.unmap_page = mips_dma_unmap_page,
 -	.map_sg = mips_dma_map_sg,
 -	.unmap_sg = mips_dma_unmap_sg,
 -	.sync_single_for_cpu = mips_dma_sync_single_for_cpu,
 -	.sync_single_for_device = mips_dma_sync_single_for_device,
 -	.sync_sg_for_cpu = mips_dma_sync_sg_for_cpu,
 -	.sync_sg_for_device = mips_dma_sync_sg_for_device,
 -	.mapping_error = mips_dma_mapping_error,
 -	.dma_supported = mips_dma_supported
 -};
 -
 -struct dma_map_ops *mips_dma_map_ops = &mips_default_dma_map_ops;
 +#ifdef CONFIG_SYS_HAS_DMA_OPS
 +struct dma_map_ops *mips_dma_map_ops = NULL;
 EXPORT_SYMBOL(mips_dma_map_ops);
 +#endif
 #define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
--- a/target/linux/generic/patches-3.13/200-fix_localversion.patch
+++ b/target/linux/generic/patches-3.13/200-fix_localversion.patch
@ -1,11 +0,0 @@
 --- a/scripts/setlocalversion
 +++ b/scripts/setlocalversion
@@ -164,7 +164,7 @@ else
 	# annotated or signed tagged state (as git describe only
 	# looks at signed or annotated tags - git tag -a/-s) and
 	# LOCALVERSION= is not specified
 -	if test "${LOCALVERSION+set}" != "set"; then
 +	if test "${CONFIG_LOCALVERSION+set}" != "set"; then
 		scm=$(scm_version --short)
 		res="$res${scm:++}"
 	fi
--- a/target/linux/generic/patches-3.13/201-extra_optimization.patch
+++ b/target/linux/generic/patches-3.13/201-extra_optimization.patch
@ -1,14 +0,0 @@
 --- a/Makefile
 +++ b/Makefile
@@ -574,9 +574,9 @@ endif # $(dot-config)
 all: vmlinux
 ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
 -KBUILD_CFLAGS	+= -Os $(call cc-disable-warning,maybe-uninitialized,)
 +KBUILD_CFLAGS	+= -Os $(EXTRA_OPTIMIZATION) $(call cc-disable-warning,maybe-uninitialized,)
 else
 -KBUILD_CFLAGS	+= -O2
 +KBUILD_CFLAGS	+= -O2 -fno-reorder-blocks -fno-tree-ch $(EXTRA_OPTIMIZATION)
 endif
 include $(srctree)/arch/$(SRCARCH)/Makefile
--- a/target/linux/generic/patches-3.13/202-reduce_module_size.patch
+++ b/target/linux/generic/patches-3.13/202-reduce_module_size.patch
@ -1,11 +0,0 @@
 --- a/Makefile
 +++ b/Makefile
@@ -382,7 +382,7 @@ KBUILD_CFLAGS_KERNEL :=
 KBUILD_AFLAGS   := -D__ASSEMBLY__
 KBUILD_AFLAGS_MODULE  := -DMODULE
 KBUILD_CFLAGS_MODULE  := -DMODULE
 -KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds
 +KBUILD_LDFLAGS_MODULE = -T $(srctree)/scripts/module-common.lds $(if $(CONFIG_PROFILING),,-s)
 # Read KERNELRELEASE from include/config/kernel.release (if it exists)
 KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)
--- a/target/linux/generic/patches-3.13/203-kallsyms_uncompressed.patch
+++ b/target/linux/generic/patches-3.13/203-kallsyms_uncompressed.patch
@ -1,108 +0,0 @@
 --- a/scripts/kallsyms.c
 +++ b/scripts/kallsyms.c
@@ -54,6 +54,7 @@ static struct text_range text_ranges[] =
 static struct sym_entry *table;
 static unsigned int table_size, table_cnt;
 static int all_symbols = 0;
 +static int uncompressed = 0;
 static char symbol_prefix_char = '\0';
 static unsigned long long kernel_start_addr = 0;
@@ -373,6 +374,9 @@ static void write_src(void)
 	free(markers);
 +	if (uncompressed)
 +		return;
 +
 	output_label("kallsyms_token_table");
 	off = 0;
 	for (i = 0; i < 256; i++) {
@@ -431,6 +435,9 @@ static void *find_token(unsigned char *s
 {
 	int i;
 +	if (uncompressed)
 +		return NULL;
 +
 	for (i = 0; i < len - 1; i++) {
 		if (str[i] == token[0] && str[i+1] == token[1])
 			return &str[i];
@@ -503,6 +510,9 @@ static void optimize_result(void)
 {
 	int i, best;
 +	if (uncompressed)
 +		return;
 +
 	/* using the '\0' symbol last allows compress_symbols to use standard
 	 * fast string functions */
 	for (i = 255; i >= 0; i--) {
@@ -662,7 +672,9 @@ int main(int argc, char **argv)
 			} else if (strncmp(argv[i], "--page-offset=", 14) == 0) {
 				const char *p = &argv[i][14];
 				kernel_start_addr = strtoull(p, NULL, 16);
 -			} else
 +			} else if (strcmp(argv[i], "--uncompressed") == 0)
 +				uncompressed = 1;
 +			else
 				usage();
 		}
 	} else if (argc != 1)
 --- a/init/Kconfig
 +++ b/init/Kconfig
@@ -1282,6 +1282,17 @@ config SYSCTL_ARCH_UNALIGN_ALLOW
 	  the unaligned access emulation.
 	  see arch/parisc/kernel/unaligned.c for reference
 +config KALLSYMS_UNCOMPRESSED
 +	bool "Keep kallsyms uncompressed"
 +	depends on KALLSYMS
 +	help
 +		Normally kallsyms contains compressed symbols (using a token table),
 +		reducing the uncompressed kernel image size. Keeping the symbol table
 +		uncompressed significantly improves the size of this part in compressed
 +		kernel images.
 +
 +		Say N unless you need compressed kernel images to be small.
 +
 config HAVE_PCSPKR_PLATFORM
 	bool
 --- a/scripts/link-vmlinux.sh
 +++ b/scripts/link-vmlinux.sh
@@ -86,6 +86,10 @@ kallsyms()
 		kallsymopt="${kallsymopt} --page-offset=$CONFIG_PAGE_OFFSET"
 	fi
 +	if [ -n "${CONFIG_KALLSYMS_UNCOMPRESSED}" ]; then
 +		kallsymopt="${kallsymopt} --uncompressed"
 +	fi
 +
 	local aflags="${KBUILD_AFLAGS} ${KBUILD_AFLAGS_KERNEL}               \
 		      ${NOSTDINC_FLAGS} ${LINUXINCLUDE} ${KBUILD_CPPFLAGS}"
 --- a/kernel/kallsyms.c
 +++ b/kernel/kallsyms.c
@@ -108,6 +108,11 @@ static unsigned int kallsyms_expand_symb
 	 * For every byte on the compressed symbol data, copy the table
 	 * entry for that byte.
 	 */
 +#ifdef CONFIG_KALLSYMS_UNCOMPRESSED
 +	memcpy(result, data + 1, len - 1);
 +	result += len - 1;
 +	len = 0;
 +#endif
 	while (len) {
 		tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
 		data++;
@@ -140,6 +145,9 @@ tail:
  */
 static char kallsyms_get_symbol_type(unsigned int off)
 {
 +#ifdef CONFIG_KALLSYMS_UNCOMPRESSED
 +	return kallsyms_names[off + 1];
 +#endif
 	/*
 	 * Get just the first code, look it up in the token table,
 	 * and return the first char from this token.
--- a/target/linux/generic/patches-3.13/204-module_strip.patch
+++ b/target/linux/generic/patches-3.13/204-module_strip.patch
@ -1,200 +0,0 @@
 From: Felix Fietkau <nbd@openwrt.org>
 Subject: [PATCH] build: add a hack for removing non-essential module info
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 ---
 --- a/include/linux/module.h
 +++ b/include/linux/module.h
@@ -83,7 +83,7 @@ void sort_extable(struct exception_table
 void sort_main_extable(void);
 void trim_init_extable(struct module *m);
 -#ifdef MODULE
 +#if defined(MODULE) && !defined(CONFIG_MODULE_STRIPPED)
 #define MODULE_GENERIC_TABLE(gtype,name)			\
 extern const struct gtype##_id __mod_##gtype##_table		\
   __attribute__ ((unused, alias(__stringify(name))))
@@ -94,9 +94,10 @@ extern const struct gtype##_id __mod_##g
 /* Generic info of form tag = "info" */
 #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
 +#define MODULE_INFO_STRIP(tag, info) __MODULE_INFO_STRIP(tag, tag, info)
 /* For userspace: you can also call me... */
 -#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
 +#define MODULE_ALIAS(_alias) MODULE_INFO_STRIP(alias, _alias)
 /* Soft module dependencies. See man modprobe.d for details.
  * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
@@ -137,10 +138,10 @@ extern const struct gtype##_id __mod_##g
  * Author(s), use "Name <email>" or just "Name", for multiple
  * authors use multiple MODULE_AUTHOR() statements/lines.
  */
 -#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
 +#define MODULE_AUTHOR(_author) MODULE_INFO_STRIP(author, _author)
 /* What your module does. */
 -#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
 +#define MODULE_DESCRIPTION(_description) MODULE_INFO_STRIP(description, _description)
 #define MODULE_DEVICE_TABLE(type,name)		\
   MODULE_GENERIC_TABLE(type##_device,name)
@@ -161,7 +162,9 @@ extern const struct gtype##_id __mod_##g
 */
 #if defined(MODULE) || !defined(CONFIG_SYSFS)
 -#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
 +#define MODULE_VERSION(_version) MODULE_INFO_STRIP(version, _version)
 +#elif defined(CONFIG_MODULE_STRIPPED)
 +#define MODULE_VERSION(_version) __MODULE_INFO_DISABLED(version)
 #else
 #define MODULE_VERSION(_version)					\
 	static struct module_version_attribute ___modver_attr = {	\
@@ -183,7 +186,7 @@ extern const struct gtype##_id __mod_##g
 /* Optional firmware file (or files) needed by the module
  * format is simply firmware file name.  Multiple firmware
  * files require multiple MODULE_FIRMWARE() specifiers */
 -#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
 +#define MODULE_FIRMWARE(_firmware) MODULE_INFO_STRIP(firmware, _firmware)
 /* Given an address, look for it in the exception tables */
 const struct exception_table_entry *search_exception_tables(unsigned long add);
 --- a/include/linux/moduleparam.h
 +++ b/include/linux/moduleparam.h
@@ -16,6 +16,16 @@
 /* Chosen so that structs with an unsigned long line up. */
 #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
 +/* This struct is here for syntactic coherency, it is not used */
 +#define __MODULE_INFO_DISABLED(name)					  \
 +  struct __UNIQUE_ID(name) {}
 +
 +#ifdef CONFIG_MODULE_STRIPPED
 +#define __MODULE_INFO_STRIP(tag, name, info) __MODULE_INFO_DISABLED(name)
 +#else
 +#define __MODULE_INFO_STRIP(tag, name, info) __MODULE_INFO(tag, name, info)
 +#endif
 +
 #ifdef MODULE
 #define __MODULE_INFO(tag, name, info)					  \
 static const char __UNIQUE_ID(name)[]					  \
@@ -23,8 +33,7 @@ static const char __UNIQUE_ID(name)[]
   = __stringify(tag) "=" info
 #else  /* !MODULE */
 /* This struct is here for syntactic coherency, it is not used */
 -#define __MODULE_INFO(tag, name, info)					  \
 -  struct __UNIQUE_ID(name) {}
 +#define __MODULE_INFO(tag, name, info) __MODULE_INFO_DISABLED(name)
 #endif
 #define __MODULE_PARM_TYPE(name, _type)					  \
   __MODULE_INFO(parmtype, name##type, #name ":" _type)
@@ -32,7 +41,7 @@ static const char __UNIQUE_ID(name)[]
 /* One for each parameter, describing how to use it.  Some files do
    multiple of these per line, so can't just use MODULE_INFO. */
 #define MODULE_PARM_DESC(_parm, desc) \
 -	__MODULE_INFO(parm, _parm, #_parm ":" desc)
 +	__MODULE_INFO_STRIP(parm, _parm, #_parm ":" desc)
 struct kernel_param;
 --- a/init/Kconfig
 +++ b/init/Kconfig
@@ -1835,6 +1835,13 @@ config MODULE_SIG_HASH
 	default "sha384" if MODULE_SIG_SHA384
 	default "sha512" if MODULE_SIG_SHA512
 +config MODULE_STRIPPED
 +	bool "Reduce module size"
 +	depends on MODULES
 +	help
 +	  Remove module parameter descriptions, author info, version, aliases,
 +	  device tables, etc.
 +
 endif # MODULES
 config INIT_ALL_POSSIBLE
 --- a/kernel/module.c
 +++ b/kernel/module.c
@@ -2666,6 +2666,7 @@ static struct module *setup_load_info(st
 static int check_modinfo(struct module *mod, struct load_info *info, int flags)
 {
 +#ifndef CONFIG_MODULE_STRIPPED
 	const char *modmagic = get_modinfo(info, "vermagic");
 	int err;
@@ -2691,6 +2692,7 @@ static int check_modinfo(struct module *
 		pr_warn("%s: module is from the staging directory, the quality "
 			"is unknown, you have been warned.\n", mod->name);
 	}
 +#endif
 	/* Set up license info based on the info section */
 	set_license(mod, get_modinfo(info, "license"));
 --- a/scripts/mod/modpost.c
 +++ b/scripts/mod/modpost.c
@@ -1717,7 +1717,9 @@ static void read_symbols(char *modname)
 		symname = info.strtab + sym->st_name;
 		handle_modversions(mod, &info, sym, symname);
 +#ifndef CONFIG_MODULE_STRIPPED
 		handle_moddevtable(mod, &info, sym, symname);
 +#endif
 	}
 	if (!is_vmlinux(modname) ||
 	     (is_vmlinux(modname) && vmlinux_section_warnings))
@@ -1861,7 +1863,9 @@ static void add_header(struct buffer *b,
 	buf_printf(b, "#include <linux/vermagic.h>\n");
 	buf_printf(b, "#include <linux/compiler.h>\n");
 	buf_printf(b, "\n");
 +#ifndef CONFIG_MODULE_STRIPPED
 	buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
 +#endif
 	buf_printf(b, "\n");
 	buf_printf(b, "__visible struct module __this_module\n");
 	buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
@@ -1878,16 +1882,20 @@ static void add_header(struct buffer *b,
 static void add_intree_flag(struct buffer *b, int is_intree)
 {
 +#ifndef CONFIG_MODULE_STRIPPED
 	if (is_intree)
 		buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
 +#endif
 }
 static void add_staging_flag(struct buffer *b, const char *name)
 {
 +#ifndef CONFIG_MODULE_STRIPPED
 	static const char *staging_dir = "drivers/staging";
 	if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
 		buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
 +#endif
 }
 /**
@@ -1980,11 +1988,13 @@ static void add_depends(struct buffer *b
 static void add_srcversion(struct buffer *b, struct module *mod)
 {
 +#ifndef CONFIG_MODULE_STRIPPED
 	if (mod->srcversion[0]) {
 		buf_printf(b, "\n");
 		buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
 			   mod->srcversion);
 	}
 +#endif
 }
 static void write_if_changed(struct buffer *b, const char *fname)
@@ -2213,7 +2223,9 @@ int main(int argc, char **argv)
 		add_staging_flag(&buf, mod->name);
 		err |= add_versions(&buf, mod);
 		add_depends(&buf, mod, modules);
 +#ifndef CONFIG_MODULE_STRIPPED
 		add_moddevtable(&buf, mod);
 +#endif
 		add_srcversion(&buf, mod);
 		sprintf(fname, "%s.mod.c", mod->name);
--- a/target/linux/generic/patches-3.13/210-darwin_scripts_include.patch
+++ b/target/linux/generic/patches-3.13/210-darwin_scripts_include.patch
--- a/target/linux/generic/patches-3.13/212-byteshift_portability.patch
+++ b/target/linux/generic/patches-3.13/212-byteshift_portability.patch
@ -1,51 +0,0 @@
 --- a/tools/include/tools/be_byteshift.h
 +++ b/tools/include/tools/be_byteshift.h
@@ -1,6 +1,10 @@
 #ifndef _TOOLS_BE_BYTESHIFT_H
 #define _TOOLS_BE_BYTESHIFT_H
 +#ifndef __linux__
 +#include "linux_types.h"
 +#endif
 +
 #include <stdint.h>
 static inline uint16_t __get_unaligned_be16(const uint8_t *p)
 --- a/tools/include/tools/le_byteshift.h
 +++ b/tools/include/tools/le_byteshift.h
@@ -1,6 +1,10 @@
 #ifndef _TOOLS_LE_BYTESHIFT_H
 #define _TOOLS_LE_BYTESHIFT_H
 +#ifndef __linux__
 +#include "linux_types.h"
 +#endif
 +
 #include <stdint.h>
 static inline uint16_t __get_unaligned_le16(const uint8_t *p)
 --- /dev/null
 +++ b/tools/include/tools/linux_types.h
@@ -0,0 +1,22 @@
 +#ifndef __LINUX_TYPES_H
 +#define __LINUX_TYPES_H
 +
 +#include <stdint.h>
 +
 +typedef uint8_t __u8;
 +typedef uint8_t __be8;
 +typedef uint8_t __le8;
 +
 +typedef uint16_t __u16;
 +typedef uint16_t __be16;
 +typedef uint16_t __le16;
 +
 +typedef uint32_t __u32;
 +typedef uint32_t __be32;
 +typedef uint32_t __le32;
 +
 +typedef uint64_t __u64;
 +typedef uint64_t __be64;
 +typedef uint64_t __le64;
 +
 +#endif
--- a/target/linux/generic/patches-3.13/220-gc_sections.patch
+++ b/target/linux/generic/patches-3.13/220-gc_sections.patch
@ -1,531 +0,0 @@
 From: Felix Fietkau <nbd@openwrt.org>
 use -ffunction-sections, -fdata-sections and --gc-sections --sort-section=name
 In combination with kernel symbol export stripping this significantly reduces
 the kernel image size. Used on both ARM and MIPS architectures.
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 Signed-off-by: Jonas Gorski <jogo@openwrt.org>
 Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
 ---
 --- a/arch/mips/Makefile
 +++ b/arch/mips/Makefile
@@ -89,10 +89,14 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
 #
 cflags-y			+= -G 0 -mno-abicalls -fno-pic -pipe
 cflags-y			+= -msoft-float
 -LDFLAGS_vmlinux			+= -G 0 -static -n -nostdlib
 +LDFLAGS_vmlinux			+= -G 0 -static -n -nostdlib --gc-sections --sort-section=name
 KBUILD_AFLAGS_MODULE		+= -mlong-calls
 KBUILD_CFLAGS_MODULE		+= -mlong-calls
 +ifndef CONFIG_FUNCTION_TRACER
 +KBUILD_CFLAGS_KERNEL		+= -ffunction-sections -fdata-sections
 +endif
 +
 cflags-y += -ffreestanding
 #
 --- a/arch/mips/kernel/vmlinux.lds.S
 +++ b/arch/mips/kernel/vmlinux.lds.S
@@ -67,7 +67,7 @@ SECTIONS
 	/* Exception table for data bus errors */
 	__dbe_table : {
 		__start___dbe_table = .;
 -		*(__dbe_table)
 +		KEEP(*(__dbe_table))
 		__stop___dbe_table = .;
 	}
@@ -112,7 +112,7 @@ SECTIONS
 	. = ALIGN(4);
 	.mips.machines.init : AT(ADDR(.mips.machines.init) - LOAD_OFFSET) {
 		__mips_machines_start = .;
 -		*(.mips.machines.init)
 +		KEEP(*(.mips.machines.init))
 		__mips_machines_end = .;
 	}
 --- a/include/asm-generic/vmlinux.lds.h
 +++ b/include/asm-generic/vmlinux.lds.h
@@ -87,7 +87,7 @@
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 #define MCOUNT_REC()	. = ALIGN(8);				\
 			VMLINUX_SYMBOL(__start_mcount_loc) = .; \
 -			*(__mcount_loc)				\
 +			KEEP(*(__mcount_loc))			\
 			VMLINUX_SYMBOL(__stop_mcount_loc) = .;
 #else
 #define MCOUNT_REC()
@@ -95,7 +95,7 @@
 #ifdef CONFIG_TRACE_BRANCH_PROFILING
 #define LIKELY_PROFILE()	VMLINUX_SYMBOL(__start_annotated_branch_profile) = .; \
 -				*(_ftrace_annotated_branch)			      \
 +				KEEP(*(_ftrace_annotated_branch))		      \
 				VMLINUX_SYMBOL(__stop_annotated_branch_profile) = .;
 #else
 #define LIKELY_PROFILE()
@@ -103,7 +103,7 @@
 #ifdef CONFIG_PROFILE_ALL_BRANCHES
 #define BRANCH_PROFILE()	VMLINUX_SYMBOL(__start_branch_profile) = .;   \
 -				*(_ftrace_branch)			      \
 +				KEEP(*(_ftrace_branch))			      \
 				VMLINUX_SYMBOL(__stop_branch_profile) = .;
 #else
 #define BRANCH_PROFILE()
@@ -112,7 +112,7 @@
 #ifdef CONFIG_EVENT_TRACING
 #define FTRACE_EVENTS()	. = ALIGN(8);					\
 			VMLINUX_SYMBOL(__start_ftrace_events) = .;	\
 -			*(_ftrace_events)				\
 +			KEEP(*(_ftrace_events))				\
 			VMLINUX_SYMBOL(__stop_ftrace_events) = .;
 #else
 #define FTRACE_EVENTS()
@@ -120,7 +120,7 @@
 #ifdef CONFIG_TRACING
 #define TRACE_PRINTKS() VMLINUX_SYMBOL(__start___trace_bprintk_fmt) = .;      \
 -			 *(__trace_printk_fmt) /* Trace_printk fmt' pointer */ \
 +			 KEEP(*(__trace_printk_fmt)) /* Trace_printk fmt' pointer */ \
 			 VMLINUX_SYMBOL(__stop___trace_bprintk_fmt) = .;
 #define TRACEPOINT_STR() VMLINUX_SYMBOL(__start___tracepoint_str) = .;	\
 			 *(__tracepoint_str) /* Trace_printk fmt' pointer */ \
@@ -133,7 +133,7 @@
 #ifdef CONFIG_FTRACE_SYSCALLS
 #define TRACE_SYSCALLS() . = ALIGN(8);					\
 			 VMLINUX_SYMBOL(__start_syscalls_metadata) = .;	\
 -			 *(__syscalls_metadata)				\
 +			 KEEP(*(__syscalls_metadata))			\
 			 VMLINUX_SYMBOL(__stop_syscalls_metadata) = .;
 #else
 #define TRACE_SYSCALLS()
@@ -142,8 +142,8 @@
 #ifdef CONFIG_CLKSRC_OF
 #define CLKSRC_OF_TABLES() . = ALIGN(8);				\
 			   VMLINUX_SYMBOL(__clksrc_of_table) = .;	\
 -			   *(__clksrc_of_table)				\
 -			   *(__clksrc_of_table_end)
 +			   KEEP(*(__clksrc_of_table))			\
 +			   KEEP(*(__clksrc_of_table_end))
 #else
 #define CLKSRC_OF_TABLES()
 #endif
@@ -152,8 +152,8 @@
 #define IRQCHIP_OF_MATCH_TABLE()					\
 	. = ALIGN(8);							\
 	VMLINUX_SYMBOL(__irqchip_begin) = .;				\
 -	*(__irqchip_of_table)		  				\
 -	*(__irqchip_of_end)
 +	KEEP(*(__irqchip_of_table))	  				\
 +	KEEP(*(__irqchip_of_end))
 #else
 #define IRQCHIP_OF_MATCH_TABLE()
 #endif
@@ -161,8 +161,8 @@
 #ifdef CONFIG_COMMON_CLK
 #define CLK_OF_TABLES() . = ALIGN(8);				\
 			VMLINUX_SYMBOL(__clk_of_table) = .;	\
 -			*(__clk_of_table)			\
 -			*(__clk_of_table_end)
 +			KEEP(*(__clk_of_table))			\
 +			KEEP(*(__clk_of_table_end))
 #else
 #define CLK_OF_TABLES()
 #endif
@@ -170,7 +170,7 @@
 #define KERNEL_DTB()							\
 	STRUCT_ALIGN();							\
 	VMLINUX_SYMBOL(__dtb_start) = .;				\
 -	*(.dtb.init.rodata)						\
 +	KEEP(*(.dtb.init.rodata))					\
 	VMLINUX_SYMBOL(__dtb_end) = .;
 /* .data section */
@@ -186,16 +186,17 @@
 	/* implement dynamic printk debug */				\
 	. = ALIGN(8);                                                   \
 	VMLINUX_SYMBOL(__start___jump_table) = .;                       \
 -	*(__jump_table)                                                 \
 +	KEEP(*(__jump_table))                                           \
 	VMLINUX_SYMBOL(__stop___jump_table) = .;                        \
 	. = ALIGN(8);							\
 	VMLINUX_SYMBOL(__start___verbose) = .;                          \
 -	*(__verbose)                                                    \
 +	KEEP(*(__verbose))                                              \
 	VMLINUX_SYMBOL(__stop___verbose) = .;				\
 	LIKELY_PROFILE()		       				\
 	BRANCH_PROFILE()						\
 	TRACE_PRINTKS()							\
 -	TRACEPOINT_STR()
 +	TRACEPOINT_STR()                                                \
 +	*(.data.[a-zA-Z_]*)
 /*
  * Data section helpers
@@ -249,32 +250,32 @@
 	/* PCI quirks */						\
 	.pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start_pci_fixups_early) = .;		\
 -		*(.pci_fixup_early)					\
 +		KEEP(*(.pci_fixup_early))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_early) = .;		\
 		VMLINUX_SYMBOL(__start_pci_fixups_header) = .;		\
 -		*(.pci_fixup_header)					\
 +		KEEP(*(.pci_fixup_header))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_header) = .;		\
 		VMLINUX_SYMBOL(__start_pci_fixups_final) = .;		\
 -		*(.pci_fixup_final)					\
 +		KEEP(*(.pci_fixup_final))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_final) = .;		\
 		VMLINUX_SYMBOL(__start_pci_fixups_enable) = .;		\
 -		*(.pci_fixup_enable)					\
 +		KEEP(*(.pci_fixup_enable))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_enable) = .;		\
 		VMLINUX_SYMBOL(__start_pci_fixups_resume) = .;		\
 -		*(.pci_fixup_resume)					\
 +		KEEP(*(.pci_fixup_resume))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_resume) = .;		\
 		VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .;	\
 -		*(.pci_fixup_resume_early)				\
 +		KEEP(*(.pci_fixup_resume_early))			\
 		VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .;	\
 		VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .;		\
 -		*(.pci_fixup_suspend)					\
 +		KEEP(*(.pci_fixup_suspend))				\
 		VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .;		\
 	}								\
 									\
 	/* Built-in firmware blobs */					\
 	.builtin_fw        : AT(ADDR(.builtin_fw) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start_builtin_fw) = .;			\
 -		*(.builtin_fw)						\
 +		KEEP(*(.builtin_fw))					\
 		VMLINUX_SYMBOL(__end_builtin_fw) = .;			\
 	}								\
 									\
@@ -283,49 +284,49 @@
 	/* Kernel symbol table: Normal symbols */			\
 	__ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {		\
 		VMLINUX_SYMBOL(__start___ksymtab) = .;			\
 -		*(SORT(___ksymtab+*))					\
 +		KEEP(*(SORT(___ksymtab+*)))				\
 		VMLINUX_SYMBOL(__stop___ksymtab) = .;			\
 	}								\
 									\
 	/* Kernel symbol table: GPL-only symbols */			\
 	__ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;		\
 -		*(SORT(___ksymtab_gpl+*))				\
 +		KEEP(*(SORT(___ksymtab_gpl+*)))				\
 		VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;		\
 	}								\
 									\
 	/* Kernel symbol table: Normal unused symbols */		\
 	__ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start___ksymtab_unused) = .;		\
 -		*(SORT(___ksymtab_unused+*))				\
 +		KEEP(*(SORT(___ksymtab_unused+*)))			\
 		VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;		\
 	}								\
 									\
 	/* Kernel symbol table: GPL-only unused symbols */		\
 	__ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
 		VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;	\
 -		*(SORT(___ksymtab_unused_gpl+*))			\
 +		KEEP(*(SORT(___ksymtab_unused_gpl+*)))			\
 		VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;	\
 	}								\
 									\
 	/* Kernel symbol table: GPL-future-only symbols */		\
 	__ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
 		VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;	\
 -		*(SORT(___ksymtab_gpl_future+*))			\
 +		KEEP(*(SORT(___ksymtab_gpl_future+*)))			\
 		VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;	\
 	}								\
 									\
 	/* Kernel symbol table: Normal symbols */			\
 	__kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {		\
 		VMLINUX_SYMBOL(__start___kcrctab) = .;			\
 -		*(SORT(___kcrctab+*))					\
 +		KEEP(*(SORT(___kcrctab+*)))				\
 		VMLINUX_SYMBOL(__stop___kcrctab) = .;			\
 	}								\
 									\
 	/* Kernel symbol table: GPL-only symbols */			\
 	__kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;		\
 -		*(SORT(___kcrctab_gpl+*))				\
 +		KEEP(*(SORT(___kcrctab_gpl+*)))				\
 		VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;		\
 	}								\
 									\
@@ -339,14 +340,14 @@
 	/* Kernel symbol table: GPL-only unused symbols */		\
 	__kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
 		VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;	\
 -		*(SORT(___kcrctab_unused_gpl+*))			\
 +		KEEP(*(SORT(___kcrctab_unused_gpl+*)))			\
 		VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;	\
 	}								\
 									\
 	/* Kernel symbol table: GPL-future-only symbols */		\
 	__kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
 		VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;	\
 -		*(SORT(___kcrctab_gpl_future+*))			\
 +		KEEP(*(SORT(___kcrctab_gpl_future+*)))			\
 		VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .;	\
 	}								\
 									\
@@ -365,14 +366,14 @@
 	/* Built-in module parameters. */				\
 	__param : AT(ADDR(__param) - LOAD_OFFSET) {			\
 		VMLINUX_SYMBOL(__start___param) = .;			\
 -		*(__param)						\
 +		KEEP(*(__param))					\
 		VMLINUX_SYMBOL(__stop___param) = .;			\
 	}								\
 									\
 	/* Built-in module versions. */					\
 	__modver : AT(ADDR(__modver) - LOAD_OFFSET) {			\
 		VMLINUX_SYMBOL(__start___modver) = .;			\
 -		*(__modver)						\
 +		KEEP(*(__modver))					\
 		VMLINUX_SYMBOL(__stop___modver) = .;			\
 		. = ALIGN((align));					\
 		VMLINUX_SYMBOL(__end_rodata) = .;			\
@@ -428,7 +429,7 @@
 #define ENTRY_TEXT							\
 		ALIGN_FUNCTION();					\
 		VMLINUX_SYMBOL(__entry_text_start) = .;			\
 -		*(.entry.text)						\
 +		KEEP(*(.entry.text))					\
 		VMLINUX_SYMBOL(__entry_text_end) = .;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
@@ -456,7 +457,7 @@
 	. = ALIGN(align);						\
 	__ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {		\
 		VMLINUX_SYMBOL(__start___ex_table) = .;			\
 -		*(__ex_table)						\
 +		KEEP(*(__ex_table))						\
 		VMLINUX_SYMBOL(__stop___ex_table) = .;			\
 	}
@@ -472,8 +473,8 @@
 #ifdef CONFIG_CONSTRUCTORS
 #define KERNEL_CTORS()	. = ALIGN(8);			   \
 			VMLINUX_SYMBOL(__ctors_start) = .; \
 -			*(.ctors)			   \
 -			*(.init_array)			   \
 +			KEEP(*(.ctors))			   \
 +			KEEP(*(.init_array))		   \
 			VMLINUX_SYMBOL(__ctors_end) = .;
 #else
 #define KERNEL_CTORS()
@@ -517,7 +518,7 @@
 #define SBSS(sbss_align)						\
 	. = ALIGN(sbss_align);						\
 	.sbss : AT(ADDR(.sbss) - LOAD_OFFSET) {				\
 -		*(.sbss)						\
 +		*(.sbss .sbss.*)					\
 		*(.scommon)						\
 	}
@@ -535,7 +536,7 @@
 		BSS_FIRST_SECTIONS					\
 		*(.bss..page_aligned)					\
 		*(.dynbss)						\
 -		*(.bss)							\
 +		*(.bss .bss.*)						\
 		*(COMMON)						\
 	}
@@ -596,7 +597,7 @@
 	. = ALIGN(4);							\
 	.tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {		\
 		VMLINUX_SYMBOL(__tracedata_start) = .;			\
 -		*(.tracedata)						\
 +		KEEP(*(.tracedata))					\
 		VMLINUX_SYMBOL(__tracedata_end) = .;			\
 	}
 #else
@@ -613,17 +614,17 @@
 #define INIT_SETUP(initsetup_align)					\
 		. = ALIGN(initsetup_align);				\
 		VMLINUX_SYMBOL(__setup_start) = .;			\
 -		*(.init.setup)						\
 +		KEEP(*(.init.setup))					\
 		VMLINUX_SYMBOL(__setup_end) = .;
 #define INIT_CALLS_LEVEL(level)						\
 		VMLINUX_SYMBOL(__initcall##level##_start) = .;		\
 -		*(.initcall##level##.init)				\
 -		*(.initcall##level##s.init)				\
 +		KEEP(*(.initcall##level##.init))			\
 +		KEEP(*(.initcall##level##s.init))			\
 #define INIT_CALLS							\
 		VMLINUX_SYMBOL(__initcall_start) = .;			\
 -		*(.initcallearly.init)					\
 +		KEEP(*(.initcallearly.init))				\
 		INIT_CALLS_LEVEL(0)					\
 		INIT_CALLS_LEVEL(1)					\
 		INIT_CALLS_LEVEL(2)					\
@@ -637,21 +638,21 @@
 #define CON_INITCALL							\
 		VMLINUX_SYMBOL(__con_initcall_start) = .;		\
 -		*(.con_initcall.init)					\
 +		KEEP(*(.con_initcall.init))				\
 		VMLINUX_SYMBOL(__con_initcall_end) = .;
 #define SECURITY_INITCALL						\
 		VMLINUX_SYMBOL(__security_initcall_start) = .;		\
 -		*(.security_initcall.init)				\
 +		KEEP(*(.security_initcall.init))			\
 		VMLINUX_SYMBOL(__security_initcall_end) = .;
 #ifdef CONFIG_BLK_DEV_INITRD
 #define INIT_RAM_FS							\
 	. = ALIGN(4);							\
 	VMLINUX_SYMBOL(__initramfs_start) = .;				\
 -	*(.init.ramfs)							\
 +	KEEP(*(.init.ramfs))						\
 	. = ALIGN(8);							\
 -	*(.init.ramfs.info)
 +	KEEP(*(.init.ramfs.info))
 #else
 #define INIT_RAM_FS
 #endif
 --- a/arch/arm/Makefile
 +++ b/arch/arm/Makefile
@@ -18,11 +18,16 @@ ifeq ($(CONFIG_CPU_ENDIAN_BE8),y)
 LDFLAGS_vmlinux	+= --be8
 LDFLAGS_MODULE	+= --be8
 endif
 +LDFLAGS_vmlinux += --gc-sections --sort-section=name
 OBJCOPYFLAGS	:=-O binary -R .comment -S
 GZFLAGS		:=-9
 #KBUILD_CFLAGS	+=-pipe
 +ifndef CONFIG_FUNCTION_TRACER
 +KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections
 +endif
 +
 # Never generate .eh_frame
 KBUILD_CFLAGS	+= $(call cc-option,-fno-dwarf2-cfi-asm)
 --- a/arch/arm/kernel/vmlinux.lds.S
 +++ b/arch/arm/kernel/vmlinux.lds.S
@@ -12,13 +12,13 @@
 #define PROC_INFO							\
 	. = ALIGN(4);							\
 	VMLINUX_SYMBOL(__proc_info_begin) = .;				\
 -	*(.proc.info.init)						\
 +	KEEP(*(.proc.info.init))					\
 	VMLINUX_SYMBOL(__proc_info_end) = .;
 #define IDMAP_TEXT							\
 	ALIGN_FUNCTION();						\
 	VMLINUX_SYMBOL(__idmap_text_start) = .;				\
 -	*(.idmap.text)							\
 +	KEEP(*(.idmap.text))						\
 	VMLINUX_SYMBOL(__idmap_text_end) = .;				\
 	. = ALIGN(32);							\
 	VMLINUX_SYMBOL(__hyp_idmap_text_start) = .;			\
@@ -93,7 +93,7 @@ SECTIONS
 	.text : {			/* Real text segment		*/
 		_stext = .;		/* Text and read-only data	*/
 			__exception_text_start = .;
 -			*(.exception.text)
 +			KEEP(*(.exception.text))
 			__exception_text_end = .;
 			IRQENTRY_TEXT
 			TEXT_TEXT
@@ -118,7 +118,7 @@ SECTIONS
 	__ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
 		__start___ex_table = .;
 #ifdef CONFIG_MMU
 -		*(__ex_table)
 +		KEEP(*(__ex_table))
 #endif
 		__stop___ex_table = .;
 	}
@@ -130,12 +130,12 @@ SECTIONS
 	. = ALIGN(8);
 	.ARM.unwind_idx : {
 		__start_unwind_idx = .;
 -		*(.ARM.exidx*)
 +		KEEP(*(.ARM.exidx*))
 		__stop_unwind_idx = .;
 	}
 	.ARM.unwind_tab : {
 		__start_unwind_tab = .;
 -		*(.ARM.extab*)
 +		KEEP(*(.ARM.extab*))
 		__stop_unwind_tab = .;
 	}
 #endif
@@ -154,14 +154,14 @@ SECTIONS
 	 */
 	__vectors_start = .;
 	.vectors 0 : AT(__vectors_start) {
 -		*(.vectors)
 +		KEEP(*(.vectors))
 	}
 	. = __vectors_start + SIZEOF(.vectors);
 	__vectors_end = .;
 	__stubs_start = .;
 	.stubs 0x1000 : AT(__stubs_start) {
 -		*(.stubs)
 +		KEEP(*(.stubs))
 	}
 	. = __stubs_start + SIZEOF(.stubs);
 	__stubs_end = .;
@@ -175,24 +175,24 @@ SECTIONS
 	}
 	.init.arch.info : {
 		__arch_info_begin = .;
 -		*(.arch.info.init)
 +		KEEP(*(.arch.info.init))
 		__arch_info_end = .;
 	}
 	.init.tagtable : {
 		__tagtable_begin = .;
 -		*(.taglist.init)
 +		KEEP(*(.taglist.init))
 		__tagtable_end = .;
 	}
 #ifdef CONFIG_SMP_ON_UP
 	.init.smpalt : {
 		__smpalt_begin = .;
 -		*(.alt.smp.init)
 +		KEEP(*(.alt.smp.init))
 		__smpalt_end = .;
 	}
 #endif
 	.init.pv_table : {
 		__pv_table_begin = .;
 -		*(.pv_table)
 +		KEEP(*(.pv_table))
 		__pv_table_end = .;
 	}
 	.init.data : {
 --- a/arch/arm/boot/compressed/Makefile
 +++ b/arch/arm/boot/compressed/Makefile
@@ -120,6 +120,7 @@ ifeq ($(CONFIG_FUNCTION_TRACER),y)
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
 KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS))
 endif
 +KBUILD_CFLAGS_KERNEL := $(patsubst -f%-sections,,$(KBUILD_CFLAGS_KERNEL))
 ccflags-y := -fpic -mno-single-pic-base -fno-builtin -I$(obj)
 asflags-y := -DZIMAGE
--- a/target/linux/generic/patches-3.13/221-module_exports.patch
+++ b/target/linux/generic/patches-3.13/221-module_exports.patch
@ -1,88 +0,0 @@
 --- a/include/asm-generic/vmlinux.lds.h
 +++ b/include/asm-generic/vmlinux.lds.h
@@ -52,6 +52,16 @@
 #define LOAD_OFFSET 0
 #endif
 +#ifndef SYMTAB_KEEP
 +#define SYMTAB_KEEP KEEP(*(SORT(___ksymtab+*)))
 +#define SYMTAB_KEEP_GPL KEEP(*(SORT(___ksymtab_gpl+*)))
 +#endif
 +
 +#ifndef SYMTAB_DISCARD
 +#define SYMTAB_DISCARD
 +#define SYMTAB_DISCARD_GPL
 +#endif
 +
 #include <linux/export.h>
 /* Align . to a 8 byte boundary equals to maximum function alignment. */
@@ -284,14 +294,14 @@
 	/* Kernel symbol table: Normal symbols */			\
 	__ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {		\
 		VMLINUX_SYMBOL(__start___ksymtab) = .;			\
 -		KEEP(*(SORT(___ksymtab+*)))				\
 +		SYMTAB_KEEP						\
 		VMLINUX_SYMBOL(__stop___ksymtab) = .;			\
 	}								\
 									\
 	/* Kernel symbol table: GPL-only symbols */			\
 	__ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {	\
 		VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;		\
 -		KEEP(*(SORT(___ksymtab_gpl+*)))				\
 +		SYMTAB_KEEP_GPL						\
 		VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;		\
 	}								\
 									\
@@ -353,7 +363,7 @@
 									\
 	/* Kernel symbol table: strings */				\
         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {	\
 -		*(__ksymtab_strings)					\
 +		*(__ksymtab_strings+*)					\
 	}								\
 									\
 	/* __*init sections */						\
@@ -671,6 +681,8 @@
 	EXIT_TEXT							\
 	EXIT_DATA							\
 	EXIT_CALL							\
 +	SYMTAB_DISCARD							\
 +	SYMTAB_DISCARD_GPL						\
 	*(.discard)							\
 	*(.discard.*)							\
 	}
 --- a/scripts/Makefile.build
 +++ b/scripts/Makefile.build
@@ -349,7 +349,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $(
 # Linker scripts preprocessor (.lds.S -> .lds)
 # ---------------------------------------------------------------------------
 quiet_cmd_cpp_lds_S = LDS     $@
 -      cmd_cpp_lds_S = $(CPP) $(cpp_flags) -P -C -U$(ARCH) \
 +      cmd_cpp_lds_S = $(CPP) $(EXTRA_LDSFLAGS) $(cpp_flags) -P -C -U$(ARCH) \
 	                     -D__ASSEMBLY__ -DLINKER_SCRIPT -o $@ $<
 $(obj)/%.lds: $(src)/%.lds.S FORCE
 --- a/include/linux/export.h
 +++ b/include/linux/export.h
@@ -52,12 +52,19 @@ extern struct module __this_module;
 #define __CRC_SYMBOL(sym, sec)
 #endif
 +#ifdef MODULE
 +#define __EXPORT_SUFFIX(sym)
 +#else
 +#define __EXPORT_SUFFIX(sym) "+" #sym
 +#endif
 +
 /* For every exported symbol, place a struct in the __ksymtab section */
 #define __EXPORT_SYMBOL(sym, sec)				\
 	extern typeof(sym) sym;					\
 	__CRC_SYMBOL(sym, sec)					\
 	static const char __kstrtab_##sym[]			\
 -	__attribute__((section("__ksymtab_strings"), aligned(1))) \
 +	__attribute__((section("__ksymtab_strings"		\
 +	  __EXPORT_SUFFIX(sym)), aligned(1)))			\
 	= VMLINUX_SYMBOL_STR(sym);				\
 	extern const struct kernel_symbol __ksymtab_##sym;	\
 	__visible const struct kernel_symbol __ksymtab_##sym	\
--- a/target/linux/generic/patches-3.13/230-openwrt_lzma_options.patch
+++ b/target/linux/generic/patches-3.13/230-openwrt_lzma_options.patch
@ -1,58 +0,0 @@
 --- a/scripts/Makefile.lib
 +++ b/scripts/Makefile.lib
@@ -303,7 +303,7 @@ cmd_bzip2 = (cat $(filter-out FORCE,$^)
 quiet_cmd_lzma = LZMA    $@
 cmd_lzma = (cat $(filter-out FORCE,$^) | \
 -	lzma -9 && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
 +	lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
 	(rm -f $@ ; false)
 quiet_cmd_lzo = LZO     $@
 --- a/scripts/gen_initramfs_list.sh
 +++ b/scripts/gen_initramfs_list.sh
@@ -226,7 +226,7 @@ cpio_list=
 output="/dev/stdout"
 output_file=""
 is_cpio_compressed=
 -compr="gzip -n -9 -f"
 +compr="gzip -n -9 -f -"
 arg="$1"
 case "$arg" in
@@ -242,13 +242,13 @@ case "$arg" in
 		output=${cpio_list}
 		echo "$output_file" | grep -q "\.gz$" \
                 && [ -x "`which gzip 2> /dev/null`" ] \
 -                && compr="gzip -n -9 -f"
 +                && compr="gzip -n -9 -f -"
 		echo "$output_file" | grep -q "\.bz2$" \
                 && [ -x "`which bzip2 2> /dev/null`" ] \
 -                && compr="bzip2 -9 -f"
 +                && compr="bzip2 -9 -f -"
 		echo "$output_file" | grep -q "\.lzma$" \
                 && [ -x "`which lzma 2> /dev/null`" ] \
 -                && compr="lzma -9 -f"
 +                && compr="lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so"
 		echo "$output_file" | grep -q "\.xz$" \
                 && [ -x "`which xz 2> /dev/null`" ] \
                 && compr="xz --check=crc32 --lzma2=dict=1MiB"
@@ -315,7 +315,7 @@ if [ ! -z ${output_file} ]; then
 	if [ "${is_cpio_compressed}" = "compressed" ]; then
 		cat ${cpio_tfile} > ${output_file}
 	else
 -		(cat ${cpio_tfile} | ${compr}  - > ${output_file}) \
 +		(cat ${cpio_tfile} | ${compr} > ${output_file}) \
 		|| (rm -f ${output_file} ; false)
 	fi
 	[ -z ${cpio_file} ] && rm ${cpio_tfile}
 --- a/lib/decompress.c
 +++ b/lib/decompress.c
@@ -47,6 +47,7 @@ static const struct compress_format comp
 	{ {037, 0236}, "gzip", gunzip },
 	{ {0x42, 0x5a}, "bzip2", bunzip2 },
 	{ {0x5d, 0x00}, "lzma", unlzma },
 +	{ {0x6d, 0x00}, "lzma-openwrt", unlzma },
 	{ {0xfd, 0x37}, "xz", unxz },
 	{ {0x89, 0x4c}, "lzo", unlzo },
 	{ {0x02, 0x21}, "lz4", unlz4 },
--- a/target/linux/generic/patches-3.13/250-netfilter_depends.patch
+++ b/target/linux/generic/patches-3.13/250-netfilter_depends.patch
@ -1,18 +0,0 @@
 --- a/net/netfilter/Kconfig
 +++ b/net/netfilter/Kconfig
@@ -195,7 +195,6 @@ config NF_CONNTRACK_FTP
 config NF_CONNTRACK_H323
 	tristate "H.323 protocol support"
 -	depends on (IPV6 || IPV6=n)
 	depends on NETFILTER_ADVANCED
 	help
 	  H.323 is a VoIP signalling protocol from ITU-T. As one of the most
@@ -802,7 +801,6 @@ config NETFILTER_XT_TARGET_SECMARK
 config NETFILTER_XT_TARGET_TCPMSS
 	tristate '"TCPMSS" target support'
 -	depends on (IPV6 || IPV6=n)
 	default m if NETFILTER_ADVANCED=n
 	---help---
 	  This option adds a `TCPMSS' target, which allows you to alter the
--- a/target/linux/generic/patches-3.13/251-sound_kconfig.patch
+++ b/target/linux/generic/patches-3.13/251-sound_kconfig.patch
@ -1,18 +0,0 @@
 --- a/sound/core/Kconfig
 +++ b/sound/core/Kconfig
@@ -10,13 +10,13 @@ config SND_DMAENGINE_PCM
 	tristate
 config SND_HWDEP
 -	tristate
 +	tristate "Sound hardware support"
 config SND_RAWMIDI
 	tristate
 config SND_COMPRESS_OFFLOAD
 -	tristate
 +	tristate "Compression offloading support"
 # To be effective this also requires INPUT - users should say:
 #    select SND_JACK if INPUT=y || INPUT=SND
--- a/target/linux/generic/patches-3.13/252-mv_cesa_depends.patch
+++ b/target/linux/generic/patches-3.13/252-mv_cesa_depends.patch
@ -1,10 +0,0 @@
 --- a/drivers/crypto/Kconfig
 +++ b/drivers/crypto/Kconfig
@@ -164,6 +164,7 @@ config CRYPTO_DEV_MV_CESA
 	depends on PLAT_ORION
 	select CRYPTO_ALGAPI
 	select CRYPTO_AES
 +	select CRYPTO_HASH2
 	select CRYPTO_BLKCIPHER2
 	select CRYPTO_HASH
 	help
--- a/target/linux/generic/patches-3.13/253-ssb_b43_default_on.patch
+++ b/target/linux/generic/patches-3.13/253-ssb_b43_default_on.patch
@ -1,29 +0,0 @@
 --- a/drivers/ssb/Kconfig
 +++ b/drivers/ssb/Kconfig
@@ -29,6 +29,7 @@ config SSB_SPROM
 config SSB_BLOCKIO
 	bool
 	depends on SSB
 +	default y
 config SSB_PCIHOST_POSSIBLE
 	bool
@@ -49,7 +50,7 @@ config SSB_PCIHOST
 config SSB_B43_PCI_BRIDGE
 	bool
 	depends on SSB_PCIHOST
 -	default n
 +	default y
 config SSB_PCMCIAHOST_POSSIBLE
 	bool
 --- a/drivers/bcma/Kconfig
 +++ b/drivers/bcma/Kconfig
@@ -17,6 +17,7 @@ config BCMA
 config BCMA_BLOCKIO
 	bool
 	depends on BCMA
 +	default y
 config BCMA_HOST_PCI_POSSIBLE
 	bool
--- a/target/linux/generic/patches-3.13/254-textsearch_kconfig_hacks.patch
+++ b/target/linux/generic/patches-3.13/254-textsearch_kconfig_hacks.patch
@ -1,23 +0,0 @@
 --- a/lib/Kconfig
 +++ b/lib/Kconfig
@@ -308,16 +308,16 @@ config BCH_CONST_T
 # Textsearch support is select'ed if needed
 #
 config TEXTSEARCH
 -	boolean
 +	boolean	"Textsearch support"
 config TEXTSEARCH_KMP
 -	tristate
 +	tristate "Textsearch KMP"
 config TEXTSEARCH_BM
 -	tristate
 +	tristate "Textsearch BM"
 config TEXTSEARCH_FSM
 -	tristate
 +	tristate "Textsearch FSM"
 config BTREE
 	boolean
--- a/target/linux/generic/patches-3.13/255-lib80211_kconfig_hacks.patch
+++ b/target/linux/generic/patches-3.13/255-lib80211_kconfig_hacks.patch
@ -1,31 +0,0 @@
 --- a/net/wireless/Kconfig
 +++ b/net/wireless/Kconfig
@@ -140,7 +140,7 @@ config CFG80211_WEXT
 	  extensions with cfg80211-based drivers.
 config LIB80211
 -	tristate
 +	tristate "LIB80211"
 	default n
 	help
 	  This options enables a library of common routines used
@@ -149,13 +149,16 @@ config LIB80211
 	  Drivers should select this themselves if needed.
 config LIB80211_CRYPT_WEP
 -	tristate
 +	tristate "LIB80211_CRYPT_WEP"
 +	select LIB80211
 config LIB80211_CRYPT_CCMP
 -	tristate
 +	tristate "LIB80211_CRYPT_CCMP"
 +	select LIB80211
 config LIB80211_CRYPT_TKIP
 -	tristate
 +	tristate "LIB80211_CRYPT_TKIP"
 +	select LIB80211
 config LIB80211_DEBUG
 	bool "lib80211 debugging messages"
--- a/target/linux/generic/patches-3.13/256-crypto_add_kconfig_prompts.patch
+++ b/target/linux/generic/patches-3.13/256-crypto_add_kconfig_prompts.patch
@ -1,47 +0,0 @@
 --- a/crypto/Kconfig
 +++ b/crypto/Kconfig
@@ -31,7 +31,7 @@ config CRYPTO_FIPS
 	  this is.
 config CRYPTO_ALGAPI
 -	tristate
 +	tristate "ALGAPI"
 	select CRYPTO_ALGAPI2
 	help
 	  This option provides the API for cryptographic algorithms.
@@ -40,7 +40,7 @@ config CRYPTO_ALGAPI2
 	tristate
 config CRYPTO_AEAD
 -	tristate
 +	tristate "AEAD"
 	select CRYPTO_AEAD2
 	select CRYPTO_ALGAPI
@@ -49,7 +49,7 @@ config CRYPTO_AEAD2
 	select CRYPTO_ALGAPI2
 config CRYPTO_BLKCIPHER
 -	tristate
 +	tristate "BLKCIPHER"
 	select CRYPTO_BLKCIPHER2
 	select CRYPTO_ALGAPI
@@ -60,7 +60,7 @@ config CRYPTO_BLKCIPHER2
 	select CRYPTO_WORKQUEUE
 config CRYPTO_HASH
 -	tristate
 +	tristate "HASH"
 	select CRYPTO_HASH2
 	select CRYPTO_ALGAPI
@@ -69,7 +69,7 @@ config CRYPTO_HASH2
 	select CRYPTO_ALGAPI2
 config CRYPTO_RNG
 -	tristate
 +	tristate "RNG"
 	select CRYPTO_RNG2
 	select CRYPTO_ALGAPI
--- a/target/linux/generic/patches-3.13/257-wireless_ext_kconfig_hack.patch
+++ b/target/linux/generic/patches-3.13/257-wireless_ext_kconfig_hack.patch
@ -1,22 +0,0 @@
 --- a/net/wireless/Kconfig
 +++ b/net/wireless/Kconfig
@@ -1,5 +1,5 @@
 config WIRELESS_EXT
 -	bool
 +	bool "Wireless extensions"
 config WEXT_CORE
 	def_bool y
@@ -11,10 +11,10 @@ config WEXT_PROC
 	depends on WEXT_CORE
 config WEXT_SPY
 -	bool
 +	bool "WEXT_SPY"
 config WEXT_PRIV
 -	bool
 +	bool "WEXT_PRIV"
 config CFG80211
 	tristate "cfg80211 - wireless configuration API"
--- a/target/linux/generic/patches-3.13/258-netfilter_netlink_kconfig_hack.patch
+++ b/target/linux/generic/patches-3.13/258-netfilter_netlink_kconfig_hack.patch
@ -1,11 +0,0 @@
 --- a/net/netfilter/Kconfig
 +++ b/net/netfilter/Kconfig
@@ -2,7 +2,7 @@ menu "Core Netfilter Configuration"
 	depends on NET && INET && NETFILTER
 config NETFILTER_NETLINK
 -	tristate
 +	tristate "Netfilter NFNETLINK interface"
 config NETFILTER_NETLINK_ACCT
 tristate "Netfilter NFACCT over NFNETLINK interface"
--- a/target/linux/generic/patches-3.13/259-regmap_dynamic.patch
+++ b/target/linux/generic/patches-3.13/259-regmap_dynamic.patch
@ -1,76 +0,0 @@
 --- a/drivers/base/regmap/Kconfig
 +++ b/drivers/base/regmap/Kconfig
@@ -3,23 +3,28 @@
 # subsystems should select the appropriate symbols.
 config REGMAP
 -	default y if (REGMAP_I2C || REGMAP_SPI || REGMAP_SPMI || REGMAP_MMIO || REGMAP_IRQ)
 	select LZO_COMPRESS
 	select LZO_DECOMPRESS
 	select IRQ_DOMAIN if REGMAP_IRQ
 -	bool
 +	tristate "Regmap"
 config REGMAP_I2C
 -	tristate
 +	select REGMAP
 +	tristate "Regmap I2C"
 config REGMAP_SPI
 -	tristate
 +	select REGMAP
 +	depends on SPI_MASTER
 +	tristate "Regmap SPI"
 config REGMAP_SPMI
 +	select REGMAP
 	tristate
 config REGMAP_MMIO
 +	select REGMAP
 	tristate
 config REGMAP_IRQ
 +	select REGMAP
 	bool
 --- a/include/linux/regmap.h
 +++ b/include/linux/regmap.h
@@ -49,7 +49,7 @@ struct reg_default {
 	unsigned int def;
 };
 -#ifdef CONFIG_REGMAP
 +#if IS_ENABLED(CONFIG_REGMAP)
 enum regmap_endian {
 	/* Unspecified -> 0 -> Backwards compatible default */
 --- a/drivers/base/regmap/Makefile
 +++ b/drivers/base/regmap/Makefile
@@ -1,6 +1,8 @@
 -obj-$(CONFIG_REGMAP) += regmap.o regcache.o
 -obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o regcache-flat.o
 -obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
 +regmap-core-objs = regmap.o regcache.o regcache-rbtree.o regcache-lzo.o regcache-flat.o
 +ifdef CONFIG_DEBUG_FS
 +regmap-core-objs += regmap-debugfs.o
 +endif
 +obj-$(CONFIG_REGMAP) += regmap-core.o
 obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
 obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
 obj-$(CONFIG_REGMAP_SPMI) += regmap-spmi.o
 --- a/drivers/base/regmap/regmap.c
 +++ b/drivers/base/regmap/regmap.c
@@ -13,6 +13,7 @@
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 +#include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/err.h>
 #include <linux/rbtree.h>
@@ -2235,3 +2236,5 @@ static int __init regmap_initcall(void)
 	return 0;
 }
 postcore_initcall(regmap_initcall);
 +
 +MODULE_LICENSE("GPL");
--- a/target/linux/generic/patches-3.13/260-crypto_test_dependencies.patch
+++ b/target/linux/generic/patches-3.13/260-crypto_test_dependencies.patch
@ -1,37 +0,0 @@
 --- a/crypto/Kconfig
 +++ b/crypto/Kconfig
@@ -95,10 +95,10 @@ config CRYPTO_MANAGER
 config CRYPTO_MANAGER2
 	def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
 -	select CRYPTO_AEAD2
 -	select CRYPTO_HASH2
 -	select CRYPTO_BLKCIPHER2
 -	select CRYPTO_PCOMP2
 +	select CRYPTO_AEAD2 if !CRYPTO_MANAGER_DISABLE_TESTS
 +	select CRYPTO_HASH2 if !CRYPTO_MANAGER_DISABLE_TESTS
 +	select CRYPTO_BLKCIPHER2 if !CRYPTO_MANAGER_DISABLE_TESTS
 +	select CRYPTO_PCOMP2 if !CRYPTO_MANAGER_DISABLE_TESTS
 config CRYPTO_USER
 	tristate "Userspace cryptographic algorithm configuration"
 --- a/crypto/algboss.c
 +++ b/crypto/algboss.c
@@ -248,6 +248,9 @@ static int cryptomgr_schedule_test(struc
 	type = alg->cra_flags;
 	/* This piece of crap needs to disappear into per-type test hooks. */
 +#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
 +	type |= CRYPTO_ALG_TESTED;
 +#else
 	if ((!((type ^ CRYPTO_ALG_TYPE_BLKCIPHER) &
 	       CRYPTO_ALG_TYPE_BLKCIPHER_MASK) && !(type & CRYPTO_ALG_GENIV) &&
 	     ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
@@ -256,6 +259,7 @@ static int cryptomgr_schedule_test(struc
 	    (!((type ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) &&
 	     alg->cra_type == &crypto_nivaead_type && alg->cra_aead.ivsize))
 		type |= CRYPTO_ALG_TESTED;
 +#endif
 	param->type = type;
--- a/target/linux/generic/patches-3.13/262-compressor_kconfig_hack.patch
+++ b/target/linux/generic/patches-3.13/262-compressor_kconfig_hack.patch
@ -1,23 +0,0 @@
 --- a/lib/Kconfig
 +++ b/lib/Kconfig
@@ -193,16 +193,16 @@ config RANDOM32_SELFTEST
 # compression support is select'ed if needed
 #
 config ZLIB_INFLATE
 -	tristate
 +	tristate "ZLIB inflate support"
 config ZLIB_DEFLATE
 -	tristate
 +	tristate "ZLIB deflate support"
 config LZO_COMPRESS
 -	tristate
 +	tristate "LZO compress support"
 config LZO_DECOMPRESS
 -	tristate
 +	tristate "LZO decompress support"
 config LZ4_COMPRESS
 	tristate
--- a/target/linux/generic/patches-3.13/300-mips_expose_boot_raw.patch
+++ b/target/linux/generic/patches-3.13/300-mips_expose_boot_raw.patch
@ -1,39 +0,0 @@
 From: Mark Miller <mark@mirell.org>
 This exposes the CONFIG_BOOT_RAW symbol in Kconfig. This is needed on
 certain Broadcom chipsets running CFE in order to load the kernel.
 Signed-off-by: Mark Miller <mark@mirell.org>
 Acked-by: Rob Landley <rob@landley.net>
 ---
 --- a/arch/mips/Kconfig
 +++ b/arch/mips/Kconfig
@@ -846,9 +846,6 @@ config FW_ARC
 config ARCH_MAY_HAVE_PC_FDC
 	bool
 -config BOOT_RAW
 -	bool
 -
 config CEVT_BCM1480
 	bool
@@ -2349,6 +2346,18 @@ config USE_OF
 	select OF_EARLY_FLATTREE
 	select IRQ_DOMAIN
 +config BOOT_RAW
 +	bool "Enable the kernel to be executed from the load address"
 +	default n
 +	help
 +	 Allow the kernel to be executed from the load address for
 +	 bootloaders which cannot read the ELF format. This places
 +	 a jump to start_kernel at the load address.
 +
 +	 If unsure, say N.
 +
 +
 +
 endmenu
 config LOCKDEP_SUPPORT
--- a/target/linux/generic/patches-3.13/301-mips_image_cmdline_hack.patch
+++ b/target/linux/generic/patches-3.13/301-mips_image_cmdline_hack.patch
@ -1,28 +0,0 @@
 --- a/arch/mips/Kconfig
 +++ b/arch/mips/Kconfig
@@ -940,6 +940,10 @@ config SYNC_R4K
 config MIPS_MACHINE
 	def_bool n
 +config IMAGE_CMDLINE_HACK
 +	bool "OpenWrt specific image command line hack"
 +	default n
 +
 config NO_IOPORT
 	def_bool n
 --- a/arch/mips/kernel/head.S
 +++ b/arch/mips/kernel/head.S
@@ -101,6 +101,12 @@ FEXPORT(__kernel_entry)
 	j	kernel_entry
 #endif
 +#ifdef CONFIG_IMAGE_CMDLINE_HACK
 +	.ascii	"CMDLINE:"
 +EXPORT(__image_cmdline)
 +	.fill	0x400
 +#endif /* CONFIG_IMAGE_CMDLINE_HACK */
 +
 	__REF
 NESTED(kernel_entry, 16, sp)			# kernel entry point
--- a/target/linux/generic/patches-3.13/302-mips_no_branch_likely.patch
+++ b/target/linux/generic/patches-3.13/302-mips_no_branch_likely.patch
@ -1,11 +0,0 @@
 --- a/arch/mips/Makefile
 +++ b/arch/mips/Makefile
@@ -87,7 +87,7 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
 # machines may also.  Since BFD is incredibly buggy with respect to
 # crossformat linking we rely on the elf2ecoff tool for format conversion.
 #
 -cflags-y			+= -G 0 -mno-abicalls -fno-pic -pipe
 +cflags-y			+= -G 0 -mno-abicalls -fno-pic -pipe -mno-branch-likely
 cflags-y			+= -msoft-float
 LDFLAGS_vmlinux			+= -G 0 -static -n -nostdlib --gc-sections --sort-section=name
 KBUILD_AFLAGS_MODULE		+= -mlong-calls
--- a/target/linux/generic/patches-3.13/304-mips_disable_fpu.patch
+++ b/target/linux/generic/patches-3.13/304-mips_disable_fpu.patch
@ -1,160 +0,0 @@
 MIPS: allow disabling the kernel FPU emulator
 This patch allows turning off the in-kernel Algorithmics
 FPU emulator support, which allows one to save a couple of
 precious blocks on an embedded system.
 Signed-off-by: Florian Fainelli <florian@openwrt.org>
 --
 --- a/arch/mips/Kconfig
 +++ b/arch/mips/Kconfig
@@ -928,6 +928,17 @@ config I8259
 config MIPS_BONITO64
 	bool
 +config MIPS_FPU_EMU
 +	bool "Enable FPU emulation"
 +	default y
 +	help
 +	   This option allows building a kernel with or without the Algorithmics
 +	   FPU emulator enabled. Turning off this option results in a kernel which
 +	   does not catch floating operations exceptions. Make sure that your toolchain
 +	   is configured to enable software floating point emulation in that case.
 +
 +	   If unsure say Y here.
 +
 config MIPS_MSC
 	bool
 --- a/arch/mips/math-emu/Makefile
 +++ b/arch/mips/math-emu/Makefile
@@ -2,10 +2,12 @@
 # Makefile for the Linux/MIPS kernel FPU emulation.
 #
 -obj-y	:= cp1emu.o ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
 +obj-y	:= kernel_linkage.o
 +
 +obj-$(CONFIG_MIPS_FPU_EMU)	+= ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
 	   ieee754xcpt.o dp_frexp.o dp_modf.o dp_div.o dp_mul.o dp_sub.o \
 	   dp_add.o dp_fsp.o dp_cmp.o dp_logb.o dp_scalb.o dp_simple.o \
 	   dp_tint.o dp_fint.o dp_tlong.o dp_flong.o sp_frexp.o sp_modf.o \
 	   sp_div.o sp_mul.o sp_sub.o sp_add.o sp_fdp.o sp_cmp.o sp_logb.o \
 	   sp_scalb.o sp_simple.o sp_tint.o sp_fint.o sp_tlong.o sp_flong.o \
 -	   dp_sqrt.o sp_sqrt.o kernel_linkage.o dsemul.o
 +	   dp_sqrt.o sp_sqrt.o dsemul.o cp1emu.o
 --- a/arch/mips/math-emu/kernel_linkage.c
 +++ b/arch/mips/math-emu/kernel_linkage.c
@@ -29,6 +29,7 @@
 #define SIGNALLING_NAN 0x7ff800007ff80000LL
 +#ifdef CONFIG_MIPS_FPU_EMU
 void fpu_emulator_init_fpu(void)
 {
 	static int first = 1;
@@ -113,3 +114,36 @@ int fpu_emulator_restore_context32(struc
 	return err;
 }
 #endif
 +
 +#else
 +
 +void fpu_emulator_init_fpu(void)
 +{
 +	printk(KERN_INFO "FPU emulator disabled, make sure your toolchain"
 +		"was compiled with software floating point support (soft-float)\n");
 +	return;
 +}
 +
 +int fpu_emulator_save_context(struct sigcontext __user *sc)
 +{
 +	return 0;
 +}
 +
 +int fpu_emulator_restore_context(struct sigcontext __user *sc)
 +{
 +	return 0;
 +}
 +
 +#ifdef CONFIG_64BIT
 +int fpu_emulator_save_context32(struct sigcontext32 __user *sc)
 +{
 +	return 0;
 +}
 +
 +int fpu_emulator_restore_context32(struct sigcontext32 __user *sc)
 +{
 +	return 0;
 +}
 +#endif /* CONFIG_64BIT */
 +
 +#endif /* CONFIG_MIPS_FPU_EMU */
 --- a/arch/mips/include/asm/fpu_emulator.h
 +++ b/arch/mips/include/asm/fpu_emulator.h
@@ -27,6 +27,8 @@
 #include <asm/inst.h>
 #include <asm/local.h>
 +#ifdef CONFIG_MIPS_FPU_EMU
 +
 #ifdef CONFIG_DEBUG_FS
 struct mips_fpu_emulator_stats {
@@ -60,6 +62,38 @@ extern int fpu_emulator_cop1Handler(stru
 int process_fpemu_return(int sig, void __user *fault_addr);
 int mm_isBranchInstr(struct pt_regs *regs, struct mm_decoded_insn dec_insn,
 		     unsigned long *contpc);
 +#else
 +static inline int mips_dsemul(struct pt_regs *regs, mips_instruction ir,
 +			      unsigned long cpc)
 +{
 +	return 0;
 +}
 +
 +static inline int do_dsemulret(struct pt_regs *xcp)
 +{
 +	return 0;
 +}
 +
 +static inline int fpu_emulator_cop1Handler(struct pt_regs *xcp,
 +					   struct mips_fpu_struct *ctx,
 +					   int has_fpu,
 +					   void *__user *fault_addr)
 +{
 +	return 0;
 +}
 +
 +static inline int process_fpemu_return(int sig, void __user *fault_addr)
 +{
 +	return -EINVAL;
 +}
 +
 +static inline int mm_isBranchInstr(struct pt_regs *regs,
 +				   struct mm_decoded_insn dec_insn,
 +				   unsigned long *contpc)
 +{
 +	return 0;
 +}
 +#endif /* CONFIG_MIPS_FPU_EMU */
 /*
  * Instruction inserted following the badinst to further tag the sequence
 --- a/arch/mips/kernel/traps.c
 +++ b/arch/mips/kernel/traps.c
@@ -700,6 +700,7 @@ asmlinkage void do_ov(struct pt_regs *re
 	exception_exit(prev_state);
 }
 +#ifdef CONFIG_MIPS_FPU_EMU
 int process_fpemu_return(int sig, void __user *fault_addr)
 {
 	if (sig == SIGSEGV || sig == SIGBUS) {
@@ -723,6 +724,7 @@ int process_fpemu_return(int sig, void _
 		return 0;
 	}
 }
 +#endif /* CONFIG_MIPS_FPU_EMU */
 /*
  * XXX Delayed fp exceptions when doing a lazy ctx switch XXX
--- a/target/linux/generic/patches-3.13/305-mips_module_reloc.patch
+++ b/target/linux/generic/patches-3.13/305-mips_module_reloc.patch
@ -1,352 +0,0 @@
 --- a/arch/mips/Makefile
 +++ b/arch/mips/Makefile
@@ -90,8 +90,13 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
 cflags-y			+= -G 0 -mno-abicalls -fno-pic -pipe -mno-branch-likely
 cflags-y			+= -msoft-float
 LDFLAGS_vmlinux			+= -G 0 -static -n -nostdlib --gc-sections --sort-section=name
 +ifdef CONFIG_64BIT
 KBUILD_AFLAGS_MODULE		+= -mlong-calls
 KBUILD_CFLAGS_MODULE		+= -mlong-calls
 +else
 +KBUILD_AFLAGS_MODULE		+= -mno-long-calls
 +KBUILD_CFLAGS_MODULE		+= -mno-long-calls
 +endif
 ifndef CONFIG_FUNCTION_TRACER
 KBUILD_CFLAGS_KERNEL		+= -ffunction-sections -fdata-sections
 --- a/arch/mips/include/asm/module.h
 +++ b/arch/mips/include/asm/module.h
@@ -11,6 +11,11 @@ struct mod_arch_specific {
 	const struct exception_table_entry *dbe_start;
 	const struct exception_table_entry *dbe_end;
 	struct mips_hi16 *r_mips_hi16_list;
 +
 +	void *phys_plt_tbl;
 +	void *virt_plt_tbl;
 +	unsigned int phys_plt_offset;
 +	unsigned int virt_plt_offset;
 };
 typedef uint8_t Elf64_Byte;		/* Type for a 8-bit quantity.  */
 --- a/arch/mips/kernel/module.c
 +++ b/arch/mips/kernel/module.c
@@ -43,14 +43,222 @@ struct mips_hi16 {
 static LIST_HEAD(dbe_list);
 static DEFINE_SPINLOCK(dbe_lock);
 -#ifdef MODULE_START
 +/*
 + * Get the potential max trampolines size required of the init and
 + * non-init sections. Only used if we cannot find enough contiguous
 + * physically mapped memory to put the module into.
 + */
 +static unsigned int
 +get_plt_size(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
 +             const char *secstrings, unsigned int symindex, bool is_init)
 +{
 +	unsigned long ret = 0;
 +	unsigned int i, j;
 +	Elf_Sym *syms;
 +
 +	/* Everything marked ALLOC (this includes the exported symbols) */
 +	for (i = 1; i < hdr->e_shnum; ++i) {
 +		unsigned int info = sechdrs[i].sh_info;
 +
 +		if (sechdrs[i].sh_type != SHT_REL
 +		    && sechdrs[i].sh_type != SHT_RELA)
 +			continue;
 +
 +		/* Not a valid relocation section? */
 +		if (info >= hdr->e_shnum)
 +			continue;
 +
 +		/* Don't bother with non-allocated sections */
 +		if (!(sechdrs[info].sh_flags & SHF_ALLOC))
 +			continue;
 +
 +		/* If it's called *.init*, and we're not init, we're
 +                   not interested */
 +		if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != 0)
 +		    != is_init)
 +			continue;
 +
 +		syms = (Elf_Sym *) sechdrs[symindex].sh_addr;
 +		if (sechdrs[i].sh_type == SHT_REL) {
 +			Elf_Mips_Rel *rel = (void *) sechdrs[i].sh_addr;
 +			unsigned int size = sechdrs[i].sh_size / sizeof(*rel);
 +
 +			for (j = 0; j < size; ++j) {
 +				Elf_Sym *sym;
 +
 +				if (ELF_MIPS_R_TYPE(rel[j]) != R_MIPS_26)
 +					continue;
 +
 +				sym = syms + ELF_MIPS_R_SYM(rel[j]);
 +				if (!is_init && sym->st_shndx != SHN_UNDEF)
 +					continue;
 +
 +				ret += 4 * sizeof(int);
 +			}
 +		} else {
 +			Elf_Mips_Rela *rela = (void *) sechdrs[i].sh_addr;
 +			unsigned int size = sechdrs[i].sh_size / sizeof(*rela);
 +
 +			for (j = 0; j < size; ++j) {
 +				Elf_Sym *sym;
 +
 +				if (ELF_MIPS_R_TYPE(rela[j]) != R_MIPS_26)
 +					continue;
 +
 +				sym = syms + ELF_MIPS_R_SYM(rela[j]);
 +				if (!is_init && sym->st_shndx != SHN_UNDEF)
 +					continue;
 +
 +				ret += 4 * sizeof(int);
 +			}
 +		}
 +	}
 +
 +	return ret;
 +}
 +
 +#ifndef MODULE_START
 +static void *alloc_phys(unsigned long size)
 +{
 +	unsigned order;
 +	struct page *page;
 +	struct page *p;
 +
 +	size = PAGE_ALIGN(size);
 +	order = get_order(size);
 +
 +	page = alloc_pages(GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN |
 +			__GFP_THISNODE, order);
 +	if (!page)
 +		return NULL;
 +
 +	split_page(page, order);
 +
 +	for (p = page + (size >> PAGE_SHIFT); p < page + (1 << order); ++p)
 +		__free_page(p);
 +
 +	return page_address(page);
 +}
 +#endif
 +
 +static void free_phys(void *ptr, unsigned long size)
 +{
 +	struct page *page;
 +	struct page *end;
 +
 +	page = virt_to_page(ptr);
 +	end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT);
 +
 +	for (; page < end; ++page)
 +		__free_page(page);
 +}
 +
 +
 void *module_alloc(unsigned long size)
 {
 +#ifdef MODULE_START
 	return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
 				GFP_KERNEL, PAGE_KERNEL, NUMA_NO_NODE,
 				__builtin_return_address(0));
 +#else
 +	void *ptr;
 +
 +	if (size == 0)
 +		return NULL;
 +
 +	ptr = alloc_phys(size);
 +
 +	/* If we failed to allocate physically contiguous memory,
 +	 * fall back to regular vmalloc. The module loader code will
 +	 * create jump tables to handle long jumps */
 +	if (!ptr)
 +		return vmalloc(size);
 +
 +	return ptr;
 +#endif
 }
 +
 +static inline bool is_phys_addr(void *ptr)
 +{
 +#ifdef CONFIG_64BIT
 +	return (KSEGX((unsigned long)ptr) == CKSEG0);
 +#else
 +	return (KSEGX(ptr) == KSEG0);
 #endif
 +}
 +
 +/* Free memory returned from module_alloc */
 +void module_free(struct module *mod, void *module_region)
 +{
 +	if (is_phys_addr(module_region)) {
 +		if (mod->module_init == module_region)
 +			free_phys(module_region, mod->init_size);
 +		else if (mod->module_core == module_region)
 +			free_phys(module_region, mod->core_size);
 +		else
 +			BUG();
 +	} else {
 +		vfree(module_region);
 +	}
 +}
 +
 +static void *__module_alloc(int size, bool phys)
 +{
 +	void *ptr;
 +
 +	if (phys)
 +		ptr = kmalloc(size, GFP_KERNEL);
 +	else
 +		ptr = vmalloc(size);
 +	return ptr;
 +}
 +
 +static void __module_free(void *ptr)
 +{
 +	if (is_phys_addr(ptr))
 +		kfree(ptr);
 +	else
 +		vfree(ptr);
 +}
 +
 +int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
 +			      char *secstrings, struct module *mod)
 +{
 +	unsigned int symindex = 0;
 +	unsigned int core_size, init_size;
 +	int i;
 +
 +	mod->arch.phys_plt_offset = 0;
 +	mod->arch.virt_plt_offset = 0;
 +	mod->arch.phys_plt_tbl = NULL;
 +	mod->arch.virt_plt_tbl = NULL;
 +
 +	if (IS_ENABLED(CONFIG_64BIT))
 +		return 0;
 +
 +	for (i = 1; i < hdr->e_shnum; i++)
 +		if (sechdrs[i].sh_type == SHT_SYMTAB)
 +			symindex = i;
 +
 +	core_size = get_plt_size(hdr, sechdrs, secstrings, symindex, false);
 +	init_size = get_plt_size(hdr, sechdrs, secstrings, symindex, true);
 +
 +	if ((core_size + init_size) == 0)
 +		return 0;
 +
 +	mod->arch.phys_plt_tbl = __module_alloc(core_size + init_size, 1);
 +	if (!mod->arch.phys_plt_tbl)
 +		return -ENOMEM;
 +
 +	mod->arch.virt_plt_tbl = __module_alloc(core_size + init_size, 0);
 +	if (!mod->arch.virt_plt_tbl) {
 +		__module_free(mod->arch.phys_plt_tbl);
 +		mod->arch.phys_plt_tbl = NULL;
 +		return -ENOMEM;
 +	}
 +
 +	return 0;
 +}
 int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
 {
@@ -64,8 +272,39 @@ static int apply_r_mips_32_rel(struct mo
 	return 0;
 }
 +static Elf_Addr add_plt_entry_to(unsigned *plt_offset,
 +				 void *start, Elf_Addr v)
 +{
 +	unsigned *tramp = start + *plt_offset;
 +	*plt_offset += 4 * sizeof(int);
 +
 +	/* adjust carry for addiu */
 +	if (v & 0x00008000)
 +		v += 0x10000;
 +
 +	tramp[0] = 0x3c190000 | (v >> 16);      /* lui t9, hi16 */
 +	tramp[1] = 0x27390000 | (v & 0xffff);   /* addiu t9, t9, lo16 */
 +	tramp[2] = 0x03200008;                  /* jr t9 */
 +	tramp[3] = 0x00000000;                  /* nop */
 +
 +	return (Elf_Addr) tramp;
 +}
 +
 +static Elf_Addr add_plt_entry(struct module *me, void *location, Elf_Addr v)
 +{
 +	if (is_phys_addr(location))
 +		return add_plt_entry_to(&me->arch.phys_plt_offset,
 +				me->arch.phys_plt_tbl, v);
 +	else
 +		return add_plt_entry_to(&me->arch.virt_plt_offset,
 +				me->arch.virt_plt_tbl, v);
 +
 +}
 +
 static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
 {
 +	u32 ofs = *location & 0x03ffffff;
 +
 	if (v % 4) {
 		pr_err("module %s: dangerous R_MIPS_26 REL relocation\n",
 		       me->name);
@@ -73,14 +312,17 @@ static int apply_r_mips_26_rel(struct mo
 	}
 	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
 -		printk(KERN_ERR
 -		       "module %s: relocation overflow\n",
 -		       me->name);
 -		return -ENOEXEC;
 +		v = add_plt_entry(me, location, v + (ofs << 2));
 +		if (!v) {
 +			printk(KERN_ERR
 +				"module %s: relocation overflow\n", me->name);
 +			return -ENOEXEC;
 +		}
 +		ofs = 0;
 	}
 	*location = (*location & ~0x03ffffff) |
 -		    ((*location + (v >> 2)) & 0x03ffffff);
 +		    ((ofs + (v >> 2)) & 0x03ffffff);
 	return 0;
 }
@@ -287,11 +529,32 @@ int module_finalize(const Elf_Ehdr *hdr,
 		list_add(&me->arch.dbe_list, &dbe_list);
 		spin_unlock_irq(&dbe_lock);
 	}
 +
 +	/* Get rid of the fixup trampoline if we're running the module
 +	 * from physically mapped address space */
 +	if (me->arch.phys_plt_offset == 0) {
 +		__module_free(me->arch.phys_plt_tbl);
 +		me->arch.phys_plt_tbl = NULL;
 +	}
 +	if (me->arch.virt_plt_offset == 0) {
 +		__module_free(me->arch.virt_plt_tbl);
 +		me->arch.virt_plt_tbl = NULL;
 +	}
 +
 	return 0;
 }
 void module_arch_cleanup(struct module *mod)
 {
 +	if (mod->arch.phys_plt_tbl) {
 +		__module_free(mod->arch.phys_plt_tbl);
 +		mod->arch.phys_plt_tbl = NULL;
 +	}
 +	if (mod->arch.virt_plt_tbl) {
 +		__module_free(mod->arch.virt_plt_tbl);
 +		mod->arch.virt_plt_tbl = NULL;
 +	}
 +
 	spin_lock_irq(&dbe_lock);
 	list_del(&mod->arch.dbe_list);
 	spin_unlock_irq(&dbe_lock);
--- a/target/linux/generic/patches-3.13/306-mips_mem_functions_performance.patch
+++ b/target/linux/generic/patches-3.13/306-mips_mem_functions_performance.patch
@ -1,83 +0,0 @@
 --- a/arch/mips/include/asm/string.h
 +++ b/arch/mips/include/asm/string.h
@@ -133,11 +133,44 @@ strncmp(__const__ char *__cs, __const__
 #define __HAVE_ARCH_MEMSET
 extern void *memset(void *__s, int __c, size_t __count);
 +#define memset(__s, __c, len)					\
 +({								\
 +	size_t __len = (len);					\
 +	void *__ret;						\
 +	if (__builtin_constant_p(len) && __len >= 64)		\
 +		__ret = memset((__s), (__c), __len);		\
 +	else							\
 +		__ret = __builtin_memset((__s), (__c), __len);	\
 +	__ret;							\
 +})
 #define __HAVE_ARCH_MEMCPY
 extern void *memcpy(void *__to, __const__ void *__from, size_t __n);
 +#define memcpy(dst, src, len)					\
 +({								\
 +	size_t __len = (len);					\
 +	void *__ret;						\
 +	if (__builtin_constant_p(len) && __len >= 64)		\
 +		__ret = memcpy((dst), (src), __len);		\
 +	else							\
 +		__ret = __builtin_memcpy((dst), (src), __len);	\
 +	__ret;							\
 +})
 #define __HAVE_ARCH_MEMMOVE
 extern void *memmove(void *__dest, __const__ void *__src, size_t __n);
 +#define memmove(dst, src, len)					\
 +({								\
 +	size_t __len = (len);					\
 +	void *__ret;						\
 +	if (__builtin_constant_p(len) && __len >= 64)		\
 +		__ret = memmove((dst), (src), __len);		\
 +	else							\
 +		__ret = __builtin_memmove((dst), (src), __len);	\
 +	__ret;							\
 +})
 +
 +#define __HAVE_ARCH_MEMCMP
 +#define memcmp(src1, src2, len) __builtin_memcmp((src1), (src2), (len))
 #endif /* _ASM_STRING_H */
 --- a/arch/mips/lib/Makefile
 +++ b/arch/mips/lib/Makefile
@@ -4,7 +4,7 @@
 lib-y	+= bitops.o csum_partial.o delay.o memcpy.o memset.o \
 	   mips-atomic.o strlen_user.o strncpy_user.o \
 -	   strnlen_user.o uncached.o
 +	   strnlen_user.o uncached.o memcmp.o
 obj-y			+= iomap.o
 obj-$(CONFIG_PCI)	+= iomap-pci.o
 --- /dev/null
 +++ b/arch/mips/lib/memcmp.c
@@ -0,0 +1,22 @@
 +/*
 + *  copied from linux/lib/string.c
 + *
 + *  Copyright (C) 1991, 1992  Linus Torvalds
 + */
 +
 +#include <linux/module.h>
 +#include <linux/string.h>
 +
 +#undef memcmp
 +int memcmp(const void *cs, const void *ct, size_t count)
 +{
 +	const unsigned char *su1, *su2;
 +	int res = 0;
 +
 +	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 +		if ((res = *su1 - *su2) != 0)
 +			break;
 +	return res;
 +}
 +EXPORT_SYMBOL(memcmp);
 +
--- a/target/linux/generic/patches-3.13/309-mips_fuse_workaround.patch
+++ b/target/linux/generic/patches-3.13/309-mips_fuse_workaround.patch
@ -1,32 +0,0 @@
 --- a/arch/mips/mm/cache.c
 +++ b/arch/mips/mm/cache.c
@@ -39,6 +39,7 @@ void (*__flush_kernel_vmap_range)(unsign
 void (*__invalidate_kernel_vmap_range)(unsigned long vaddr, int size);
 EXPORT_SYMBOL_GPL(__flush_kernel_vmap_range);
 +EXPORT_SYMBOL(__flush_cache_all);
 /* MIPS specific cache operations */
 void (*flush_cache_sigtramp)(unsigned long addr);
 --- a/fs/fuse/dev.c
 +++ b/fs/fuse/dev.c
@@ -20,6 +20,9 @@
 #include <linux/swap.h>
 #include <linux/splice.h>
 #include <linux/aio.h>
 +#ifdef CONFIG_MIPS
 +#include <asm/cacheflush.h>
 +#endif
 MODULE_ALIAS_MISCDEV(FUSE_MINOR);
 MODULE_ALIAS("devname:fuse");
@@ -759,6 +762,9 @@ static int fuse_copy_fill(struct fuse_co
 static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
 {
 	unsigned ncpy = min(*size, cs->len);
 +#ifdef CONFIG_MIPS
 +	__flush_cache_all();
 +#endif
 	if (val) {
 		if (cs->write)
 			memcpy(cs->buf, *val, ncpy);
--- a/target/linux/generic/patches-3.13/310-arm_module_unresolved_weak_sym.patch
+++ b/target/linux/generic/patches-3.13/310-arm_module_unresolved_weak_sym.patch
@ -1,13 +0,0 @@
 --- a/arch/arm/kernel/module.c
 +++ b/arch/arm/kernel/module.c
@@ -83,6 +83,10 @@ apply_relocate(Elf32_Shdr *sechdrs, cons
 			return -ENOEXEC;
 		}
 +		if ((IS_ERR_VALUE(sym->st_value) || !sym->st_value) &&
 +		    ELF_ST_BIND(sym->st_info) == STB_WEAK)
 +			continue;
 +
 		loc = dstsec->sh_addr + rel->r_offset;
 		switch (ELF32_R_TYPE(rel->r_info)) {
--- a/target/linux/generic/patches-3.13/320-ppc4xx_optimization.patch
+++ b/target/linux/generic/patches-3.13/320-ppc4xx_optimization.patch
@ -1,31 +0,0 @@
 Upstream doesn't optimize the kernel and bootwrappers for ppc44x because
 they still want to support gcc 3.3 -- well, we don't.
 --- a/arch/powerpc/Makefile
 +++ b/arch/powerpc/Makefile
@@ -189,7 +189,8 @@ ifeq ($(CONFIG_FUNCTION_TRACER),y)
 KBUILD_CFLAGS		+= -mno-sched-epilog
 endif
 -cpu-as-$(CONFIG_4xx)		+= -Wa,-m405
 +cpu-as-$(CONFIG_40x)		+= -Wa,-m405
 +cpu-as-$(CONFIG_44x)		+= -Wa,-m440
 cpu-as-$(CONFIG_ALTIVEC)	+= -Wa,-maltivec
 cpu-as-$(CONFIG_E200)		+= -Wa,-me200
 --- a/arch/powerpc/boot/Makefile
 +++ b/arch/powerpc/boot/Makefile
@@ -39,10 +39,10 @@ BOOTCFLAGS	+= -I$(obj) -I$(srctree)/$(ob
 DTC_FLAGS	?= -p 1024
 $(obj)/4xx.o: BOOTCFLAGS += -mcpu=405
 -$(obj)/ebony.o: BOOTCFLAGS += -mcpu=405
 +$(obj)/ebony.o: BOOTCFLAGS += -mcpu=440
 $(obj)/cuboot-hotfoot.o: BOOTCFLAGS += -mcpu=405
 -$(obj)/cuboot-taishan.o: BOOTCFLAGS += -mcpu=405
 -$(obj)/cuboot-katmai.o: BOOTCFLAGS += -mcpu=405
 +$(obj)/cuboot-taishan.o: BOOTCFLAGS += -mcpu=440
 +$(obj)/cuboot-katmai.o: BOOTCFLAGS += -mcpu=440
 $(obj)/cuboot-acadia.o: BOOTCFLAGS += -mcpu=405
 $(obj)/treeboot-walnut.o: BOOTCFLAGS += -mcpu=405
 $(obj)/treeboot-iss4xx.o: BOOTCFLAGS += -mcpu=405
--- a/target/linux/generic/patches-3.13/321-powerpc_crtsavres_prereq.patch
+++ b/target/linux/generic/patches-3.13/321-powerpc_crtsavres_prereq.patch
@ -1,10 +0,0 @@
 --- a/arch/powerpc/Makefile
 +++ b/arch/powerpc/Makefile
@@ -156,7 +156,6 @@ CPP		= $(CC) -E $(KBUILD_CFLAGS)
 CHECKFLAGS	+= -m$(CONFIG_WORD_SIZE) -D__powerpc__ -D__powerpc$(CONFIG_WORD_SIZE)__
 -KBUILD_LDFLAGS_MODULE += arch/powerpc/lib/crtsavres.o
 # No AltiVec or VSX instructions when building kernel
 KBUILD_CFLAGS += $(call cc-option,-mno-altivec)
--- a/target/linux/generic/patches-3.13/400-mtd-add-rootfs-split-support.patch
+++ b/target/linux/generic/patches-3.13/400-mtd-add-rootfs-split-support.patch
@ -1,289 +0,0 @@
 --- a/drivers/mtd/Kconfig
 +++ b/drivers/mtd/Kconfig
@@ -12,6 +12,32 @@ menuconfig MTD
 if MTD
 +menu "OpenWrt specific MTD options"
 +
 +config MTD_ROOTFS_ROOT_DEV
 +	bool "Automatically set 'rootfs' partition to be root filesystem"
 +	default y
 +
 +config MTD_ROOTFS_SPLIT
 +	bool "Automatically split 'rootfs' partition for squashfs"
 +	default y
 +
 +config MTD_SPLIT_FIRMWARE
 +	bool "Automatically split firmware partition for kernel+rootfs"
 +	default y
 +
 +config MTD_SPLIT_FIRMWARE_NAME
 +	string "Firmware partition name"
 +	depends on MTD_SPLIT_FIRMWARE
 +	default "firmware"
 +
 +config MTD_UIMAGE_SPLIT
 +	bool "Enable split support for firmware partitions containing a uImage"
 +	depends on MTD_SPLIT_FIRMWARE
 +	default y
 +
 +endmenu
 +
 config MTD_TESTS
 	tristate "MTD tests support (DANGEROUS)"
 	depends on m
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -29,9 +29,11 @@
 #include <linux/kmod.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 +#include <linux/magic.h>
 #include <linux/err.h>
 #include "mtdcore.h"
 +#include "mtdsplit/mtdsplit.h"
 /* Our partition linked list */
 static LIST_HEAD(mtd_partitions);
@@ -45,13 +47,14 @@ struct mtd_part {
 	struct list_head list;
 };
 +static void mtd_partition_split(struct mtd_info *master, struct mtd_part *part);
 +
 /*
  * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
  * the pointer to that structure with this macro.
  */
 #define PART(x)  ((struct mtd_part *)(x))
 -
 /*
  * MTD methods which simply translate the effective address and pass through
  * to the _real_ device.
@@ -534,8 +537,10 @@ out_register:
 	return slave;
 }
 -int mtd_add_partition(struct mtd_info *master, char *name,
 -		      long long offset, long long length)
 +
 +static int
 +__mtd_add_partition(struct mtd_info *master, char *name,
 +		    long long offset, long long length, bool dup_check)
 {
 	struct mtd_partition part;
 	struct mtd_part *p, *new;
@@ -567,21 +572,24 @@ int mtd_add_partition(struct mtd_info *m
 	end = offset + length;
 	mutex_lock(&mtd_partitions_mutex);
 -	list_for_each_entry(p, &mtd_partitions, list)
 -		if (p->master == master) {
 -			if ((start >= p->offset) &&
 -			    (start < (p->offset + p->mtd.size)))
 -				goto err_inv;
 -
 -			if ((end >= p->offset) &&
 -			    (end < (p->offset + p->mtd.size)))
 -				goto err_inv;
 -		}
 +	if (dup_check) {
 +		list_for_each_entry(p, &mtd_partitions, list)
 +			if (p->master == master) {
 +				if ((start >= p->offset) &&
 +				    (start < (p->offset + p->mtd.size)))
 +					goto err_inv;
 +
 +				if ((end >= p->offset) &&
 +				    (end < (p->offset + p->mtd.size)))
 +					goto err_inv;
 +			}
 +	}
 	list_add(&new->list, &mtd_partitions);
 	mutex_unlock(&mtd_partitions_mutex);
 	add_mtd_device(&new->mtd);
 +	mtd_partition_split(master, new);
 	return ret;
 err_inv:
@@ -591,6 +599,12 @@ err_inv:
 }
 EXPORT_SYMBOL_GPL(mtd_add_partition);
 +int mtd_add_partition(struct mtd_info *master, char *name,
 +		      long long offset, long long length)
 +{
 +	return __mtd_add_partition(master, name, offset, length, true);
 +}
 +
 int mtd_del_partition(struct mtd_info *master, int partno)
 {
 	struct mtd_part *slave, *next;
@@ -614,6 +628,144 @@ int mtd_del_partition(struct mtd_info *m
 }
 EXPORT_SYMBOL_GPL(mtd_del_partition);
 +static inline unsigned long
 +mtd_pad_erasesize(struct mtd_info *mtd, int offset, int len)
 +{
 +	unsigned long mask = mtd->erasesize - 1;
 +
 +	len += offset & mask;
 +	len = (len + mask) & ~mask;
 +	len -= offset & mask;
 +	return len;
 +}
 +
 +#define ROOTFS_SPLIT_NAME "rootfs_data"
 +
 +struct squashfs_super_block {
 +	__le32 s_magic;
 +	__le32 pad0[9];
 +	__le64 bytes_used;
 +};
 +
 +
 +static int split_squashfs(struct mtd_info *master, int offset, int *split_offset)
 +{
 +	struct squashfs_super_block sb;
 +	int len, ret;
 +
 +	ret = mtd_read(master, offset, sizeof(sb), &len, (void *) &sb);
 +	if (ret || (len != sizeof(sb))) {
 +		printk(KERN_ALERT "split_squashfs: error occured while reading "
 +			"from \"%s\"\n", master->name);
 +		return -EINVAL;
 +	}
 +
 +	if (SQUASHFS_MAGIC != le32_to_cpu(sb.s_magic) ) {
 +		printk(KERN_ALERT "split_squashfs: no squashfs found in \"%s\"\n",
 +			master->name);
 +		*split_offset = 0;
 +		return 0;
 +	}
 +
 +	if (le64_to_cpu((sb.bytes_used)) <= 0) {
 +		printk(KERN_ALERT "split_squashfs: squashfs is empty in \"%s\"\n",
 +			master->name);
 +		*split_offset = 0;
 +		return 0;
 +	}
 +
 +	len = (u32) le64_to_cpu(sb.bytes_used);
 +	len = mtd_pad_erasesize(master, offset, len);
 +	*split_offset = offset + len;
 +
 +	return 0;
 +}
 +
 +static void split_rootfs_data(struct mtd_info *master, struct mtd_part *part)
 +{
 +	unsigned int split_offset = 0;
 +	unsigned int split_size;
 +	int ret;
 +
 +	ret = split_squashfs(master, part->offset, &split_offset);
 +	if (ret)
 +		return;
 +
 +	if (split_offset <= 0)
 +		return;
 +
 +	split_size = part->mtd.size - (split_offset - part->offset);
 +	printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=0x%x, len=0x%x\n",
 +		ROOTFS_SPLIT_NAME, split_offset, split_size);
 +
 +	__mtd_add_partition(master, ROOTFS_SPLIT_NAME, split_offset,
 +			    split_size, false);
 +}
 +
 +#define UBOOT_MAGIC	0x27051956
 +
 +static void split_uimage(struct mtd_info *master, struct mtd_part *part)
 +{
 +	struct {
 +		__be32 magic;
 +		__be32 pad[2];
 +		__be32 size;
 +	} hdr;
 +	size_t len;
 +
 +	if (mtd_read(master, part->offset, sizeof(hdr), &len, (void *) &hdr))
 +		return;
 +
 +	if (len != sizeof(hdr) || hdr.magic != cpu_to_be32(UBOOT_MAGIC))
 +		return;
 +
 +	len = be32_to_cpu(hdr.size) + 0x40;
 +	len = mtd_pad_erasesize(master, part->offset, len);
 +	if (len + master->erasesize > part->mtd.size)
 +		return;
 +
 +	__mtd_add_partition(master, "rootfs", part->offset + len,
 +			    part->mtd.size - len, false);
 +}
 +
 +#ifdef CONFIG_MTD_SPLIT_FIRMWARE_NAME
 +#define SPLIT_FIRMWARE_NAME	CONFIG_MTD_SPLIT_FIRMWARE_NAME
 +#else
 +#define SPLIT_FIRMWARE_NAME	"unused"
 +#endif
 +
 +static void split_firmware(struct mtd_info *master, struct mtd_part *part)
 +{
 +	if (config_enabled(CONFIG_MTD_UIMAGE_SPLIT))
 +		split_uimage(master, part);
 +}
 +
 +void __weak arch_split_mtd_part(struct mtd_info *master, const char *name,
 +                                int offset, int size)
 +{
 +}
 +
 +static void mtd_partition_split(struct mtd_info *master, struct mtd_part *part)
 +{
 +	static int rootfs_found = 0;
 +
 +	if (rootfs_found)
 +		return;
 +
 +	if (!strcmp(part->mtd.name, "rootfs")) {
 +		rootfs_found = 1;
 +
 +		if (config_enabled(CONFIG_MTD_ROOTFS_SPLIT))
 +			split_rootfs_data(master, part);
 +	}
 +
 +	if (!strcmp(part->mtd.name, SPLIT_FIRMWARE_NAME) &&
 +	    config_enabled(CONFIG_MTD_SPLIT_FIRMWARE))
 +		split_firmware(master, part);
 +
 +	arch_split_mtd_part(master, part->mtd.name, part->offset,
 +			    part->mtd.size);
 +}
 /*
  * This function, given a master MTD object and a partition table, creates
  * and registers slave MTD objects which are bound to the master according to
@@ -643,6 +795,7 @@ int add_mtd_partitions(struct mtd_info *
 		mutex_unlock(&mtd_partitions_mutex);
 		add_mtd_device(&slave->mtd);
 +		mtd_partition_split(master, slave);
 		cur_offset = slave->offset + slave->mtd.size;
 	}
 --- a/include/linux/mtd/partitions.h
 +++ b/include/linux/mtd/partitions.h
@@ -84,5 +84,7 @@ int mtd_add_partition(struct mtd_info *m
 		      long long offset, long long length);
 int mtd_del_partition(struct mtd_info *master, int partno);
 uint64_t mtd_get_device_size(const struct mtd_info *mtd);
 +extern void __weak arch_split_mtd_part(struct mtd_info *master,
 +				       const char *name, int offset, int size);
 #endif
--- a/target/linux/generic/patches-3.13/401-mtd-add-support-for-different-partition-parser-types.patch
+++ b/target/linux/generic/patches-3.13/401-mtd-add-support-for-different-partition-parser-types.patch
@ -1,113 +0,0 @@
 From 02cff0ccaa6d364f5c1eeea83f47ac80ccc967d4 Mon Sep 17 00:00:00 2001
 From: Gabor Juhos <juhosg@openwrt.org>
 Date: Tue, 3 Sep 2013 18:11:50 +0200
 Subject: [PATCH] mtd: add support for different partition parser types
 Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
 ---
 drivers/mtd/mtdpart.c          |   56 ++++++++++++++++++++++++++++++++++++++++
 include/linux/mtd/partitions.h |   11 ++++++++
 2 files changed, 67 insertions(+)
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -825,6 +825,30 @@ static struct mtd_part_parser *get_parti
 #define put_partition_parser(p) do { module_put((p)->owner); } while (0)
 +static struct mtd_part_parser *
 +get_partition_parser_by_type(enum mtd_parser_type type,
 +			     struct mtd_part_parser *start)
 +{
 +	struct mtd_part_parser *p, *ret = NULL;
 +
 +	spin_lock(&part_parser_lock);
 +
 +	p = list_prepare_entry(start, &part_parsers, list);
 +	if (start)
 +		put_partition_parser(start);
 +
 +	list_for_each_entry_continue(p, &part_parsers, list) {
 +		if (p->type == type && try_module_get(p->owner)) {
 +			ret = p;
 +			break;
 +		}
 +	}
 +
 +	spin_unlock(&part_parser_lock);
 +
 +	return ret;
 +}
 +
 int register_mtd_parser(struct mtd_part_parser *p)
 {
 	spin_lock(&part_parser_lock);
@@ -901,6 +925,38 @@ int parse_mtd_partitions(struct mtd_info
 	return ret;
 }
 +int parse_mtd_partitions_by_type(struct mtd_info *master,
 +				 enum mtd_parser_type type,
 +				 struct mtd_partition **pparts,
 +				 struct mtd_part_parser_data *data)
 +{
 +	struct mtd_part_parser *prev = NULL;
 +	int ret = 0;
 +
 +	while (1) {
 +		struct mtd_part_parser *parser;
 +
 +		parser = get_partition_parser_by_type(type, prev);
 +		if (!parser)
 +			break;
 +
 +		ret = (*parser->parse_fn)(master, pparts, data);
 +
 +		if (ret > 0) {
 +			put_partition_parser(parser);
 +			printk(KERN_NOTICE
 +			       "%d %s partitions found on MTD device %s\n",
 +			       ret, parser->name, master->name);
 +			break;
 +		}
 +
 +		prev = parser;
 +	}
 +
 +	return ret;
 +}
 +EXPORT_SYMBOL_GPL(parse_mtd_partitions_by_type);
 +
 int mtd_is_partition(const struct mtd_info *mtd)
 {
 	struct mtd_part *part;
 --- a/include/linux/mtd/partitions.h
 +++ b/include/linux/mtd/partitions.h
@@ -68,12 +68,17 @@ struct mtd_part_parser_data {
  * Functions dealing with the various ways of partitioning the space
  */
 +enum mtd_parser_type {
 +	MTD_PARSER_TYPE_DEVICE = 0,
 +};
 +
 struct mtd_part_parser {
 	struct list_head list;
 	struct module *owner;
 	const char *name;
 	int (*parse_fn)(struct mtd_info *, struct mtd_partition **,
 			struct mtd_part_parser_data *);
 +	enum mtd_parser_type type;
 };
 extern int register_mtd_parser(struct mtd_part_parser *parser);
@@ -87,4 +92,9 @@ uint64_t mtd_get_device_size(const struc
 extern void __weak arch_split_mtd_part(struct mtd_info *master,
 				       const char *name, int offset, int size);
 +int parse_mtd_partitions_by_type(struct mtd_info *master,
 +				 enum mtd_parser_type type,
 +				 struct mtd_partition **pparts,
 +				 struct mtd_part_parser_data *data);
 +
 #endif
--- a/target/linux/generic/patches-3.13/402-mtd-use-typed-mtd-parsers-for-rootfs-and-firmware-split.patch
+++ b/target/linux/generic/patches-3.13/402-mtd-use-typed-mtd-parsers-for-rootfs-and-firmware-split.patch
@ -1,75 +0,0 @@
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -628,6 +628,37 @@ int mtd_del_partition(struct mtd_info *m
 }
 EXPORT_SYMBOL_GPL(mtd_del_partition);
 +static int
 +run_parsers_by_type(struct mtd_part *slave, enum mtd_parser_type type)
 +{
 +	struct mtd_partition *parts;
 +	int nr_parts;
 +	int i;
 +
 +	nr_parts = parse_mtd_partitions_by_type(&slave->mtd, type, &parts,
 +						NULL);
 +	if (nr_parts <= 0)
 +		return nr_parts;
 +
 +	if (WARN_ON(!parts))
 +		return 0;
 +
 +	for (i = 0; i < nr_parts; i++) {
 +		/* adjust partition offsets */
 +		parts[i].offset += slave->offset;
 +
 +		__mtd_add_partition(slave->master,
 +				    parts[i].name,
 +				    parts[i].offset,
 +				    parts[i].size,
 +				    false);
 +	}
 +
 +	kfree(parts);
 +
 +	return nr_parts;
 +}
 +
 static inline unsigned long
 mtd_pad_erasesize(struct mtd_info *mtd, int offset, int len)
 {
@@ -687,6 +718,10 @@ static void split_rootfs_data(struct mtd
 	unsigned int split_size;
 	int ret;
 +	ret = run_parsers_by_type(part, MTD_PARSER_TYPE_ROOTFS);
 +	if (ret > 0)
 +		return;
 +
 	ret = split_squashfs(master, part->offset, &split_offset);
 	if (ret)
 		return;
@@ -736,6 +771,12 @@ static void split_uimage(struct mtd_info
 static void split_firmware(struct mtd_info *master, struct mtd_part *part)
 {
 +	int ret;
 +
 +	ret = run_parsers_by_type(part, MTD_PARSER_TYPE_FIRMWARE);
 +	if (ret > 0)
 +		return;
 +
 	if (config_enabled(CONFIG_MTD_UIMAGE_SPLIT))
 		split_uimage(master, part);
 }
 --- a/include/linux/mtd/partitions.h
 +++ b/include/linux/mtd/partitions.h
@@ -70,6 +70,8 @@ struct mtd_part_parser_data {
 enum mtd_parser_type {
 	MTD_PARSER_TYPE_DEVICE = 0,
 +	MTD_PARSER_TYPE_ROOTFS,
 +	MTD_PARSER_TYPE_FIRMWARE,
 };
 struct mtd_part_parser {
--- a/target/linux/generic/patches-3.13/403-mtd-hook-mtdsplit-to-Kbuild.patch
+++ b/target/linux/generic/patches-3.13/403-mtd-hook-mtdsplit-to-Kbuild.patch
@ -1,22 +0,0 @@
 --- a/drivers/mtd/Kconfig
 +++ b/drivers/mtd/Kconfig
@@ -36,6 +36,8 @@ config MTD_UIMAGE_SPLIT
 	depends on MTD_SPLIT_FIRMWARE
 	default y
 +source "drivers/mtd/mtdsplit/Kconfig"
 +
 endmenu
 config MTD_TESTS
 --- a/drivers/mtd/Makefile
 +++ b/drivers/mtd/Makefile
@@ -6,6 +6,8 @@
 obj-$(CONFIG_MTD)		+= mtd.o
 mtd-y				:= mtdcore.o mtdsuper.o mtdconcat.o mtdpart.o mtdchar.o
 +obj-$(CONFIG_MTD_SPLIT)		+= mtdsplit/
 +
 obj-$(CONFIG_MTD_OF_PARTS)	+= ofpart.o
 obj-$(CONFIG_MTD_REDBOOT_PARTS) += redboot.o
 obj-$(CONFIG_MTD_CMDLINE_PARTS) += cmdlinepart.o
--- a/target/linux/generic/patches-3.13/404-mtd-use-mtd_get_squashfs_len-in-split_squasfh.patch
+++ b/target/linux/generic/patches-3.13/404-mtd-use-mtd_get_squashfs_len-in-split_squasfh.patch
@ -1,61 +0,0 @@
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -670,43 +670,16 @@ mtd_pad_erasesize(struct mtd_info *mtd, 
 	return len;
 }
 -#define ROOTFS_SPLIT_NAME "rootfs_data"
 -
 -struct squashfs_super_block {
 -	__le32 s_magic;
 -	__le32 pad0[9];
 -	__le64 bytes_used;
 -};
 -
 -
 static int split_squashfs(struct mtd_info *master, int offset, int *split_offset)
 {
 -	struct squashfs_super_block sb;
 +	size_t squashfs_len;
 	int len, ret;
 -	ret = mtd_read(master, offset, sizeof(sb), &len, (void *) &sb);
 -	if (ret || (len != sizeof(sb))) {
 -		printk(KERN_ALERT "split_squashfs: error occured while reading "
 -			"from \"%s\"\n", master->name);
 -		return -EINVAL;
 -	}
 -
 -	if (SQUASHFS_MAGIC != le32_to_cpu(sb.s_magic) ) {
 -		printk(KERN_ALERT "split_squashfs: no squashfs found in \"%s\"\n",
 -			master->name);
 -		*split_offset = 0;
 -		return 0;
 -	}
 -
 -	if (le64_to_cpu((sb.bytes_used)) <= 0) {
 -		printk(KERN_ALERT "split_squashfs: squashfs is empty in \"%s\"\n",
 -			master->name);
 -		*split_offset = 0;
 -		return 0;
 -	}
 +	ret = mtd_get_squashfs_len(master, offset, &squashfs_len);
 +	if (ret)
 +		return ret;
 -	len = (u32) le64_to_cpu(sb.bytes_used);
 -	len = mtd_pad_erasesize(master, offset, len);
 +	len = mtd_pad_erasesize(master, offset, squashfs_len);
 	*split_offset = offset + len;
 	return 0;
 --- a/drivers/mtd/Kconfig
 +++ b/drivers/mtd/Kconfig
@@ -20,6 +20,7 @@ config MTD_ROOTFS_ROOT_DEV
 config MTD_ROOTFS_SPLIT
 	bool "Automatically split 'rootfs' partition for squashfs"
 +	select MTD_SPLIT
 	default y
 config MTD_SPLIT_FIRMWARE
--- a/target/linux/generic/patches-3.13/405-mtd-add-more-helper-functions.patch
+++ b/target/linux/generic/patches-3.13/405-mtd-add-more-helper-functions.patch
@ -1,83 +0,0 @@
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -434,14 +434,12 @@ static struct mtd_part *allocate_partiti
 	if (slave->offset == MTDPART_OFS_APPEND)
 		slave->offset = cur_offset;
 	if (slave->offset == MTDPART_OFS_NXTBLK) {
 -		slave->offset = cur_offset;
 -		if (mtd_mod_by_eb(cur_offset, master) != 0) {
 -			/* Round up to next erasesize */
 -			slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
 +		/* Round up to next erasesize */
 +		slave->offset = mtd_roundup_to_eb(cur_offset, master);
 +		if (slave->offset != cur_offset)
 			printk(KERN_NOTICE "Moving partition %d: "
 			       "0x%012llx -> 0x%012llx\n", partno,
 			       (unsigned long long)cur_offset, (unsigned long long)slave->offset);
 -		}
 	}
 	if (slave->offset == MTDPART_OFS_RETAIN) {
 		slave->offset = cur_offset;
@@ -988,6 +986,24 @@ int mtd_is_partition(const struct mtd_in
 }
 EXPORT_SYMBOL_GPL(mtd_is_partition);
 +struct mtd_info *mtdpart_get_master(const struct mtd_info *mtd)
 +{
 +	if (!mtd_is_partition(mtd))
 +		return (struct mtd_info *)mtd;
 +
 +	return PART(mtd)->master;
 +}
 +EXPORT_SYMBOL_GPL(mtdpart_get_master);
 +
 +uint64_t mtdpart_get_offset(const struct mtd_info *mtd)
 +{
 +	if (!mtd_is_partition(mtd))
 +		return 0;
 +
 +	return PART(mtd)->offset;
 +}
 +EXPORT_SYMBOL_GPL(mtdpart_get_offset);
 +
 /* Returns the size of the entire flash chip */
 uint64_t mtd_get_device_size(const struct mtd_info *mtd)
 {
 --- a/include/linux/mtd/partitions.h
 +++ b/include/linux/mtd/partitions.h
@@ -90,6 +90,8 @@ int mtd_is_partition(const struct mtd_in
 int mtd_add_partition(struct mtd_info *master, char *name,
 		      long long offset, long long length);
 int mtd_del_partition(struct mtd_info *master, int partno);
 +struct mtd_info *mtdpart_get_master(const struct mtd_info *mtd);
 +uint64_t mtdpart_get_offset(const struct mtd_info *mtd);
 uint64_t mtd_get_device_size(const struct mtd_info *mtd);
 extern void __weak arch_split_mtd_part(struct mtd_info *master,
 				       const char *name, int offset, int size);
 --- a/include/linux/mtd/mtd.h
 +++ b/include/linux/mtd/mtd.h
@@ -331,6 +331,24 @@ static inline uint32_t mtd_mod_by_eb(uin
 	return do_div(sz, mtd->erasesize);
 }
 +static inline uint64_t mtd_roundup_to_eb(uint64_t sz, struct mtd_info *mtd)
 +{
 +	if (mtd_mod_by_eb(sz, mtd) == 0)
 +		return sz;
 +
 +	/* Round up to next erase block */
 +	return (mtd_div_by_eb(sz, mtd) + 1) * mtd->erasesize;
 +}
 +
 +static inline uint64_t mtd_rounddown_to_eb(uint64_t sz, struct mtd_info *mtd)
 +{
 +	if (mtd_mod_by_eb(sz, mtd) == 0)
 +		return sz;
 +
 +	/* Round down to the start of the current erase block */
 +	return (mtd_div_by_eb(sz, mtd)) * mtd->erasesize;
 +}
 +
 static inline uint32_t mtd_div_by_ws(uint64_t sz, struct mtd_info *mtd)
 {
 	if (mtd->writesize_shift)
--- a/target/linux/generic/patches-3.13/410-mtd-move-forward-declaration-of-struct-mtd_info.patch
+++ b/target/linux/generic/patches-3.13/410-mtd-move-forward-declaration-of-struct-mtd_info.patch
@ -1,18 +0,0 @@
 --- a/include/linux/mtd/partitions.h
 +++ b/include/linux/mtd/partitions.h
@@ -35,6 +35,7 @@
  * Note: writeable partitions require their size and offset be
  * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
  */
 +struct mtd_info;
 struct mtd_partition {
 	char *name;			/* identifier string */
@@ -50,7 +51,6 @@ struct mtd_partition {
 #define MTDPART_SIZ_FULL	(0)
 -struct mtd_info;
 struct device_node;
 /**
--- a/target/linux/generic/patches-3.13/411-mtd-partial_eraseblock_write.patch
+++ b/target/linux/generic/patches-3.13/411-mtd-partial_eraseblock_write.patch
@ -1,146 +0,0 @@
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -35,6 +35,8 @@
 #include "mtdcore.h"
 #include "mtdsplit/mtdsplit.h"
 +#define MTD_ERASE_PARTIAL	0x8000 /* partition only covers parts of an erase block */
 +
 /* Our partition linked list */
 static LIST_HEAD(mtd_partitions);
 static DEFINE_MUTEX(mtd_partitions_mutex);
@@ -231,13 +233,61 @@ static int part_erase(struct mtd_info *m
 	struct mtd_part *part = PART(mtd);
 	int ret;
 +
 +	instr->partial_start = false;
 +	if (mtd->flags & MTD_ERASE_PARTIAL) {
 +		size_t readlen = 0;
 +		u64 mtd_ofs;
 +
 +		instr->erase_buf = kmalloc(part->master->erasesize, GFP_ATOMIC);
 +		if (!instr->erase_buf)
 +			return -ENOMEM;
 +
 +		mtd_ofs = part->offset + instr->addr;
 +		instr->erase_buf_ofs = do_div(mtd_ofs, part->master->erasesize);
 +
 +		if (instr->erase_buf_ofs > 0) {
 +			instr->addr -= instr->erase_buf_ofs;
 +			ret = mtd_read(part->master,
 +				instr->addr + part->offset,
 +				part->master->erasesize,
 +				&readlen, instr->erase_buf);
 +
 +			instr->len += instr->erase_buf_ofs;
 +			instr->partial_start = true;
 +		} else {
 +			mtd_ofs = part->offset + part->mtd.size;
 +			instr->erase_buf_ofs = part->master->erasesize -
 +				do_div(mtd_ofs, part->master->erasesize);
 +
 +			if (instr->erase_buf_ofs > 0) {
 +				instr->len += instr->erase_buf_ofs;
 +				ret = mtd_read(part->master,
 +					part->offset + instr->addr +
 +					instr->len - part->master->erasesize,
 +					part->master->erasesize, &readlen,
 +					instr->erase_buf);
 +			} else {
 +				ret = 0;
 +			}
 +		}
 +		if (ret < 0) {
 +			kfree(instr->erase_buf);
 +			return ret;
 +		}
 +
 +	}
 +
 	instr->addr += part->offset;
 	ret = part->master->_erase(part->master, instr);
 	if (ret) {
 		if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 			instr->fail_addr -= part->offset;
 		instr->addr -= part->offset;
 +		if (mtd->flags & MTD_ERASE_PARTIAL)
 +			kfree(instr->erase_buf);
 	}
 +
 	return ret;
 }
@@ -245,7 +295,25 @@ void mtd_erase_callback(struct erase_inf
 {
 	if (instr->mtd->_erase == part_erase) {
 		struct mtd_part *part = PART(instr->mtd);
 +		size_t wrlen = 0;
 +		if (instr->mtd->flags & MTD_ERASE_PARTIAL) {
 +			if (instr->partial_start) {
 +				part->master->_write(part->master,
 +					instr->addr, instr->erase_buf_ofs,
 +					&wrlen, instr->erase_buf);
 +				instr->addr += instr->erase_buf_ofs;
 +			} else {
 +				instr->len -= instr->erase_buf_ofs;
 +				part->master->_write(part->master,
 +					instr->addr + instr->len,
 +					instr->erase_buf_ofs, &wrlen,
 +					instr->erase_buf +
 +					part->master->erasesize -
 +					instr->erase_buf_ofs);
 +			}
 +			kfree(instr->erase_buf);
 +		}
 		if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 			instr->fail_addr -= part->offset;
 		instr->addr -= part->offset;
@@ -503,18 +571,24 @@ static struct mtd_part *allocate_partiti
 	if ((slave->mtd.flags & MTD_WRITEABLE) &&
 	    mtd_mod_by_eb(slave->offset, &slave->mtd)) {
 		/* Doesn't start on a boundary of major erase size */
 -		/* FIXME: Let it be writable if it is on a boundary of
 -		 * _minor_ erase size though */
 -		slave->mtd.flags &= ~MTD_WRITEABLE;
 -		printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
 -			part->name);
 +		slave->mtd.flags |= MTD_ERASE_PARTIAL;
 +		if (((u32) slave->mtd.size) > master->erasesize)
 +			slave->mtd.flags &= ~MTD_WRITEABLE;
 +		else
 +			slave->mtd.erasesize = slave->mtd.size;
 	}
 	if ((slave->mtd.flags & MTD_WRITEABLE) &&
 -	    mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
 -		slave->mtd.flags &= ~MTD_WRITEABLE;
 -		printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
 -			part->name);
 +	    mtd_mod_by_eb(slave->offset + slave->mtd.size, &slave->mtd)) {
 +		slave->mtd.flags |= MTD_ERASE_PARTIAL;
 +
 +		if ((u32) slave->mtd.size > master->erasesize)
 +			slave->mtd.flags &= ~MTD_WRITEABLE;
 +		else
 +			slave->mtd.erasesize = slave->mtd.size;
 	}
 +	if ((slave->mtd.flags & (MTD_ERASE_PARTIAL|MTD_WRITEABLE)) == MTD_ERASE_PARTIAL)
 +		printk(KERN_WARNING"mtd: partition \"%s\" must either start or end on erase block boundary or be smaller than an erase block -- forcing read-only\n",
 +				part->name);
 	slave->mtd.ecclayout = master->ecclayout;
 	slave->mtd.ecc_step_size = master->ecc_step_size;
 --- a/include/linux/mtd/mtd.h
 +++ b/include/linux/mtd/mtd.h
@@ -55,6 +55,10 @@ struct erase_info {
 	u_long priv;
 	u_char state;
 	struct erase_info *next;
 +
 +	u8 *erase_buf;
 +	u32 erase_buf_ofs;
 +	bool partial_start;
 };
 struct mtd_erase_region_info {
--- a/target/linux/generic/patches-3.13/412-mtd-partial_eraseblock_unlock.patch
+++ b/target/linux/generic/patches-3.13/412-mtd-partial_eraseblock_unlock.patch
@ -1,18 +0,0 @@
 --- a/drivers/mtd/mtdpart.c
 +++ b/drivers/mtd/mtdpart.c
@@ -332,7 +332,14 @@ static int part_lock(struct mtd_info *mt
 static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 {
 	struct mtd_part *part = PART(mtd);
 -	return part->master->_unlock(part->master, ofs + part->offset, len);
 +
 +	ofs += part->offset;
 +	if (mtd->flags & MTD_ERASE_PARTIAL) {
 +		/* round up len to next erasesize and round down offset to prev block */
 +		len = (mtd_div_by_eb(len, part->master) + 1) * part->master->erasesize;
 +		ofs &= ~(part->master->erasesize - 1);
 +	}
 +	return part->master->_unlock(part->master, ofs, len);
 }
 static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
--- a/target/linux/generic/patches-3.13/420-mtd-redboot_space.patch
+++ b/target/linux/generic/patches-3.13/420-mtd-redboot_space.patch
@ -1,30 +0,0 @@
 --- a/drivers/mtd/redboot.c
 +++ b/drivers/mtd/redboot.c
@@ -265,14 +265,21 @@ static int parse_redboot_partitions(stru
 #endif
 		names += strlen(names)+1;
 -#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
 		if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) {
 -			i++;
 -			parts[i].offset = parts[i-1].size + parts[i-1].offset;
 -			parts[i].size = fl->next->img->flash_base - parts[i].offset;
 -			parts[i].name = nullname;
 -		}
 +			if (!strcmp(parts[i].name, "rootfs")) {
 +				parts[i].size = fl->next->img->flash_base;
 +				parts[i].size &= ~(master->erasesize - 1);
 +				parts[i].size -= parts[i].offset;
 +#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
 +				nrparts--;
 +			} else {
 +				i++;
 +				parts[i].offset = parts[i-1].size + parts[i-1].offset;
 +				parts[i].size = fl->next->img->flash_base - parts[i].offset;
 +				parts[i].name = nullname;
 #endif
 +			}
 +		}
 		tmp_fl = fl;
 		fl = fl->next;
 		kfree(tmp_fl);
--- a/target/linux/generic/patches-3.13/430-mtd-add-myloader-partition-parser.patch
+++ b/target/linux/generic/patches-3.13/430-mtd-add-myloader-partition-parser.patch
@ -1,35 +0,0 @@
 --- a/drivers/mtd/Kconfig
 +++ b/drivers/mtd/Kconfig
@@ -184,6 +184,22 @@ config MTD_BCM47XX_PARTS
 	  This provides partitions parser for devices based on BCM47xx
 	  boards.
 +config MTD_MYLOADER_PARTS
 +	tristate "MyLoader partition parsing"
 +	depends on ADM5120 || ATHEROS_AR231X || ATHEROS_AR71XX || ATH79
 +	---help---
 +	  MyLoader is a bootloader which allows the user to define partitions
 +	  in flash devices, by putting a table in the second erase block
 +	  on the device, similar to a partition table. This table gives the 
 +	  offsets and lengths of the user defined partitions.
 +
 +	  If you need code which can detect and parse these tables, and
 +	  register MTD 'partitions' corresponding to each image detected,
 +	  enable this option.
 +
 +	  You will still need the parsing functions to be called by the driver
 +	  for your particular device. It won't happen automatically.
 +
 comment "User Modules And Translation Layers"
 config MTD_BLKDEVS
 --- a/drivers/mtd/Makefile
 +++ b/drivers/mtd/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_MTD_AFS_PARTS)	+= afs.o
 obj-$(CONFIG_MTD_AR7_PARTS)	+= ar7part.o
 obj-$(CONFIG_MTD_BCM63XX_PARTS)	+= bcm63xxpart.o
 obj-$(CONFIG_MTD_BCM47XX_PARTS)	+= bcm47xxpart.o
 +obj-$(CONFIG_MTD_MYLOADER_PARTS) += myloader.o
 # 'Users' - code which presents functionality to userspace.
 obj-$(CONFIG_MTD_BLKDEVS)	+= mtd_blkdevs.o
--- a/target/linux/generic/patches-3.13/440-block2mtd_init.patch
+++ b/target/linux/generic/patches-3.13/440-block2mtd_init.patch
@ -1,107 +0,0 @@
 --- a/drivers/mtd/devices/block2mtd.c
 +++ b/drivers/mtd/devices/block2mtd.c
@@ -17,6 +17,7 @@
 #include <linux/list.h>
 #include <linux/init.h>
 #include <linux/mtd/mtd.h>
 +#include <linux/mtd/partitions.h>
 #include <linux/mutex.h>
 #include <linux/mount.h>
 #include <linux/slab.h>
@@ -210,11 +211,12 @@ static void block2mtd_free_device(struct
 /* FIXME: ensure that mtd->size % erase_size == 0 */
 -static struct block2mtd_dev *add_device(char *devname, int erase_size)
 +static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname)
 {
 	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
 	struct block_device *bdev;
 	struct block2mtd_dev *dev;
 +	struct mtd_partition *part;
 	char *name;
 	if (!devname)
@@ -253,13 +255,16 @@ static struct block2mtd_dev *add_device(
 	/* Setup the MTD structure */
 	/* make the name contain the block device in */
 -	name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
 +	if (!mtdname)
 +		mtdname = devname;
 +	name = kmalloc(strlen(mtdname) + 1, GFP_KERNEL);
 	if (!name)
 		goto devinit_err;
 +	strcpy(name, mtdname);
 	dev->mtd.name = name;
 -	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
 +	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK & ~(erase_size - 1);
 	dev->mtd.erasesize = erase_size;
 	dev->mtd.writesize = 1;
 	dev->mtd.writebufsize = PAGE_SIZE;
@@ -272,15 +277,18 @@ static struct block2mtd_dev *add_device(
 	dev->mtd.priv = dev;
 	dev->mtd.owner = THIS_MODULE;
 -	if (mtd_device_register(&dev->mtd, NULL, 0)) {
 +	part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
 +	part->name = name;
 +	part->offset = 0;
 +	part->size = dev->mtd.size;
 +	if (mtd_device_register(&dev->mtd, part, 1)) {
 		/* Device didn't get added, so free the entry */
 		goto devinit_err;
 	}
 	list_add(&dev->list, &blkmtd_device_list);
 	pr_info("mtd%d: [%s] erase_size = %dKiB [%d]\n",
 		dev->mtd.index,
 -		dev->mtd.name + strlen("block2mtd: "),
 -		dev->mtd.erasesize >> 10, dev->mtd.erasesize);
 +		mtdname, dev->mtd.erasesize >> 10, dev->mtd.erasesize);
 	return dev;
 devinit_err:
@@ -347,9 +355,9 @@ static char block2mtd_paramline[80 + 12]
 static int block2mtd_setup2(const char *val)
 {
 -	char buf[80 + 12]; /* 80 for device, 12 for erase size */
 +	char buf[80 + 12 + 80]; /* 80 for device, 12 for erase size, 80 for name */
 	char *str = buf;
 -	char *token[2];
 +	char *token[3];
 	char *name;
 	size_t erase_size = PAGE_SIZE;
 	int i, ret;
@@ -362,7 +370,7 @@ static int block2mtd_setup2(const char *
 	strcpy(str, val);
 	kill_final_newline(str);
 -	for (i = 0; i < 2; i++)
 +	for (i = 0; i < 3; i++)
 		token[i] = strsep(&str, ",");
 	if (str) {
@@ -388,8 +396,10 @@ static int block2mtd_setup2(const char *
 			return 0;
 		}
 	}
 +	if (token[2] && (strlen(token[2]) + 1 > 80))
 +		pr_err("mtd device name too long\n");
 -	add_device(name, erase_size);
 +	add_device(name, erase_size, token[2]);
 	return 0;
 }
@@ -423,7 +433,7 @@ static int block2mtd_setup(const char *v
 module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
 -MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
 +MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>[,<name>]]\"");
 static int __init block2mtd_init(void)
 {
--- a/target/linux/generic/patches-3.13/441-block2mtd_probe.patch
+++ b/target/linux/generic/patches-3.13/441-block2mtd_probe.patch
@ -1,108 +0,0 @@
 --- a/drivers/mtd/devices/block2mtd.c
 +++ b/drivers/mtd/devices/block2mtd.c
@@ -10,6 +10,7 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
 +#include <linux/delay.h>
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/bio.h>
@@ -211,13 +212,14 @@ static void block2mtd_free_device(struct
 /* FIXME: ensure that mtd->size % erase_size == 0 */
 -static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname)
 +static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname, int timeout)
 {
 	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
 -	struct block_device *bdev;
 +	struct block_device *bdev = ERR_PTR(-ENODEV);
 	struct block2mtd_dev *dev;
 	struct mtd_partition *part;
 	char *name;
 +	int i;
 	if (!devname)
 		return NULL;
@@ -228,15 +230,20 @@ static struct block2mtd_dev *add_device(
 	/* Get a handle on the device */
 	bdev = blkdev_get_by_path(devname, mode, dev);
 +
 #ifndef MODULE
 -	if (IS_ERR(bdev)) {
 +	for (i = 0; IS_ERR(bdev) && i <= timeout; i++) {
 +		dev_t devt;
 -		/* We might not have rootfs mounted at this point. Try
 -		   to resolve the device name by other means. */
 +		if (i)
 +			msleep(1000);
 +		wait_for_device_probe();
 +
 +		devt = name_to_dev_t(devname);
 +		if (!devt)
 +			continue;
 -		dev_t devt = name_to_dev_t(devname);
 -		if (devt)
 -			bdev = blkdev_get_by_dev(devt, mode, dev);
 +		bdev = blkdev_get_by_dev(devt, mode, dev);
 	}
 #endif
@@ -355,11 +362,12 @@ static char block2mtd_paramline[80 + 12]
 static int block2mtd_setup2(const char *val)
 {
 -	char buf[80 + 12 + 80]; /* 80 for device, 12 for erase size, 80 for name */
 +	char buf[80 + 12 + 80 + 8]; /* 80 for device, 12 for erase size, 80 for name, 8 for timeout */
 	char *str = buf;
 -	char *token[3];
 +	char *token[4];
 	char *name;
 	size_t erase_size = PAGE_SIZE;
 +	unsigned long timeout = 0;
 	int i, ret;
 	if (strnlen(val, sizeof(buf)) >= sizeof(buf)) {
@@ -370,7 +378,7 @@ static int block2mtd_setup2(const char *
 	strcpy(str, val);
 	kill_final_newline(str);
 -	for (i = 0; i < 3; i++)
 +	for (i = 0; i < 4; i++)
 		token[i] = strsep(&str, ",");
 	if (str) {
@@ -399,7 +407,10 @@ static int block2mtd_setup2(const char *
 	if (token[2] && (strlen(token[2]) + 1 > 80))
 		pr_err("mtd device name too long\n");
 -	add_device(name, erase_size, token[2]);
 +	if (token[3] && kstrtoul(token[3], 0, &timeout))
 +		pr_err("invalid timeout\n");
 +
 +	add_device(name, erase_size, token[2], timeout);
 	return 0;
 }
@@ -433,7 +444,7 @@ static int block2mtd_setup(const char *v
 module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
 -MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>[,<name>]]\"");
 +MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>[,<name>[,<timeout>]]]\"");
 static int __init block2mtd_init(void)
 {
@@ -467,7 +478,7 @@ static void block2mtd_exit(void)
 }
 -module_init(block2mtd_init);
 +late_initcall(block2mtd_init);
 module_exit(block2mtd_exit);
 MODULE_LICENSE("GPL");
--- a/target/linux/generic/patches-3.13/450-mtd-nand-allow-to-use-platform-specific-chip-fixup.patch
+++ b/target/linux/generic/patches-3.13/450-mtd-nand-allow-to-use-platform-specific-chip-fixup.patch
@ -1,37 +0,0 @@
 ---
 drivers/mtd/nand/plat_nand.c |   13 ++++++++++++-
 include/linux/mtd/nand.h     |    1 +
 2 files changed, 13 insertions(+), 1 deletion(-)
 --- a/include/linux/mtd/nand.h
 +++ b/include/linux/mtd/nand.h
@@ -721,6 +721,7 @@ struct platform_nand_chip {
 	unsigned int options;
 	unsigned int bbt_options;
 	const char **part_probe_types;
 +	int (*chip_fixup)(struct mtd_info *mtd);
 };
 /* Keep gcc happy */
 --- a/drivers/mtd/nand/plat_nand.c
 +++ b/drivers/mtd/nand/plat_nand.c
@@ -103,7 +103,18 @@ static int plat_nand_probe(struct platfo
 	}
 	/* Scan to find existence of the device */
 -	if (nand_scan(&data->mtd, pdata->chip.nr_chips)) {
 +	if (nand_scan_ident(&data->mtd, pdata->chip.nr_chips, NULL)) {
 +		err = -ENXIO;
 +		goto out;
 +	}
 +
 +	if (pdata->chip.chip_fixup) {
 +		err = pdata->chip.chip_fixup(&data->mtd);
 +		if (err)
 +			goto out;
 +	}
 +
 +	if (nand_scan_tail(&data->mtd)) {
 		err = -ENXIO;
 		goto out;
 	}
--- a/target/linux/generic/patches-3.13/451-mtd-nand-fix-return-code-of-nand_correct_data-function.patch
+++ b/target/linux/generic/patches-3.13/451-mtd-nand-fix-return-code-of-nand_correct_data-function.patch
@ -1,11 +0,0 @@
 --- a/drivers/mtd/nand/nand_ecc.c
 +++ b/drivers/mtd/nand/nand_ecc.c
@@ -507,7 +507,7 @@ int __nand_correct_data(unsigned char *b
 		return 1;	/* error in ECC data; no action needed */
 	pr_err("%s: uncorrectable ECC error", __func__);
 -	return -1;
 +	return -EBADMSG;
 }
 EXPORT_SYMBOL(__nand_correct_data);
--- a/target/linux/generic/patches-3.13/460-mtd-cfi_cmdset_0002-no-erase_suspend.patch
+++ b/target/linux/generic/patches-3.13/460-mtd-cfi_cmdset_0002-no-erase_suspend.patch
@ -1,11 +0,0 @@
 --- a/drivers/mtd/chips/cfi_cmdset_0002.c
 +++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -780,7 +780,7 @@ static int get_chip(struct map_info *map
 		return 0;
 	case FL_ERASING:
 -		if (!cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
 +		if (1 /* no suspend */ || !cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
 		    !(mode == FL_READY || mode == FL_POINT ||
 		    (mode == FL_WRITING && (cfip->EraseSuspend & 0x2))))
 			goto sleep;
--- a/target/linux/generic/patches-3.13/461-mtd-cfi_cmdset_0002-add-buffer-write-cmd-timeout.patch
+++ b/target/linux/generic/patches-3.13/461-mtd-cfi_cmdset_0002-add-buffer-write-cmd-timeout.patch
@ -1,18 +0,0 @@
 From: George Kashperko <george@znau.edu.ua>
 Issue map read after Write Buffer Load command to ensure chip is ready
 to receive data.
 Signed-off-by: George Kashperko <george@znau.edu.ua>
 ---
 drivers/mtd/chips/cfi_cmdset_0002.c |    1 +
 1 file changed, 1 insertion(+)
 --- a/drivers/mtd/chips/cfi_cmdset_0002.c
 +++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -1498,6 +1498,7 @@ static int __xipram do_write_buffer(stru
 	/* Write Buffer Load */
 	map_write(map, CMD(0x25), cmd_adr);
 +	(void) map_read(map, cmd_adr);
 	chip->state = FL_WRITING_TO_BUFFER;
--- a/target/linux/generic/patches-3.13/471-mtd-m25p80-allow-to-disable-small-sector-erase.patch
+++ b/target/linux/generic/patches-3.13/471-mtd-m25p80-allow-to-disable-small-sector-erase.patch
@ -1,41 +0,0 @@
 --- a/drivers/mtd/devices/Kconfig
 +++ b/drivers/mtd/devices/Kconfig
@@ -102,6 +102,14 @@ config MTD_SPEAR_SMI
 	help
 	  This enable SNOR support on SPEAR platforms using SMI controller
 +config M25PXX_PREFER_SMALL_SECTOR_ERASE
 +	bool "Prefer small sector erase"
 +	depends on MTD_M25P80
 +	default y
 +	help
 +	  This option enables use of the small erase sectors if that is
 +	  supported by the flash chip.
 +
 config MTD_SST25L
 	tristate "Support SST25L (non JEDEC) SPI Flash chips"
 	depends on SPI_MASTER
 --- a/drivers/mtd/devices/m25p80.c
 +++ b/drivers/mtd/devices/m25p80.c
@@ -82,6 +82,12 @@
 #define JEDEC_MFR(_jedec_id)	((_jedec_id) >> 16)
 +#ifdef CONFIG_M25PXX_PREFER_SMALL_SECTOR_ERASE
 +#define PREFER_SMALL_SECTOR_ERASE 1
 +#else
 +#define PREFER_SMALL_SECTOR_ERASE 0
 +#endif
 +
 /****************************************************************************/
 struct m25p {
@@ -1032,7 +1038,7 @@ static int m25p_probe(struct spi_device 
 		flash->mtd._write = m25p80_write;
 	/* prefer "small sector" erase if possible */
 -	if (info->flags & SECT_4K) {
 +	if (PREFER_SMALL_SECTOR_ERASE && (info->flags & SECT_4K)) {
 		flash->erase_opcode = OPCODE_BE_4K;
 		flash->mtd.erasesize = 4096;
 	} else if (info->flags & SECT_4K_PMC) {
--- a/target/linux/generic/patches-3.13/472-mtd-m25p80-add-support-for-Winbond-W25X05-flash.patch
+++ b/target/linux/generic/patches-3.13/472-mtd-m25p80-add-support-for-Winbond-W25X05-flash.patch
@ -1,20 +0,0 @@
 From eef9dfc4e821408af1af13aa0cc707fc496fb7c6 Mon Sep 17 00:00:00 2001
 From: Gabor Juhos <juhosg@openwrt.org>
 Date: Wed, 11 Dec 2013 19:05:59 +0100
 Subject: [PATCH] m25p80: add support for the Winbond W25X05 flash
 Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
 ---
 drivers/mtd/devices/m25p80.c |    1 +
 1 file changed, 1 insertion(+)
 --- a/drivers/mtd/devices/m25p80.c
 +++ b/drivers/mtd/devices/m25p80.c
@@ -863,6 +863,7 @@ static const struct spi_device_id m25p_i
 	{ "m25px64",    INFO(0x207117,  0, 64 * 1024, 128, 0) },
 	/* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
 +	{ "w25x05", INFO(0xef3010, 0, 64 * 1024,  1,  SECT_4K) },
 	{ "w25x10", INFO(0xef3011, 0, 64 * 1024,  2,  SECT_4K) },
 	{ "w25x20", INFO(0xef3012, 0, 64 * 1024,  4,  SECT_4K) },
 	{ "w25x40", INFO(0xef3013, 0, 64 * 1024,  8,  SECT_4K) },
--- a/target/linux/generic/patches-3.13/473-mtd-m25p80-add-support-for-EON-EN25QH128-flash.patch
+++ b/target/linux/generic/patches-3.13/473-mtd-m25p80-add-support-for-EON-EN25QH128-flash.patch
@ -1,20 +0,0 @@
 From 0233dcb52eefa0b29250a6d8a58b3143790df57d Mon Sep 17 00:00:00 2001
 From: Sergey Ryazanov <ryazanov.s.a@gmail.com>
 Date: Wed, 11 Jun 2014 02:23:00 +0400
 Subject: [PATCH] mtd: m25p80: add support for EON EN25QH128
 Signed-off-by: Sergey Ryazanov <ryazanov.s.a@gmail.com>
 ---
 drivers/mtd/devices/m25p80.c | 1 +
 1 file changed, 1 insertion(+)
 --- a/drivers/mtd/devices/m25p80.c
 +++ b/drivers/mtd/devices/m25p80.c
@@ -751,6 +751,7 @@ static const struct spi_device_id m25p_i
 	{ "en25q32b",   INFO(0x1c3016, 0, 64 * 1024,   64, 0) },
 	{ "en25p64",    INFO(0x1c2017, 0, 64 * 1024,  128, 0) },
 	{ "en25q64",    INFO(0x1c3017, 0, 64 * 1024,  128, SECT_4K) },
 +	{ "en25qh128",  INFO(0x1c7018, 0, 64 * 1024,  256, 0) },
 	{ "en25qh256",  INFO(0x1c7019, 0, 64 * 1024,  512, 0) },
 	/* ESMT */
--- a/target/linux/generic/patches-3.13/480-mtd-set-rootfs-to-be-root-dev.patch
+++ b/target/linux/generic/patches-3.13/480-mtd-set-rootfs-to-be-root-dev.patch
@ -1,26 +0,0 @@
 --- a/drivers/mtd/mtdcore.c
 +++ b/drivers/mtd/mtdcore.c
@@ -37,6 +37,7 @@
 #include <linux/backing-dev.h>
 #include <linux/gfp.h>
 #include <linux/slab.h>
 +#include <linux/root_dev.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
@@ -422,6 +423,15 @@ int add_mtd_device(struct mtd_info *mtd)
 	   of this try_ nonsense, and no bitching about it
 	   either. :) */
 	__module_get(THIS_MODULE);
 +
 +	if (!strcmp(mtd->name, "rootfs") &&
 +	    config_enabled(CONFIG_MTD_ROOTFS_ROOT_DEV) &&
 +	    ROOT_DEV == 0) {
 +		pr_notice("mtd: device %d (%s) set to be root filesystem\n",
 +			  mtd->index, mtd->name);
 +		ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, mtd->index);
 +	}
 +
 	return 0;
 fail_added:
--- a/target/linux/generic/patches-3.13/500-yaffs-Kbuild-integration.patch
+++ b/target/linux/generic/patches-3.13/500-yaffs-Kbuild-integration.patch
@ -1,18 +0,0 @@
 --- a/fs/Kconfig
 +++ b/fs/Kconfig
@@ -39,6 +39,7 @@ source "fs/gfs2/Kconfig"
 source "fs/ocfs2/Kconfig"
 source "fs/btrfs/Kconfig"
 source "fs/nilfs2/Kconfig"
 +source "fs/yaffs2/Kconfig"
 endif # BLOCK
 --- a/fs/Makefile
 +++ b/fs/Makefile
@@ -127,3 +127,5 @@ obj-y				+= exofs/ # Multiple modules
 obj-$(CONFIG_CEPH_FS)		+= ceph/
 obj-$(CONFIG_PSTORE)		+= pstore/
 obj-$(CONFIG_EFIVAR_FS)		+= efivarfs/
 +obj-$(CONFIG_YAFFS_FS)		+= yaffs2/
 +
--- a/target/linux/generic/patches-3.13/501-yaffs-3.5-convert-to-use-kuid_t-kgid_t.patch
+++ b/target/linux/generic/patches-3.13/501-yaffs-3.5-convert-to-use-kuid_t-kgid_t.patch
@ -1,155 +0,0 @@
 --- a/fs/yaffs2/yaffs_vfs.c
 +++ b/fs/yaffs2/yaffs_vfs.c
@@ -329,6 +329,33 @@ static int yaffs_readpage(struct file *f
 	return ret;
 }
 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
 +#define YCRED_FSUID()	from_kuid(&init_user_ns, current_fsuid())
 +#define YCRED_FSGID()	from_kgid(&init_user_ns, current_fsgid())
 +#else
 +#define YCRED_FSUID()	YCRED(current)->fsuid
 +#define YCRED_FSGID()	YCRED(current)->fsgid
 +
 +static inline uid_t i_uid_read(const struct inode *inode)
 +{
 +	return inode->i_uid;
 +}
 +
 +static inline gid_t i_gid_read(const struct inode *inode)
 +{
 +	return inode->i_gid;
 +}
 +
 +static inline void i_uid_write(struct inode *inode, uid_t uid)
 +{
 +	inode->i_uid = uid;
 +}
 +
 +static inline void i_gid_write(struct inode *inode, gid_t gid)
 +{
 +	inode->i_gid = gid;
 +}
 +#endif
 static void yaffs_set_super_dirty_val(struct yaffs_dev *dev, int val)
 {
@@ -1225,9 +1252,9 @@ static int yaffs_mknod(struct inode *dir
 	struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
 	int error = -ENOSPC;
 -	uid_t uid = YCRED(current)->fsuid;
 +	uid_t uid = YCRED_FSUID();
 	gid_t gid =
 -	    (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
 +	    (dir->i_mode & S_ISGID) ? i_gid_read(dir) : YCRED_FSGID();
 	if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
 		mode |= S_ISGID;
@@ -1424,9 +1451,9 @@ static int yaffs_symlink(struct inode *d
 {
 	struct yaffs_obj *obj;
 	struct yaffs_dev *dev;
 -	uid_t uid = YCRED(current)->fsuid;
 +	uid_t uid = YCRED_FSUID();
 	gid_t gid =
 -	    (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
 +	    (dir->i_mode & S_ISGID) ? i_gid_read(dir) : YCRED_FSGID();
 	yaffs_trace(YAFFS_TRACE_OS, "yaffs_symlink");
@@ -1829,8 +1856,8 @@ static void yaffs_fill_inode_from_obj(st
 		inode->i_ino = obj->obj_id;
 		inode->i_mode = obj->yst_mode;
 -		inode->i_uid = obj->yst_uid;
 -		inode->i_gid = obj->yst_gid;
 +		i_uid_write(inode, obj->yst_uid);
 +		i_gid_write(inode, obj->yst_gid);
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
 		inode->i_blksize = inode->i_sb->s_blocksize;
 #endif
@@ -1856,7 +1883,7 @@ static void yaffs_fill_inode_from_obj(st
 		yaffs_trace(YAFFS_TRACE_OS,
 			"yaffs_fill_inode mode %x uid %d gid %d size %lld count %d",
 -			inode->i_mode, inode->i_uid, inode->i_gid,
 +			inode->i_mode, i_uid_read(inode), i_gid_read(inode),
 			inode->i_size, atomic_read(&inode->i_count));
 		switch (obj->yst_mode & S_IFMT) {
 --- a/fs/yaffs2/yaffs_attribs.c
 +++ b/fs/yaffs2/yaffs_attribs.c
@@ -14,6 +14,48 @@
 #include "yaffs_guts.h"
 #include "yaffs_attribs.h"
 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
 +static inline uid_t ia_uid_read(const struct iattr *iattr)
 +{
 +	return from_kuid(&init_user_ns, iattr->ia_uid);
 +}
 +
 +static inline gid_t ia_gid_read(const struct iattr *iattr)
 +{
 +	return from_kgid(&init_user_ns, iattr->ia_gid);
 +}
 +
 +static inline void ia_uid_write(struct iattr *iattr, uid_t uid)
 +{
 +	iattr->ia_uid = make_kuid(&init_user_ns, uid);
 +}
 +
 +static inline void ia_gid_write(struct iattr *iattr, gid_t gid)
 +{
 +	iattr->ia_gid = make_kgid(&init_user_ns, gid);
 +}
 +#else
 +static inline uid_t ia_uid_read(const struct iattr *iattr)
 +{
 +	return iattr->ia_uid;
 +}
 +
 +static inline gid_t ia_gid_read(const struct iattr *inode)
 +{
 +	return iattr->ia_gid;
 +}
 +
 +static inline void ia_uid_write(struct iattr *iattr, uid_t uid)
 +{
 +	iattr->ia_uid = uid;
 +}
 +
 +static inline void ia_gid_write(struct iattr *iattr, gid_t gid)
 +{
 +	iattr->ia_gid = gid;
 +}
 +#endif
 +
 void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh)
 {
 	obj->yst_uid = oh->yst_uid;
@@ -77,9 +119,9 @@ int yaffs_set_attribs(struct yaffs_obj *
 	if (valid & ATTR_MODE)
 		obj->yst_mode = attr->ia_mode;
 	if (valid & ATTR_UID)
 -		obj->yst_uid = attr->ia_uid;
 +		obj->yst_uid =  ia_uid_read(attr);
 	if (valid & ATTR_GID)
 -		obj->yst_gid = attr->ia_gid;
 +		obj->yst_gid =  ia_gid_read(attr);
 	if (valid & ATTR_ATIME)
 		obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime);
@@ -103,9 +145,9 @@ int yaffs_get_attribs(struct yaffs_obj *
 	attr->ia_mode = obj->yst_mode;
 	valid |= ATTR_MODE;
 -	attr->ia_uid = obj->yst_uid;
 +	ia_uid_write(attr, obj->yst_uid);
 	valid |= ATTR_UID;
 -	attr->ia_gid = obj->yst_gid;
 +	ia_gid_write(attr, obj->yst_gid);
 	valid |= ATTR_GID;
 	Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime;
--- a/target/linux/generic/patches-3.13/502-yaffs-3.10-disable-proc-entry.patch
+++ b/target/linux/generic/patches-3.13/502-yaffs-3.10-disable-proc-entry.patch
@ -1,44 +0,0 @@
 --- a/fs/yaffs2/yaffs_vfs.c
 +++ b/fs/yaffs2/yaffs_vfs.c
@@ -3025,6 +3025,7 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "y
 #endif
 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
 static struct proc_dir_entry *my_proc_entry;
 static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev)
@@ -3398,6 +3399,7 @@ static int yaffs_proc_write(struct file 
 		return yaffs_proc_debug_write(file, buf, count, data);
 	return yaffs_proc_write_trace_options(file, buf, count, data);
 }
 +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0)) */
 /* Stuff to handle installation of file systems */
 struct file_system_to_install {
@@ -3421,6 +3423,7 @@ static int __init init_yaffs_fs(void)
 	mutex_init(&yaffs_context_lock);
 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
 	/* Install the proc_fs entries */
 	my_proc_entry = create_proc_entry("yaffs",
 					  S_IRUGO | S_IFREG, YPROC_ROOT);
@@ -3432,6 +3435,7 @@ static int __init init_yaffs_fs(void)
 	} else {
 		return -ENOMEM;
         }
 +#endif
 	/* Now add the file system entries */
@@ -3468,7 +3472,9 @@ static void __exit exit_yaffs_fs(void)
 	yaffs_trace(YAFFS_TRACE_ALWAYS,
 		"yaffs built " __DATE__ " " __TIME__ " removing.");
 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
 	remove_proc_entry("yaffs", YPROC_ROOT);
 +#endif
 	fsinst = fs_to_install;
--- a/target/linux/generic/patches-3.13/503-yaffs-3.12-convert-readdir-to-iterate.patch
+++ b/target/linux/generic/patches-3.13/503-yaffs-3.12-convert-readdir-to-iterate.patch
@ -1,129 +0,0 @@
 --- a/fs/yaffs2/yaffs_vfs.c
 +++ b/fs/yaffs2/yaffs_vfs.c
@@ -1701,6 +1701,110 @@ static void yaffs_remove_obj_callback(st
 /*-----------------------------------------------------------------*/
 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0))
 +static int yaffs_readdir(struct file *file, struct dir_context *ctx)
 +{
 +	struct yaffs_obj *obj;
 +	struct yaffs_dev *dev;
 +	struct yaffs_search_context *sc;
 +	struct inode *inode = file->f_dentry->d_inode;
 +	unsigned long offset, curoffs;
 +	struct yaffs_obj *l;
 +	int ret_val = 0;
 +
 +	char name[YAFFS_MAX_NAME_LENGTH + 1];
 +
 +	obj = yaffs_dentry_to_obj(file->f_dentry);
 +	dev = obj->my_dev;
 +
 +	yaffs_gross_lock(dev);
 +
 +	yaffs_dev_to_lc(dev)->readdir_process = current;
 +
 +	offset = ctx->pos;
 +
 +	sc = yaffs_new_search(obj);
 +	if (!sc) {
 +		ret_val = -ENOMEM;
 +		goto out;
 +	}
 +
 +	yaffs_trace(YAFFS_TRACE_OS,
 +		"yaffs_readdir: starting at %d", (int)offset);
 +
 +	if (offset == 0) {
 +		yaffs_trace(YAFFS_TRACE_OS,
 +			"yaffs_readdir: entry . ino %d",
 +			(int)inode->i_ino);
 +		yaffs_gross_unlock(dev);
 +		if (!dir_emit_dot(file, ctx)) {
 +			yaffs_gross_lock(dev);
 +			goto out;
 +		}
 +		yaffs_gross_lock(dev);
 +		offset++;
 +		ctx->pos++;
 +	}
 +	if (offset == 1) {
 +		yaffs_trace(YAFFS_TRACE_OS,
 +			"yaffs_readdir: entry .. ino %d",
 +			(int)file->f_dentry->d_parent->d_inode->i_ino);
 +		yaffs_gross_unlock(dev);
 +		if (!dir_emit_dotdot(file, ctx)) {
 +			yaffs_gross_lock(dev);
 +			goto out;
 +		}
 +		yaffs_gross_lock(dev);
 +		offset++;
 +		ctx->pos++;
 +	}
 +
 +	curoffs = 1;
 +
 +	/* If the directory has changed since the open or last call to
 +	   readdir, rewind to after the 2 canned entries. */
 +	if (file->f_version != inode->i_version) {
 +		offset = 2;
 +		ctx->pos = offset;
 +		file->f_version = inode->i_version;
 +	}
 +
 +	while (sc->next_return) {
 +		curoffs++;
 +		l = sc->next_return;
 +		if (curoffs >= offset) {
 +			int this_inode = yaffs_get_obj_inode(l);
 +			int this_type = yaffs_get_obj_type(l);
 +
 +			yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1);
 +			yaffs_trace(YAFFS_TRACE_OS,
 +				"yaffs_readdir: %s inode %d",
 +				name, yaffs_get_obj_inode(l));
 +
 +			yaffs_gross_unlock(dev);
 +
 +			if (!dir_emit(ctx, name, strlen(name),
 +				      this_inode, this_type) < 0) {
 +				yaffs_gross_lock(dev);
 +				goto out;
 +			}
 +
 +			yaffs_gross_lock(dev);
 +
 +			offset++;
 +			ctx->pos++;
 +		}
 +		yaffs_search_advance(sc);
 +	}
 +
 +out:
 +	yaffs_search_end(sc);
 +	yaffs_dev_to_lc(dev)->readdir_process = NULL;
 +	yaffs_gross_unlock(dev);
 +
 +	return ret_val;
 +}
 +#else
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
 	struct yaffs_obj *obj;
@@ -1807,10 +1911,15 @@ out:
 	return ret_val;
 }
 +#endif
 static const struct file_operations yaffs_dir_operations = {
 	.read = generic_read_dir,
 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0))
 +	.iterate = yaffs_readdir,
 +#else
 	.readdir = yaffs_readdir,
 +#endif
 	.fsync = yaffs_sync_object,
 	.llseek = generic_file_llseek,
 };
--- a/target/linux/generic/patches-3.13/503-yaffs-add-tags-9bytes-mount-option.patch
+++ b/target/linux/generic/patches-3.13/503-yaffs-add-tags-9bytes-mount-option.patch
@ -1,115 +0,0 @@
 Subject: yaffs: add support for tags-9bytes mount option
 Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
 ---
 --- a/fs/yaffs2/yaffs_vfs.c
 +++ b/fs/yaffs2/yaffs_vfs.c
@@ -2634,6 +2634,7 @@ static const struct super_operations yaf
 struct yaffs_options {
 	int inband_tags;
 +	int tags_9bytes;
 	int skip_checkpoint_read;
 	int skip_checkpoint_write;
 	int no_cache;
@@ -2673,6 +2674,8 @@ static int yaffs_parse_options(struct ya
 		if (!strcmp(cur_opt, "inband-tags")) {
 			options->inband_tags = 1;
 +		} else if (!strcmp(cur_opt, "tags-9bytes")) {
 +			options->tags_9bytes = 1;
 		} else if (!strcmp(cur_opt, "tags-ecc-off")) {
 			options->tags_ecc_on = 0;
 			options->tags_ecc_overridden = 1;
@@ -2746,7 +2749,6 @@ static struct super_block *yaffs_interna
 	struct yaffs_param *param;
 	int read_only = 0;
 -	int inband_tags = 0;
 	struct yaffs_options options;
@@ -2786,6 +2788,9 @@ static struct super_block *yaffs_interna
 	memset(&options, 0, sizeof(options));
 +	if (IS_ENABLED(CONFIG_YAFFS_9BYTE_TAGS))
 +		options.tags_9bytes = 1;
 +
 	if (yaffs_parse_options(&options, data_str)) {
 		/* Option parsing failed */
 		return NULL;
@@ -2819,17 +2824,22 @@ static struct super_block *yaffs_interna
 	}
 	/* Added NCB 26/5/2006 for completeness */
 -	if (yaffs_version == 2 && !options.inband_tags
 -	    && WRITE_SIZE(mtd) == 512) {
 +	if (yaffs_version == 2 &&
 +	    (!options.inband_tags || options.tags_9bytes) &&
 +	    WRITE_SIZE(mtd) == 512) {
 		yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs1");
 		yaffs_version = 1;
 	}
 -	if (mtd->oobavail < sizeof(struct yaffs_packed_tags2) ||
 -	    options.inband_tags)
 -		inband_tags = 1;
 +	if (yaffs_version == 2 &&
 +	    mtd->oobavail < sizeof(struct yaffs_packed_tags2)) {
 +		yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting inband tags");
 +		options.inband_tags = 1;
 +	}
 -	if(yaffs_verify_mtd(mtd, yaffs_version, inband_tags) < 0)
 +	err = yaffs_verify_mtd(mtd, yaffs_version, options.inband_tags,
 +			       options.tags_9bytes);
 +	if (err < 0)
 		return NULL;
 	/* OK, so if we got here, we have an MTD that's NAND and looks
@@ -2890,7 +2900,8 @@ static struct super_block *yaffs_interna
 	param->n_reserved_blocks = 5;
 	param->n_caches = (options.no_cache) ? 0 : 10;
 -	param->inband_tags = inband_tags;
 +	param->inband_tags = options.inband_tags;
 +	param->tags_9bytes = options.tags_9bytes;
 	param->enable_xattr = 1;
 	if (options.lazy_loading_overridden)
 --- a/fs/yaffs2/yaffs_mtdif.c
 +++ b/fs/yaffs2/yaffs_mtdif.c
@@ -276,7 +276,8 @@ struct mtd_info * yaffs_get_mtd_device(d
 	return mtd;
 }
 -int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags)
 +int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags,
 +		     int tags_9bytes)
 {
 	if (yaffs_version == 2) {
 		if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
@@ -295,6 +296,12 @@ int yaffs_verify_mtd(struct mtd_info *mt
 			);
 			return -1;
 		}
 +
 +		if (tags_9bytes && mtd->oobavail < 9) {
 +			yaffs_trace(YAFFS_TRACE_ALWAYS,
 +				    "MTD device does not support 9-byte tags");
 +			return -1;
 +		}
 	}
 	return 0;
 --- a/fs/yaffs2/yaffs_mtdif.h
 +++ b/fs/yaffs2/yaffs_mtdif.h
@@ -21,5 +21,6 @@
 void yaffs_mtd_drv_install(struct yaffs_dev *dev);
 struct mtd_info * yaffs_get_mtd_device(dev_t sdev);
 void yaffs_put_mtd_device(struct mtd_info *mtd);
 -int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags);
 +int yaffs_verify_mtd(struct mtd_info *mtd, int yaffs_version, int inband_tags,
 +		     int tags_9bytes);
 #endif
--- a/target/linux/generic/patches-3.13/504-yaffs-fix-compat-tags-handling.patch
+++ b/target/linux/generic/patches-3.13/504-yaffs-fix-compat-tags-handling.patch
@ -1,239 +0,0 @@
 Subject: yaffs: fix compat tags handling
 Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
 ---
 --- a/fs/yaffs2/yaffs_tagscompat.c
 +++ b/fs/yaffs2/yaffs_tagscompat.c
@@ -17,7 +17,9 @@
 #include "yaffs_getblockinfo.h"
 #include "yaffs_trace.h"
 +#if 0
 static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk);
 +#endif
 /********** Tags ECC calculations  *********/
@@ -71,6 +73,7 @@ int yaffs_check_tags_ecc(struct yaffs_ta
 	return 0;
 }
 +#if 0
 /********** Tags **********/
 static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr,
@@ -379,3 +382,214 @@ void yaffs_tags_compat_install(struct ya
 	if(!dev->tagger.mark_bad_fn)
 		dev->tagger.mark_bad_fn = yaffs_tags_compat_mark_bad;
 }
 +#else
 +
 +#include "yaffs_packedtags1.h"
 +
 +static int yaffs_tags_compat_write(struct yaffs_dev *dev,
 +				   int nand_chunk,
 +				   const u8 *data,
 +				   const struct yaffs_ext_tags *tags)
 +{
 +	struct yaffs_packed_tags1 pt1;
 +	u8 tag_buf[9];
 +	int retval;
 +
 +	/* we assume that yaffs_packed_tags1 and yaffs_tags are compatible */
 +	compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12);
 +	compile_time_assertion(sizeof(struct yaffs_tags) == 8);
 +
 +	yaffs_pack_tags1(&pt1, tags);
 +	yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1);
 +
 +	/* When deleting a chunk, the upper layer provides only skeletal
 +	 * tags, one with is_deleted set.  However, we need to update the
 +	 * tags, not erase them completely.  So we use the NAND write property
 +	 * that only zeroed-bits stick and set tag bytes to all-ones and
 +	 * zero just the (not) deleted bit.
 +	 */
 +	if (!dev->param.tags_9bytes) {
 +		if (tags->is_deleted) {
 +			memset(&pt1, 0xff, 8);
 +			/* clear delete status bit to indicate deleted */
 +			pt1.deleted = 0;
 +		}
 +		memcpy(tag_buf, &pt1, 8);
 +	} else {
 +		if (tags->is_deleted) {
 +			memset(tag_buf, 0xff, 8);
 +			tag_buf[8] = 0;
 +		} else {
 +			memcpy(tag_buf, &pt1, 8);
 +			tag_buf[8] = 0xff;
 +		}
 +	}
 +
 +	retval = dev->drv.drv_write_chunk_fn(dev, nand_chunk,
 +			data,
 +			(data) ? dev->data_bytes_per_chunk : 0,
 +			tag_buf,
 +			(dev->param.tags_9bytes) ? 9 : 8);
 +
 +	return retval;
 +}
 +
 +/* Return with empty extended tags but add ecc_result.
 + */
 +static int return_empty_tags(struct yaffs_ext_tags *tags,
 +			     enum yaffs_ecc_result ecc_result,
 +			     int retval)
 +{
 +	if (tags) {
 +		memset(tags, 0, sizeof(*tags));
 +		tags->ecc_result = ecc_result;
 +	}
 +
 +	return retval;
 +}
 +
 +static int yaffs_tags_compat_read(struct yaffs_dev *dev,
 +				  int nand_chunk,
 +				  u8 *data,
 +				  struct yaffs_ext_tags *tags)
 +{
 +	struct yaffs_packed_tags1 pt1;
 +	enum yaffs_ecc_result ecc_result;
 +	int retval;
 +	int deleted;
 +	u8 tag_buf[9];
 +
 +	retval = dev->drv.drv_read_chunk_fn(dev, nand_chunk,
 +			data, dev->param.total_bytes_per_chunk,
 +			tag_buf,
 +			(dev->param.tags_9bytes) ? 9 : 8,
 +			&ecc_result);
 +
 +	switch (ecc_result) {
 +	case YAFFS_ECC_RESULT_NO_ERROR:
 +	case YAFFS_ECC_RESULT_FIXED:
 +		break;
 +
 +	case YAFFS_ECC_RESULT_UNFIXED:
 +	default:
 +		return_empty_tags(tags, YAFFS_ECC_RESULT_UNFIXED, 0);
 +		tags->block_bad = dev->drv.drv_check_bad_fn(dev, nand_chunk);
 +		return YAFFS_FAIL;
 +	}
 +
 +	/* Check for a blank/erased chunk. */
 +	if (yaffs_check_ff(tag_buf, 8)) {
 +		/* when blank, upper layers want ecc_result to be <= NO_ERROR */
 +		return return_empty_tags(tags, YAFFS_ECC_RESULT_NO_ERROR,
 +					 YAFFS_OK);
 +	}
 +
 +	memcpy(&pt1, tag_buf, 8);
 +
 +	if (!dev->param.tags_9bytes) {
 +		/* Read deleted status (bit) then return it to it's non-deleted
 +		 * state before performing tags mini-ECC check. pt1.deleted is
 +		 * inverted.
 +		 */
 +		deleted = !pt1.deleted;
 +		pt1.deleted = 1;
 +	} else {
 +		deleted = (hweight8(tag_buf[8]) < 7) ? 1 : 0;
 +	}
 +
 +	/* Check the packed tags mini-ECC and correct if necessary/possible. */
 +	retval = yaffs_check_tags_ecc((struct yaffs_tags *)&pt1);
 +	switch (retval) {
 +	case 0:
 +		/* no tags error, use MTD result */
 +		break;
 +	case 1:
 +		/* recovered tags-ECC error */
 +		dev->n_tags_ecc_fixed++;
 +		if (ecc_result == YAFFS_ECC_RESULT_NO_ERROR)
 +			ecc_result = YAFFS_ECC_RESULT_FIXED;
 +		break;
 +	default:
 +		/* unrecovered tags-ECC error */
 +		dev->n_tags_ecc_unfixed++;
 +		return return_empty_tags(tags, YAFFS_ECC_RESULT_UNFIXED,
 +					 YAFFS_FAIL);
 +	}
 +
 +	/* Unpack the tags to extended form and set ECC result.
 +	 * [set should_be_ff just to keep yaffs_unpack_tags1 happy]
 +	 */
 +	pt1.should_be_ff = 0xffffffff;
 +	yaffs_unpack_tags1(tags, &pt1);
 +	tags->ecc_result = ecc_result;
 +
 +	/* Set deleted state */
 +	tags->is_deleted = deleted;
 +	return YAFFS_OK;
 +}
 +
 +static int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no)
 +{
 +	return dev->drv.drv_mark_bad_fn(dev, block_no);
 +}
 +
 +static int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
 +					 int block_no,
 +					 enum yaffs_block_state *state,
 +					 u32 *seq_number)
 +{
 +	struct yaffs_ext_tags tags;
 +	int retval;
 +
 +	yaffs_trace(YAFFS_TRACE_MTD, "%s %d", __func__, block_no);
 +
 +	*seq_number = 0;
 +
 +	retval = dev->drv.drv_check_bad_fn(dev, block_no);
 +	if (retval == YAFFS_FAIL) {
 +		*state = YAFFS_BLOCK_STATE_DEAD;
 +		goto out;
 +	}
 +
 +	yaffs_tags_compat_read(dev, block_no * dev->param.chunks_per_block,
 +			       NULL, &tags);
 +
 +	if (tags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
 +		yaffs_trace(YAFFS_TRACE_MTD, "block %d is marked bad",
 +			    block_no);
 +		*state = YAFFS_BLOCK_STATE_NEEDS_SCAN;
 +	} else if (tags.chunk_used) {
 +		*seq_number = tags.seq_number;
 +		*state = YAFFS_BLOCK_STATE_NEEDS_SCAN;
 +	} else {
 +		*state = YAFFS_BLOCK_STATE_EMPTY;
 +	}
 +
 +	retval = YAFFS_OK;
 +
 +out:
 +	yaffs_trace(YAFFS_TRACE_MTD,
 +		    "block query returns seq %u state %d",
 +		    *seq_number, *state);
 +
 +	return retval;
 +}
 +
 +void yaffs_tags_compat_install(struct yaffs_dev *dev)
 +{
 +	if (dev->param.is_yaffs2)
 +		return;
 +
 +	if (!dev->tagger.write_chunk_tags_fn)
 +		dev->tagger.write_chunk_tags_fn = yaffs_tags_compat_write;
 +
 +	if (!dev->tagger.read_chunk_tags_fn)
 +		dev->tagger.read_chunk_tags_fn = yaffs_tags_compat_read;
 +
 +	if (!dev->tagger.query_block_fn)
 +		dev->tagger.query_block_fn = yaffs_tags_compat_query_block;
 +
 +	if (!dev->tagger.mark_bad_fn)
 +		dev->tagger.mark_bad_fn = yaffs_tags_compat_mark_bad;
 +}
 +#endif
--- a/target/linux/generic/patches-3.13/520-squashfs_update_xz_comp_opts.patch
+++ b/target/linux/generic/patches-3.13/520-squashfs_update_xz_comp_opts.patch
@ -1,25 +0,0 @@
 From f31b7c0efa255dd17a5f584022a319387f09b0d8 Mon Sep 17 00:00:00 2001
 From: Jonas Gorski <jonas.gorski@gmail.com>
 Date: Tue, 12 Apr 2011 19:55:41 +0200
 Subject: [PATCH] squashfs: update xz compressor options struct.
 Update the xz compressor options struct to match the squashfs userspace
 one.
 ---
 fs/squashfs/xz_wrapper.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)
 --- a/fs/squashfs/xz_wrapper.c
 +++ b/fs/squashfs/xz_wrapper.c
@@ -40,8 +40,10 @@ struct squashfs_xz {
 };
 struct disk_comp_opts {
 -	__le32 dictionary_size;
 	__le32 flags;
 +	__le16 bit_opts;
 +	__le16 fb;
 +	__le32 dictionary_size;
 };
 struct comp_opts {
--- a/target/linux/generic/patches-3.13/530-jffs2_make_lzma_available.patch
+++ b/target/linux/generic/patches-3.13/530-jffs2_make_lzma_available.patch
--- a/target/linux/generic/patches-3.13/531-debloat_lzma.patch
+++ b/target/linux/generic/patches-3.13/531-debloat_lzma.patch
--- a/target/linux/generic/patches-3.13/532-jffs2_eofdetect.patch
+++ b/target/linux/generic/patches-3.13/532-jffs2_eofdetect.patch
@ -1,56 +0,0 @@
 --- a/fs/jffs2/build.c
 +++ b/fs/jffs2/build.c
@@ -114,6 +114,16 @@ static int jffs2_build_filesystem(struct
 	dbg_fsbuild("scanned flash completely\n");
 	jffs2_dbg_dump_block_lists_nolock(c);
 +	if (c->flags & (1 << 7)) {
 +		printk("%s(): unlocking the mtd device... ", __func__);
 +		mtd_unlock(c->mtd, 0, c->mtd->size);
 +		printk("done.\n");
 +
 +		printk("%s(): erasing all blocks after the end marker... ", __func__);
 +		jffs2_erase_pending_blocks(c, -1);
 +		printk("done.\n");
 +	}
 +
 	dbg_fsbuild("pass 1 starting\n");
 	c->flags |= JFFS2_SB_FLAG_BUILDING;
 	/* Now scan the directory tree, increasing nlink according to every dirent found. */
 --- a/fs/jffs2/scan.c
 +++ b/fs/jffs2/scan.c
@@ -148,8 +148,14 @@ int jffs2_scan_medium(struct jffs2_sb_in
 		/* reset summary info for next eraseblock scan */
 		jffs2_sum_reset_collected(s);
 -		ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
 -						buf_size, s);
 +		if (c->flags & (1 << 7)) {
 +			if (mtd_block_isbad(c->mtd, jeb->offset))
 +				ret = BLK_STATE_BADBLOCK;
 +			else
 +				ret = BLK_STATE_ALLFF;
 +		} else
 +			ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
 +							buf_size, s);
 		if (ret < 0)
 			goto out;
@@ -556,6 +562,17 @@ static int jffs2_scan_eraseblock (struct
 			return err;
 	}
 +	if ((buf[0] == 0xde) &&
 +		(buf[1] == 0xad) &&
 +		(buf[2] == 0xc0) &&
 +		(buf[3] == 0xde)) {
 +		/* end of filesystem. erase everything after this point */
 +		printk("%s(): End of filesystem marker found at 0x%x\n", __func__, jeb->offset);
 +		c->flags |= (1 << 7);
 +
 +		return BLK_STATE_ALLFF;
 +	}
 +
 	/* We temporarily use 'ofs' as a pointer into the buffer/jeb */
 	ofs = 0;
 	max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
--- a/target/linux/generic/patches-3.13/540-crypto-xz-decompression-support.patch
+++ b/target/linux/generic/patches-3.13/540-crypto-xz-decompression-support.patch
@ -1,146 +0,0 @@
 --- a/crypto/Kconfig
 +++ b/crypto/Kconfig
@@ -1367,6 +1367,13 @@ config CRYPTO_LZ4HC
 	help
 	  This is the LZ4 high compression mode algorithm.
 +config CRYPTO_XZ
 +	tristate "XZ compression algorithm"
 +	select CRYPTO_ALGAPI
 +	select XZ_DEC
 +	help
 +	  This is the XZ algorithm. Only decompression is supported for now.
 +
 comment "Random Number Generation"
 config CRYPTO_ANSI_CPRNG
 --- a/crypto/Makefile
 +++ b/crypto/Makefile
@@ -93,6 +93,7 @@ obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.
 obj-$(CONFIG_CRYPTO_LZO) += lzo.o
 obj-$(CONFIG_CRYPTO_LZ4) += lz4.o
 obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o
 +obj-$(CONFIG_CRYPTO_XZ) += xz.o
 obj-$(CONFIG_CRYPTO_842) += 842.o
 obj-$(CONFIG_CRYPTO_RNG2) += rng.o
 obj-$(CONFIG_CRYPTO_RNG2) += krng.o
 --- /dev/null
 +++ b/crypto/xz.c
@@ -0,0 +1,117 @@
 +/*
 + * Cryptographic API.
 + *
 + * XZ decompression support.
 + *
 + * Copyright (c) 2012 Gabor Juhos <juhosg@openwrt.org>
 + *
 + * 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/init.h>
 +#include <linux/module.h>
 +#include <linux/crypto.h>
 +#include <linux/xz.h>
 +#include <linux/interrupt.h>
 +#include <linux/mm.h>
 +#include <linux/net.h>
 +
 +struct xz_comp_ctx {
 +	struct xz_dec	*decomp_state;
 +	struct xz_buf	decomp_buf;
 +};
 +
 +static int crypto_xz_decomp_init(struct xz_comp_ctx *ctx)
 +{
 +	ctx->decomp_state = xz_dec_init(XZ_SINGLE, 0);
 +	if (!ctx->decomp_state)
 +		return -ENOMEM;
 +
 +	return 0;
 +}
 +
 +static void crypto_xz_decomp_exit(struct xz_comp_ctx *ctx)
 +{
 +	xz_dec_end(ctx->decomp_state);
 +}
 +
 +static int crypto_xz_init(struct crypto_tfm *tfm)
 +{
 +	struct xz_comp_ctx *ctx = crypto_tfm_ctx(tfm);
 +
 +	return crypto_xz_decomp_init(ctx);
 +}
 +
 +static void crypto_xz_exit(struct crypto_tfm *tfm)
 +{
 +	struct xz_comp_ctx *ctx = crypto_tfm_ctx(tfm);
 +
 +	crypto_xz_decomp_exit(ctx);
 +}
 +
 +static int crypto_xz_compress(struct crypto_tfm *tfm, const u8 *src,
 +			      unsigned int slen, u8 *dst, unsigned int *dlen)
 +{
 +	return -EOPNOTSUPP;
 +}
 +
 +static int crypto_xz_decompress(struct crypto_tfm *tfm, const u8 *src,
 +				unsigned int slen, u8 *dst, unsigned int *dlen)
 +{
 +	struct xz_comp_ctx *dctx = crypto_tfm_ctx(tfm);
 +	struct xz_buf *xz_buf = &dctx->decomp_buf;
 +	int ret;
 +
 +	memset(xz_buf, '\0', sizeof(struct xz_buf));
 +
 +	xz_buf->in = (u8 *) src;
 +	xz_buf->in_pos = 0;
 +	xz_buf->in_size = slen;
 +	xz_buf->out = (u8 *) dst;
 +	xz_buf->out_pos = 0;
 +	xz_buf->out_size = *dlen;
 +
 +	ret = xz_dec_run(dctx->decomp_state, xz_buf);
 +	if (ret != XZ_STREAM_END) {
 +		ret = -EINVAL;
 +		goto out;
 +	}
 +
 +	*dlen = xz_buf->out_pos;
 +	ret = 0;
 +
 +out:
 +	return ret;
 +}
 +
 +static struct crypto_alg crypto_xz_alg = {
 +	.cra_name		= "xz",
 +	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
 +	.cra_ctxsize		= sizeof(struct xz_comp_ctx),
 +	.cra_module		= THIS_MODULE,
 +	.cra_list		= LIST_HEAD_INIT(crypto_xz_alg.cra_list),
 +	.cra_init		= crypto_xz_init,
 +	.cra_exit		= crypto_xz_exit,
 +	.cra_u			= { .compress = {
 +	.coa_compress 		= crypto_xz_compress,
 +	.coa_decompress  	= crypto_xz_decompress } }
 +};
 +
 +static int __init crypto_xz_mod_init(void)
 +{
 +	return crypto_register_alg(&crypto_xz_alg);
 +}
 +
 +static void __exit crypto_xz_mod_exit(void)
 +{
 +	crypto_unregister_alg(&crypto_xz_alg);
 +}
 +
 +module_init(crypto_xz_mod_init);
 +module_exit(crypto_xz_mod_exit);
 +
 +MODULE_LICENSE("GPL v2");
 +MODULE_DESCRIPTION("Crypto XZ decompression support");
 +MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
--- a/target/linux/generic/patches-3.13/541-ubifs-xz-decompression-support.patch
+++ b/target/linux/generic/patches-3.13/541-ubifs-xz-decompression-support.patch
@ -1,92 +0,0 @@
 --- a/fs/ubifs/Kconfig
 +++ b/fs/ubifs/Kconfig
@@ -5,8 +5,10 @@ config UBIFS_FS
 	select CRYPTO if UBIFS_FS_ADVANCED_COMPR
 	select CRYPTO if UBIFS_FS_LZO
 	select CRYPTO if UBIFS_FS_ZLIB
 +	select CRYPTO if UBIFS_FS_XZ
 	select CRYPTO_LZO if UBIFS_FS_LZO
 	select CRYPTO_DEFLATE if UBIFS_FS_ZLIB
 +	select CRYPTO_XZ if UBIFS_FS_XZ
 	depends on MTD_UBI
 	help
 	  UBIFS is a file system for flash devices which works on top of UBI.
@@ -35,3 +37,12 @@ config UBIFS_FS_ZLIB
 	default y
 	help
 	  Zlib compresses better than LZO but it is slower. Say 'Y' if unsure.
 +
 +config UBIFS_FS_XZ
 +	bool "XZ decompression support" if UBIFS_FS_ADVANCED_COMPR
 +	depends on UBIFS_FS
 +	default y
 +	help
 +	  XZ compresses better the ZLIB but it is slower..
 +	  Say 'Y' if unsure.
 +
 --- a/fs/ubifs/compress.c
 +++ b/fs/ubifs/compress.c
@@ -71,6 +71,24 @@ static struct ubifs_compressor zlib_comp
 };
 #endif
 +#ifdef CONFIG_UBIFS_FS_XZ
 +static DEFINE_MUTEX(xz_enc_mutex);
 +static DEFINE_MUTEX(xz_dec_mutex);
 +
 +static struct ubifs_compressor xz_compr = {
 +	.compr_type = UBIFS_COMPR_XZ,
 +	.comp_mutex = &xz_enc_mutex,
 +	.decomp_mutex = &xz_dec_mutex,
 +	.name = "xz",
 +	.capi_name = "xz",
 +};
 +#else
 +static struct ubifs_compressor xz_compr = {
 +	.compr_type = UBIFS_COMPR_XZ,
 +	.name = "xz",
 +};
 +#endif
 +
 /* All UBIFS compressors */
 struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
@@ -232,9 +250,15 @@ int __init ubifs_compressors_init(void)
 	if (err)
 		goto out_lzo;
 +	err = compr_init(&xz_compr);
 +	if (err)
 +		goto out_zlib;
 +
 	ubifs_compressors[UBIFS_COMPR_NONE] = &none_compr;
 	return 0;
 +out_zlib:
 +	compr_exit(&zlib_compr);
 out_lzo:
 	compr_exit(&lzo_compr);
 	return err;
@@ -247,4 +271,5 @@ void ubifs_compressors_exit(void)
 {
 	compr_exit(&lzo_compr);
 	compr_exit(&zlib_compr);
 +	compr_exit(&xz_compr);
 }
 --- a/fs/ubifs/ubifs-media.h
 +++ b/fs/ubifs/ubifs-media.h
@@ -332,12 +332,14 @@ enum {
  * UBIFS_COMPR_NONE: no compression
  * UBIFS_COMPR_LZO: LZO compression
  * UBIFS_COMPR_ZLIB: ZLIB compression
 + * UBIFS_COMPR_XZ: XZ compression
  * UBIFS_COMPR_TYPES_CNT: count of supported compression types
  */
 enum {
 	UBIFS_COMPR_NONE,
 	UBIFS_COMPR_LZO,
 	UBIFS_COMPR_ZLIB,
 +	UBIFS_COMPR_XZ,
 	UBIFS_COMPR_TYPES_CNT,
 };
--- a/target/linux/generic/patches-3.13/550-ubifs-symlink-xattr-support.patch
+++ b/target/linux/generic/patches-3.13/550-ubifs-symlink-xattr-support.patch
@ -1,65 +0,0 @@
 --- a/fs/ubifs/file.c
 +++ b/fs/ubifs/file.c
@@ -1577,6 +1577,10 @@ const struct inode_operations ubifs_syml
 	.follow_link = ubifs_follow_link,
 	.setattr     = ubifs_setattr,
 	.getattr     = ubifs_getattr,
 +	.setxattr    = ubifs_setxattr,
 +	.getxattr    = ubifs_getxattr,
 +	.listxattr   = ubifs_listxattr,
 +	.removexattr = ubifs_removexattr,
 };
 const struct file_operations ubifs_file_operations = {
 --- a/fs/ubifs/journal.c
 +++ b/fs/ubifs/journal.c
@@ -553,7 +553,8 @@ int ubifs_jnl_update(struct ubifs_info *
 	dbg_jnl("ino %lu, dent '%.*s', data len %d in dir ino %lu",
 		inode->i_ino, nm->len, nm->name, ui->data_len, dir->i_ino);
 -	ubifs_assert(dir_ui->data_len == 0);
 +	if (!xent)
 +		ubifs_assert(dir_ui->data_len == 0);
 	ubifs_assert(mutex_is_locked(&dir_ui->ui_mutex));
 	dlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
@@ -573,6 +574,13 @@ int ubifs_jnl_update(struct ubifs_info *
 	aligned_dlen = ALIGN(dlen, 8);
 	aligned_ilen = ALIGN(ilen, 8);
 	len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
 +	if (xent) {
 +		/*
 +		 * Make sure to account for dir_ui->data_len in
 +		 * length calculation in case there is extended attribute.
 +		 */
 +		len += dir_ui->data_len;
 +	}
 	dent = kmalloc(len, GFP_NOFS);
 	if (!dent)
 		return -ENOMEM;
@@ -649,7 +657,8 @@ int ubifs_jnl_update(struct ubifs_info *
 	ino_key_init(c, &ino_key, dir->i_ino);
 	ino_offs += aligned_ilen;
 -	err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, UBIFS_INO_NODE_SZ);
 +	err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs,
 +			    UBIFS_INO_NODE_SZ + dir_ui->data_len);
 	if (err)
 		goto out_ro;
 --- a/fs/ubifs/xattr.c
 +++ b/fs/ubifs/xattr.c
@@ -209,12 +209,12 @@ static int change_xattr(struct ubifs_inf
 		goto out_free;
 	}
 	inode->i_size = ui->ui_size = size;
 -	ui->data_len = size;
 	mutex_lock(&host_ui->ui_mutex);
 	host->i_ctime = ubifs_current_time(host);
 	host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
 	host_ui->xattr_size += CALC_XATTR_BYTES(size);
 +	ui->data_len = size;
 	/*
 	 * It is important to write the host inode after the xattr inode
--- a/target/linux/generic/patches-3.13/551-ubifs-fix-default-compression-selection.patch
+++ b/target/linux/generic/patches-3.13/551-ubifs-fix-default-compression-selection.patch
@ -1,29 +0,0 @@
 --- a/fs/ubifs/sb.c
 +++ b/fs/ubifs/sb.c
@@ -63,6 +63,17 @@
 /* Default time granularity in nanoseconds */
 #define DEFAULT_TIME_GRAN 1000000000
 +static int get_default_compressor(void)
 +{
 +	if (ubifs_compr_present(UBIFS_COMPR_LZO))
 +		return UBIFS_COMPR_LZO;
 +
 +	if (ubifs_compr_present(UBIFS_COMPR_ZLIB))
 +		return UBIFS_COMPR_ZLIB;
 +
 +	return UBIFS_COMPR_NONE;
 +}
 +
 /**
  * create_default_filesystem - format empty UBI volume.
  * @c: UBIFS file-system description object
@@ -183,7 +194,7 @@ static int create_default_filesystem(str
 	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);
 +		sup->default_compr = cpu_to_le16(get_default_compressor());
 	generate_random_uuid(sup->uuid);
--- a/target/linux/generic/patches-3.13/555-gluebi-sysfs-support.patch
+++ b/target/linux/generic/patches-3.13/555-gluebi-sysfs-support.patch
@ -1,86 +0,0 @@
 --- a/drivers/mtd/ubi/gluebi.c
 +++ b/drivers/mtd/ubi/gluebi.c
@@ -38,6 +38,7 @@
 #include <linux/mutex.h>
 #include <linux/mtd/ubi.h>
 #include <linux/mtd/mtd.h>
 +#include <linux/export.h>
 #include "ubi-media.h"
 #define err_msg(fmt, ...)                                   \
@@ -66,6 +67,16 @@ struct gluebi_device {
 static LIST_HEAD(gluebi_devices);
 static DEFINE_MUTEX(devices_mutex);
 +/* Device attribute handler for gluebi files in '/<sysfs>/class/mtd/mtdX' */
 +static ssize_t gluebi_attribute_show(struct device *dev,
 +	struct device_attribute *attr, char *buf);
 +
 +/* Device attributes corresponding to files in '/<sysfs>/class/mtd/mtdX' */
 +static struct device_attribute attr_vol_gluebi_ubi_num =
 +__ATTR(gluebi_ubi_num, S_IRUGO, gluebi_attribute_show, NULL);
 +static struct device_attribute attr_vol_gluebi_vol_id =
 +__ATTR(gluebi_vol_id, S_IRUGO, gluebi_attribute_show, NULL);
 +
 /**
  * find_gluebi_nolock - find a gluebi device.
  * @ubi_num: UBI device number
@@ -288,6 +299,36 @@ out_err:
 }
 /**
 + * gluebi_attribute_show - "Show" method for gluebi files in sysfs.
 + */
 +static ssize_t gluebi_attribute_show(struct device *dev,
 +				  struct device_attribute *attr, char *buf)
 +{
 +	int ret;
 +	struct mtd_info *mtd = container_of(dev, struct mtd_info, dev);
 +	struct gluebi_device *gluebi;
 +
 +	gluebi_get_device(mtd);
 +	gluebi = container_of(mtd, struct gluebi_device, mtd);
 +
 +	/* This really shouldn't happen */
 +	if (!gluebi)
 +		return -ENODEV;
 +
 +	if (attr == &attr_vol_gluebi_ubi_num) {
 +		ret = sprintf(buf, "%u\n", gluebi->ubi_num);
 +	} else if (attr == &attr_vol_gluebi_vol_id) {
 +		ret = sprintf(buf, "%u\n", gluebi->vol_id);
 +	} else {
 +		/* This must be a bug */
 +		ret = -EINVAL;
 +	}
 +
 +	gluebi_put_device(mtd);
 +	return ret;
 +}
 +
 +/**
  * gluebi_create - create a gluebi device for an UBI volume.
  * @di: UBI device description object
  * @vi: UBI volume description object
@@ -355,6 +396,8 @@ static int gluebi_create(struct ubi_devi
 	mutex_lock(&devices_mutex);
 	list_add_tail(&gluebi->list, &gluebi_devices);
 	mutex_unlock(&devices_mutex);
 +	device_create_file(&mtd->dev, &attr_vol_gluebi_ubi_num);
 +	device_create_file(&mtd->dev, &attr_vol_gluebi_vol_id);
 	return 0;
 }
@@ -380,8 +423,11 @@ static int gluebi_remove(struct ubi_volu
 		err = -ENOENT;
 	} else if (gluebi->refcnt)
 		err = -EBUSY;
 -	else
 +	else {
 +		device_remove_file(&gluebi->mtd.dev, &attr_vol_gluebi_ubi_num);
 +		device_remove_file(&gluebi->mtd.dev, &attr_vol_gluebi_vol_id);
 		list_del(&gluebi->list);
 +	}
 	mutex_unlock(&devices_mutex);
 	if (err)
 		return err;
--- a/target/linux/generic/patches-3.13/600-netfilter_layer7_2.22.patch
+++ b/target/linux/generic/patches-3.13/600-netfilter_layer7_2.22.patch
--- a/target/linux/generic/patches-3.13/601-netfilter_layer7_pktmatch.patch
+++ b/target/linux/generic/patches-3.13/601-netfilter_layer7_pktmatch.patch
@ -1,108 +0,0 @@
 --- a/include/linux/netfilter/xt_layer7.h
 +++ b/include/linux/netfilter/xt_layer7.h
@@ -8,6 +8,7 @@ struct xt_layer7_info {
     char protocol[MAX_PROTOCOL_LEN];
     char pattern[MAX_PATTERN_LEN];
     u_int8_t invert;
 +    u_int8_t pkt;
 };
 #endif /* _XT_LAYER7_H */
 --- a/net/netfilter/xt_layer7.c
 +++ b/net/netfilter/xt_layer7.c
@@ -314,33 +314,35 @@ static int match_no_append(struct nf_con
 }
 /* add the new app data to the conntrack.  Return number of bytes added. */
 -static int add_data(struct nf_conn * master_conntrack,
 -                    char * app_data, int appdatalen)
 +static int add_datastr(char *target, int offset, char *app_data, int len)
 {
 	int length = 0, i;
 -	int oldlength = master_conntrack->layer7.app_data_len;
 -
 -	/* This is a fix for a race condition by Deti Fliegl. However, I'm not 
 -	   clear on whether the race condition exists or whether this really 
 -	   fixes it.  I might just be being dense... Anyway, if it's not really 
 -	   a fix, all it does is waste a very small amount of time. */
 -	if(!master_conntrack->layer7.app_data) return 0;
 +	if (!target) return 0;
 	/* Strip nulls. Make everything lower case (our regex lib doesn't
 	do case insensitivity).  Add it to the end of the current data. */
 -	for(i = 0; i < maxdatalen-oldlength-1 &&
 -		   i < appdatalen; i++) {
 + 	for(i = 0; i < maxdatalen-offset-1 && i < len; i++) {
 		if(app_data[i] != '\0') {
 			/* the kernel version of tolower mungs 'upper ascii' */
 -			master_conntrack->layer7.app_data[length+oldlength] =
 +			target[length+offset] =
 				isascii(app_data[i])? 
 					tolower(app_data[i]) : app_data[i];
 			length++;
 		}
 	}
 +	target[length+offset] = '\0';
 +
 +	return length;
 +}
 +
 +/* add the new app data to the conntrack.  Return number of bytes added. */
 +static int add_data(struct nf_conn * master_conntrack,
 +                    char * app_data, int appdatalen)
 +{
 +	int length;
 -	master_conntrack->layer7.app_data[length+oldlength] = '\0';
 -	master_conntrack->layer7.app_data_len = length + oldlength;
 +	length = add_datastr(master_conntrack->layer7.app_data, master_conntrack->layer7.app_data_len, app_data, appdatalen);
 +	master_conntrack->layer7.app_data_len += length;
 	return length;
 }
@@ -438,7 +440,7 @@ match(const struct sk_buff *skbin,
 	enum ip_conntrack_info master_ctinfo, ctinfo;
 	struct nf_conn *master_conntrack, *conntrack;
 -	unsigned char * app_data;
 +	unsigned char *app_data, *tmp_data;
 	unsigned int pattern_result, appdatalen;
 	regexp * comppattern;
@@ -466,8 +468,8 @@ match(const struct sk_buff *skbin,
 		master_conntrack = master_ct(master_conntrack);
 	/* if we've classified it or seen too many packets */
 -	if(total_acct_packets(master_conntrack) > num_packets ||
 -	   master_conntrack->layer7.app_proto) {
 +	if(!info->pkt && (total_acct_packets(master_conntrack) > num_packets ||
 +	   master_conntrack->layer7.app_proto)) {
 		pattern_result = match_no_append(conntrack, master_conntrack, 
 						 ctinfo, master_ctinfo, info);
@@ -500,6 +502,25 @@ match(const struct sk_buff *skbin,
 	/* the return value gets checked later, when we're ready to use it */
 	comppattern = compile_and_cache(info->pattern, info->protocol);
 +	if (info->pkt) {
 +		tmp_data = kmalloc(maxdatalen, GFP_ATOMIC);
 +		if(!tmp_data){
 +			if (net_ratelimit())
 +				printk(KERN_ERR "layer7: out of memory in match, bailing.\n");
 +			return info->invert;
 +		}
 +
 +		tmp_data[0] = '\0';
 +		add_datastr(tmp_data, 0, app_data, appdatalen);
 +		pattern_result = ((comppattern && regexec(comppattern, tmp_data)) ? 1 : 0);
 +
 +		kfree(tmp_data);
 +		tmp_data = NULL;
 +		spin_unlock_bh(&l7_lock);
 +
 +		return (pattern_result ^ info->invert);
 +	}
 +
 	/* On the first packet of a connection, allocate space for app data */
 	if(total_acct_packets(master_conntrack) == 1 && !skb->cb[0] && 
 	   !master_conntrack->layer7.app_data){
--- a/target/linux/generic/patches-3.13/602-netfilter_layer7_match.patch
+++ b/target/linux/generic/patches-3.13/602-netfilter_layer7_match.patch
@ -1,51 +0,0 @@
 --- a/net/netfilter/xt_layer7.c
 +++ b/net/netfilter/xt_layer7.c
@@ -415,7 +415,9 @@ static int layer7_write_proc(struct file
 }
 static bool
 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
 +match(const struct sk_buff *skbin, struct xt_action_param *par)
 +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
 match(const struct sk_buff *skbin, const struct xt_match_param *par)
 #else
 match(const struct sk_buff *skbin,
@@ -597,14 +599,19 @@ match(const struct sk_buff *skbin,
 }
 // load nf_conntrack_ipv4
 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
 +static int
 +#else
 +static bool
 +#endif
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
 -static bool check(const struct xt_mtchk_param *par)
 +check(const struct xt_mtchk_param *par)
 {
         if (nf_ct_l3proto_try_module_get(par->match->family) < 0) {
                 printk(KERN_WARNING "can't load conntrack support for "
                                     "proto=%d\n", par->match->family);
 #else
 -static bool check(const char *tablename, const void *inf,
 +check(const char *tablename, const void *inf,
 		 const struct xt_match *match, void *matchinfo,
 		 unsigned int hook_mask)
 {
@@ -612,9 +619,15 @@ static bool check(const char *tablename,
                 printk(KERN_WARNING "can't load conntrack support for "
                                     "proto=%d\n", match->family);
 #endif
 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
 +		return -EINVAL;
 +	}
 +	return 0;
 +#else
                 return 0;
         }
 	return 1;
 +#endif
 }
--- a/target/linux/generic/patches-3.13/603-netfilter_layer7_2.6.36_fix.patch
+++ b/target/linux/generic/patches-3.13/603-netfilter_layer7_2.6.36_fix.patch
@ -1,61 +0,0 @@
 --- a/net/netfilter/Kconfig
 +++ b/net/netfilter/Kconfig
@@ -1053,6 +1053,27 @@ config NETFILTER_XT_MATCH_IPVS
 	  If unsure, say N.
 +config NETFILTER_XT_MATCH_LAYER7
 +	tristate '"layer7" match support'
 +	depends on EXPERIMENTAL
 +	depends on NETFILTER_XTABLES
 +	depends on NETFILTER_ADVANCED
 +	depends on NF_CONNTRACK
 +	help
 +	  Say Y if you want to be able to classify connections (and their
 +	  packets) based on regular expression matching of their application
 +	  layer data.   This is one way to classify applications such as
 +	  peer-to-peer filesharing systems that do not always use the same
 +	  port.
 +
 +	  To compile it as a module, choose M here.  If unsure, say N.
 +
 +config NETFILTER_XT_MATCH_LAYER7_DEBUG
 +	bool 'Layer 7 debugging output'
 +	depends on NETFILTER_XT_MATCH_LAYER7
 +	help
 +	  Say Y to get lots of debugging output.
 +
 config NETFILTER_XT_MATCH_LENGTH
 	tristate '"length" match support'
 	depends on NETFILTER_ADVANCED
@@ -1247,26 +1268,11 @@ config NETFILTER_XT_MATCH_STATE
 	  To compile it as a module, choose M here.  If unsure, say N.
 -config NETFILTER_XT_MATCH_LAYER7
 -	tristate '"layer7" match support'
 -	depends on NETFILTER_XTABLES
 -	depends on EXPERIMENTAL && (IP_NF_CONNTRACK || NF_CONNTRACK)
 -       depends on NETFILTER_ADVANCED
 -	help
 -	  Say Y if you want to be able to classify connections (and their
 -	  packets) based on regular expression matching of their application
 -	  layer data.   This is one way to classify applications such as
 -	  peer-to-peer filesharing systems that do not always use the same
 -	  port.
 -
 -	  To compile it as a module, choose M here.  If unsure, say N.
 -
 config NETFILTER_XT_MATCH_LAYER7_DEBUG
 -        bool 'Layer 7 debugging output'
 -        depends on NETFILTER_XT_MATCH_LAYER7
 -        help
 -          Say Y to get lots of debugging output.
 -
 +	bool 'Layer 7 debugging output'
 +	depends on NETFILTER_XT_MATCH_LAYER7
 +	help
 +	  Say Y to get lots of debugging output.
 config NETFILTER_XT_MATCH_STATISTIC
 	tristate '"statistic" match support'
--- a/target/linux/generic/patches-3.13/604-netfilter_conntrack_flush.patch
+++ b/target/linux/generic/patches-3.13/604-netfilter_conntrack_flush.patch
@ -1,86 +0,0 @@
 --- a/net/netfilter/nf_conntrack_standalone.c
 +++ b/net/netfilter/nf_conntrack_standalone.c
@@ -17,6 +17,7 @@
 #include <linux/percpu.h>
 #include <linux/netdevice.h>
 #include <linux/security.h>
 +#include <linux/inet.h>
 #include <net/net_namespace.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
@@ -268,10 +269,66 @@ static int ct_open(struct inode *inode,
 			sizeof(struct ct_iter_state));
 }
 +struct kill_request {
 +	u16 family;
 +	union nf_inet_addr addr;
 +};
 +
 +static int kill_matching(struct nf_conn *i, void *data)
 +{
 +	struct kill_request *kr = data;
 +	struct nf_conntrack_tuple *t1 = &i->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
 +	struct nf_conntrack_tuple *t2 = &i->tuplehash[IP_CT_DIR_REPLY].tuple;
 +
 +	if (!kr->family)
 +		return 1;
 +
 +	if (t1->src.l3num != kr->family)
 +		return 0;
 +
 +	return (nf_inet_addr_cmp(&kr->addr, &t1->src.u3) ||
 +	        nf_inet_addr_cmp(&kr->addr, &t1->dst.u3) ||
 +	        nf_inet_addr_cmp(&kr->addr, &t2->src.u3) ||
 +	        nf_inet_addr_cmp(&kr->addr, &t2->dst.u3));
 +}
 +
 +static ssize_t ct_file_write(struct file *file, const char __user *buf,
 +			     size_t count, loff_t *ppos)
 +{
 +	struct seq_file *seq = file->private_data;
 +	struct net *net = seq_file_net(seq);
 +	struct kill_request kr = { };
 +	char req[INET6_ADDRSTRLEN] = { };
 +
 +	if (count == 0)
 +		return 0;
 +
 +	if (count >= INET6_ADDRSTRLEN)
 +		count = INET6_ADDRSTRLEN - 1;
 +
 +	if (copy_from_user(req, buf, count))
 +		return -EFAULT;
 +
 +	if (strnchr(req, count, ':')) {
 +		kr.family = AF_INET6;
 +		if (!in6_pton(req, count, (void *)&kr.addr, '\n', NULL))
 +			return -EINVAL;
 +	} else if (strnchr(req, count, '.')) {
 +		kr.family = AF_INET;
 +		if (!in4_pton(req, count, (void *)&kr.addr, '\n', NULL))
 +			return -EINVAL;
 +	}
 +
 +	nf_ct_iterate_cleanup(net, kill_matching, &kr, 0, 0);
 +
 +	return count;
 +}
 +
 static const struct file_operations ct_file_ops = {
 	.owner   = THIS_MODULE,
 	.open    = ct_open,
 	.read    = seq_read,
 +	.write	 = ct_file_write,
 	.llseek  = seq_lseek,
 	.release = seq_release_net,
 };
@@ -373,7 +430,7 @@ static int nf_conntrack_standalone_init_
 {
 	struct proc_dir_entry *pde;
 -	pde = proc_create("nf_conntrack", 0440, net->proc_net, &ct_file_ops);
 +	pde = proc_create("nf_conntrack", 0660, net->proc_net, &ct_file_ops);
 	if (!pde)
 		goto out_nf_conntrack;
--- a/target/linux/generic/patches-3.13/610-netfilter_match_bypass_default_checks.patch
+++ b/target/linux/generic/patches-3.13/610-netfilter_match_bypass_default_checks.patch
@ -1,93 +0,0 @@
 --- a/include/uapi/linux/netfilter_ipv4/ip_tables.h
 +++ b/include/uapi/linux/netfilter_ipv4/ip_tables.h
@@ -87,6 +87,7 @@ struct ipt_ip {
 #define IPT_F_FRAG		0x01	/* Set if rule is a fragment rule */
 #define IPT_F_GOTO		0x02	/* Set if jump is a goto */
 #define IPT_F_MASK		0x03	/* All possible flag bits mask. */
 +#define IPT_F_NO_DEF_MATCH	0x80	/* Internal: no default match rules present */
 /* Values for "inv" field in struct ipt_ip. */
 #define IPT_INV_VIA_IN		0x01	/* Invert the sense of IN IFACE. */
 --- a/net/ipv4/netfilter/ip_tables.c
 +++ b/net/ipv4/netfilter/ip_tables.c
@@ -82,6 +82,9 @@ ip_packet_match(const struct iphdr *ip,
 #define FWINV(bool, invflg) ((bool) ^ !!(ipinfo->invflags & (invflg)))
 +	if (ipinfo->flags & IPT_F_NO_DEF_MATCH)
 +		return true;
 +
 	if (FWINV((ip->saddr&ipinfo->smsk.s_addr) != ipinfo->src.s_addr,
 		  IPT_INV_SRCIP) ||
 	    FWINV((ip->daddr&ipinfo->dmsk.s_addr) != ipinfo->dst.s_addr,
@@ -135,6 +138,29 @@ ip_packet_match(const struct iphdr *ip,
 	return true;
 }
 +static void
 +ip_checkdefault(struct ipt_ip *ip)
 +{
 +	static const char iface_mask[IFNAMSIZ] = {};
 +
 +	if (ip->invflags || ip->flags & IPT_F_FRAG)
 +		return;
 +
 +	if (memcmp(ip->iniface_mask, iface_mask, IFNAMSIZ) != 0)
 +		return;
 +
 +	if (memcmp(ip->outiface_mask, iface_mask, IFNAMSIZ) != 0)
 +		return;
 +
 +	if (ip->smsk.s_addr || ip->dmsk.s_addr)
 +		return;
 +
 +	if (ip->proto)
 +		return;
 +
 +	ip->flags |= IPT_F_NO_DEF_MATCH;
 +}
 +
 static bool
 ip_checkentry(const struct ipt_ip *ip)
 {
@@ -565,7 +591,7 @@ static void cleanup_match(struct xt_entr
 }
 static int
 -check_entry(const struct ipt_entry *e, const char *name)
 +check_entry(struct ipt_entry *e, const char *name)
 {
 	const struct xt_entry_target *t;
@@ -574,6 +600,8 @@ check_entry(const struct ipt_entry *e, c
 		return -EINVAL;
 	}
 +	ip_checkdefault(&e->ip);
 +
 	if (e->target_offset + sizeof(struct xt_entry_target) >
 	    e->next_offset)
 		return -EINVAL;
@@ -935,6 +963,7 @@ copy_entries_to_user(unsigned int total_
 	const struct xt_table_info *private = table->private;
 	int ret = 0;
 	const void *loc_cpu_entry;
 +	u8 flags;
 	counters = alloc_counters(table);
 	if (IS_ERR(counters))
@@ -965,6 +994,14 @@ copy_entries_to_user(unsigned int total_
 			ret = -EFAULT;
 			goto free_counters;
 		}
 +
 +		flags = e->ip.flags & IPT_F_MASK;
 +		if (copy_to_user(userptr + off
 +				 + offsetof(struct ipt_entry, ip.flags),
 +				 &flags, sizeof(flags)) != 0) {
 +			ret = -EFAULT;
 +			goto free_counters;
 +		}
 		for (i = sizeof(struct ipt_entry);
 		     i < e->target_offset;
--- a/target/linux/generic/patches-3.13/611-netfilter_match_bypass_default_table.patch
+++ b/target/linux/generic/patches-3.13/611-netfilter_match_bypass_default_table.patch
@ -1,83 +0,0 @@
 --- a/net/ipv4/netfilter/ip_tables.c
 +++ b/net/ipv4/netfilter/ip_tables.c
@@ -310,6 +310,33 @@ struct ipt_entry *ipt_next_entry(const s
 	return (void *)entry + entry->next_offset;
 }
 +static bool
 +ipt_handle_default_rule(struct ipt_entry *e, unsigned int *verdict)
 +{
 +	struct xt_entry_target *t;
 +	struct xt_standard_target *st;
 +
 +	if (e->target_offset != sizeof(struct ipt_entry))
 +		return false;
 +
 +	if (!(e->ip.flags & IPT_F_NO_DEF_MATCH))
 +		return false;
 +
 +	t = ipt_get_target(e);
 +	if (t->u.kernel.target->target)
 +		return false;
 +
 +	st = (struct xt_standard_target *) t;
 +	if (st->verdict == XT_RETURN)
 +		return false;
 +
 +	if (st->verdict >= 0)
 +		return false;
 +
 +	*verdict = (unsigned)(-st->verdict) - 1;
 +	return true;
 +}
 +
 /* Returns one of the generic firewall policies, like NF_ACCEPT. */
 unsigned int
 ipt_do_table(struct sk_buff *skb,
@@ -334,19 +361,6 @@ ipt_do_table(struct sk_buff *skb,
 	ip = ip_hdr(skb);
 	indev = in ? in->name : nulldevname;
 	outdev = out ? out->name : nulldevname;
 -	/* We handle fragments by dealing with the first fragment as
 -	 * if it was a normal packet.  All other fragments are treated
 -	 * normally, except that they will NEVER match rules that ask
 -	 * things we don't know, ie. tcp syn flag or ports).  If the
 -	 * rule is also a fragment-specific rule, non-fragments won't
 -	 * match it. */
 -	acpar.fragoff = ntohs(ip->frag_off) & IP_OFFSET;
 -	acpar.thoff   = ip_hdrlen(skb);
 -	acpar.hotdrop = false;
 -	acpar.in      = in;
 -	acpar.out     = out;
 -	acpar.family  = NFPROTO_IPV4;
 -	acpar.hooknum = hook;
 	IP_NF_ASSERT(table->valid_hooks & (1 << hook));
 	local_bh_disable();
@@ -364,6 +378,26 @@ ipt_do_table(struct sk_buff *skb,
 	origptr    = *stackptr;
 	e = get_entry(table_base, private->hook_entry[hook]);
 +	if (ipt_handle_default_rule(e, &verdict)) {
 +		ADD_COUNTER(e->counters, skb->len, 1);
 +		xt_write_recseq_end(addend);
 +		local_bh_enable();
 +		return verdict;
 +	}
 +
 +	/* We handle fragments by dealing with the first fragment as
 +	 * if it was a normal packet.  All other fragments are treated
 +	 * normally, except that they will NEVER match rules that ask
 +	 * things we don't know, ie. tcp syn flag or ports).  If the
 +	 * rule is also a fragment-specific rule, non-fragments won't
 +	 * match it. */
 +	acpar.fragoff = ntohs(ip->frag_off) & IP_OFFSET;
 +	acpar.thoff   = ip_hdrlen(skb);
 +	acpar.hotdrop = false;
 +	acpar.in      = in;
 +	acpar.out     = out;
 +	acpar.family  = NFPROTO_IPV4;
 +	acpar.hooknum = hook;
 	pr_debug("Entering %s(hook %u); sp at %u (UF %p)\n",
 		 table->name, hook, origptr,
--- a/target/linux/generic/patches-3.13/612-netfilter_match_reduce_memory_access.patch
+++ b/target/linux/generic/patches-3.13/612-netfilter_match_reduce_memory_access.patch
@ -1,16 +0,0 @@
 --- a/net/ipv4/netfilter/ip_tables.c
 +++ b/net/ipv4/netfilter/ip_tables.c
@@ -85,9 +85,11 @@ ip_packet_match(const struct iphdr *ip,
 	if (ipinfo->flags & IPT_F_NO_DEF_MATCH)
 		return true;
 -	if (FWINV((ip->saddr&ipinfo->smsk.s_addr) != ipinfo->src.s_addr,
 +	if (FWINV(ipinfo->smsk.s_addr &&
 +		  (ip->saddr&ipinfo->smsk.s_addr) != ipinfo->src.s_addr,
 		  IPT_INV_SRCIP) ||
 -	    FWINV((ip->daddr&ipinfo->dmsk.s_addr) != ipinfo->dst.s_addr,
 +	    FWINV(ipinfo->dmsk.s_addr &&
 +		  (ip->daddr&ipinfo->dmsk.s_addr) != ipinfo->dst.s_addr,
 		  IPT_INV_DSTIP)) {
 		dprintf("Source or dest mismatch.\n");
--- a/target/linux/generic/patches-3.13/613-netfilter_optional_tcp_window_check.patch
+++ b/target/linux/generic/patches-3.13/613-netfilter_optional_tcp_window_check.patch
@ -1,36 +0,0 @@
 --- a/net/netfilter/nf_conntrack_proto_tcp.c
 +++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -33,6 +33,9 @@
 #include <net/netfilter/ipv4/nf_conntrack_ipv4.h>
 #include <net/netfilter/ipv6/nf_conntrack_ipv6.h>
 +/* Do not check the TCP window for incoming packets  */
 +static int nf_ct_tcp_no_window_check __read_mostly = 1;
 +
 /* "Be conservative in what you do,
     be liberal in what you accept from others."
     If it's non-zero, we mark only out of window RST segments as INVALID. */
@@ -515,6 +518,9 @@ static bool tcp_in_window(const struct n
 	s32 receiver_offset;
 	bool res, in_recv_win;
 +	if (nf_ct_tcp_no_window_check)
 +		return true;
 +
 	/*
 	 * Get the required data from the packet.
 	 */
@@ -1452,6 +1458,13 @@ static struct ctl_table tcp_sysctl_table
 		.mode		= 0644,
 		.proc_handler	= proc_dointvec,
 	},
 +	{
 +		.procname       = "nf_conntrack_tcp_no_window_check",
 +		.data           = &nf_ct_tcp_no_window_check,
 +		.maxlen         = sizeof(unsigned int),
 +		.mode           = 0644,
 +		.proc_handler   = proc_dointvec,
 +	},
 	{ }
 };
--- a/target/linux/generic/patches-3.13/615-netfilter_add_xt_id_match.patch
+++ b/target/linux/generic/patches-3.13/615-netfilter_add_xt_id_match.patch
@ -1,95 +0,0 @@
 --- a/include/uapi/linux/netfilter/Kbuild
 +++ b/include/uapi/linux/netfilter/Kbuild
@@ -54,6 +54,7 @@ header-y += xt_ecn.h
 header-y += xt_esp.h
 header-y += xt_hashlimit.h
 header-y += xt_helper.h
 +header-y += xt_id.h
 header-y += xt_iprange.h
 header-y += xt_ipvs.h
 header-y += xt_layer7.h
 --- /dev/null
 +++ b/include/uapi/linux/netfilter/xt_id.h
@@ -0,0 +1,8 @@
 +#ifndef _XT_ID_H
 +#define _XT_ID_H
 +
 +struct xt_id_info {
 +	u32 id;
 +};
 +
 +#endif /* XT_ID_H */
 --- a/net/netfilter/Kconfig
 +++ b/net/netfilter/Kconfig
@@ -1033,6 +1033,13 @@ config NETFILTER_XT_MATCH_HL
 	in the IPv6 header, or the time-to-live field in the IPv4
 	header of the packet.
 +config NETFILTER_XT_MATCH_ID
 +	tristate '"id" match support'
 +	depends on NETFILTER_ADVANCED
 +	---help---
 +	This option adds a `id' dummy-match, which allows you to put
 +	numeric IDs into your iptables ruleset.
 +
 config NETFILTER_XT_MATCH_IPRANGE
 	tristate '"iprange" address range match support'
 	depends on NETFILTER_ADVANCED
 --- a/net/netfilter/Makefile
 +++ b/net/netfilter/Makefile
@@ -133,6 +133,7 @@ obj-$(CONFIG_NETFILTER_XT_MATCH_ESP) +=
 obj-$(CONFIG_NETFILTER_XT_MATCH_HASHLIMIT) += xt_hashlimit.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_HELPER) += xt_helper.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_HL) += xt_hl.o
 +obj-$(CONFIG_NETFILTER_XT_MATCH_ID) += xt_id.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_IPRANGE) += xt_iprange.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_IPVS) += xt_ipvs.o
 obj-$(CONFIG_NETFILTER_XT_MATCH_LENGTH) += xt_length.o
 --- /dev/null
 +++ b/net/netfilter/xt_id.c
@@ -0,0 +1,45 @@
 +/*
 + * Implements a dummy match to allow attaching IDs to rules
 + *
 + * 2014-08-01 Jo-Philipp Wich <jow@openwrt.org>
 + */
 +
 +#include <linux/module.h>
 +#include <linux/skbuff.h>
 +#include <linux/netfilter/x_tables.h>
 +#include <linux/netfilter/xt_id.h>
 +
 +MODULE_AUTHOR("Jo-Philipp Wich <jow@openwrt.org>");
 +MODULE_DESCRIPTION("Xtables: No-op match which can be tagged with a 32bit ID");
 +MODULE_LICENSE("GPL");
 +MODULE_ALIAS("ipt_id");
 +MODULE_ALIAS("ip6t_id");
 +
 +static bool
 +id_mt(const struct sk_buff *skb, struct xt_action_param *par)
 +{
 +	/* We always match */
 +	return true;
 +}
 +
 +static struct xt_match id_mt_reg __read_mostly = {
 +	.name      = "id",
 +	.revision  = 0,
 +	.family    = NFPROTO_UNSPEC,
 +	.match     = id_mt,
 +	.matchsize = sizeof(struct xt_id_info),
 +	.me        = THIS_MODULE,
 +};
 +
 +static int __init id_mt_init(void)
 +{
 +	return xt_register_match(&id_mt_reg);
 +}
 +
 +static void __exit id_mt_exit(void)
 +{
 +	xt_unregister_match(&id_mt_reg);
 +}
 +
 +module_init(id_mt_init);
 +module_exit(id_mt_exit);
--- a/target/linux/generic/patches-3.13/620-sched_esfq.patch
+++ b/target/linux/generic/patches-3.13/620-sched_esfq.patch
@ -1,791 +0,0 @@
 --- a/include/uapi/linux/pkt_sched.h
 +++ b/include/uapi/linux/pkt_sched.h
@@ -224,6 +224,33 @@ struct tc_sfq_xstats {
 	__s32		allot;
 };
 +/* ESFQ section */
 +
 +enum
 +{
 +        /* traditional */
 +	TCA_SFQ_HASH_CLASSIC,
 +	TCA_SFQ_HASH_DST,
 +	TCA_SFQ_HASH_SRC,
 +	TCA_SFQ_HASH_FWMARK,
 +	/* conntrack */
 +	TCA_SFQ_HASH_CTORIGDST,
 +	TCA_SFQ_HASH_CTORIGSRC,
 +	TCA_SFQ_HASH_CTREPLDST,
 +	TCA_SFQ_HASH_CTREPLSRC,
 +	TCA_SFQ_HASH_CTNATCHG,
 +};
 +
 +struct tc_esfq_qopt
 +{
 +	unsigned	quantum;	/* Bytes per round allocated to flow */
 +	int		perturb_period;	/* Period of hash perturbation */
 +	__u32		limit;		/* Maximal packets in queue */
 +	unsigned	divisor;	/* Hash divisor  */
 +	unsigned	flows;		/* Maximal number of flows  */
 +	unsigned	hash_kind;	/* Hash function to use for flow identification */
 +};
 +
 /* RED section */
 enum {
 --- a/net/sched/Kconfig
 +++ b/net/sched/Kconfig
@@ -148,6 +148,37 @@ config NET_SCH_SFQ
 	  To compile this code as a module, choose M here: the
 	  module will be called sch_sfq.
 +config NET_SCH_ESFQ
 +	tristate "Enhanced Stochastic Fairness Queueing (ESFQ)"
 +	---help---
 +	  Say Y here if you want to use the Enhanced Stochastic Fairness
 +	  Queueing (ESFQ) packet scheduling algorithm for some of your network
 +	  devices or as a leaf discipline for a classful qdisc such as HTB or
 +	  CBQ (see the top of <file:net/sched/sch_esfq.c> for details and
 +	  references to the SFQ algorithm).
 +
 +	  This is an enchanced SFQ version which allows you to control some
 +	  hardcoded values in the SFQ scheduler.
 +
 +	  ESFQ also adds control of the hash function used to identify packet
 +	  flows. The original SFQ discipline hashes by connection; ESFQ add
 +	  several other hashing methods, such as by src IP or by dst IP, which
 +	  can be more fair to users in some networking situations.
 +
 +	  To compile this code as a module, choose M here: the
 +	  module will be called sch_esfq.
 +
 +config NET_SCH_ESFQ_NFCT
 +	bool "Connection Tracking Hash Types"
 +	depends on NET_SCH_ESFQ && NF_CONNTRACK
 +	---help---
 +	  Say Y here to enable support for hashing based on netfilter connection
 +	  tracking information. This is useful for a router that is also using
 +	  NAT to connect privately-addressed hosts to the Internet. If you want
 +	  to provide fair distribution of upstream bandwidth, ESFQ must use
 +	  connection tracking information, since all outgoing packets will share
 +	  the same source address.
 +
 config NET_SCH_TEQL
 	tristate "True Link Equalizer (TEQL)"
 	---help---
 --- a/net/sched/Makefile
 +++ b/net/sched/Makefile
@@ -26,6 +26,7 @@ obj-$(CONFIG_NET_SCH_INGRESS)	+= sch_ing
 obj-$(CONFIG_NET_SCH_DSMARK)	+= sch_dsmark.o
 obj-$(CONFIG_NET_SCH_SFB)	+= sch_sfb.o
 obj-$(CONFIG_NET_SCH_SFQ)	+= sch_sfq.o
 +obj-$(CONFIG_NET_SCH_ESFQ)	+= sch_esfq.o
 obj-$(CONFIG_NET_SCH_TBF)	+= sch_tbf.o
 obj-$(CONFIG_NET_SCH_TEQL)	+= sch_teql.o
 obj-$(CONFIG_NET_SCH_PRIO)	+= sch_prio.o
 --- /dev/null
 +++ b/net/sched/sch_esfq.c
@@ -0,0 +1,702 @@
 +/*
 + * net/sched/sch_esfq.c	Extended Stochastic Fairness Queueing discipline.
 + *
 + *		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.
 + *
 + * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 + *
 + * Changes:	Alexander Atanasov, <alex@ssi.bg>
 + *		Added dynamic depth,limit,divisor,hash_kind options.
 + *		Added dst and src hashes.
 + *
 + * 		Alexander Clouter, <alex@digriz.org.uk>
 + *		Ported ESFQ to Linux 2.6.
 + *
 + * 		Corey Hickey, <bugfood-c@fatooh.org>
 + *		Maintenance of the Linux 2.6 port.
 + *		Added fwmark hash (thanks to Robert Kurjata).
 + *		Added usage of jhash.
 + *		Added conntrack support.
 + *		Added ctnatchg hash (thanks to Ben Pfountz).
 + */
 +
 +#include <linux/module.h>
 +#include <asm/uaccess.h>
 +#include <linux/bitops.h>
 +#include <linux/types.h>
 +#include <linux/kernel.h>
 +#include <linux/jiffies.h>
 +#include <linux/string.h>
 +#include <linux/mm.h>
 +#include <linux/socket.h>
 +#include <linux/sockios.h>
 +#include <linux/in.h>
 +#include <linux/errno.h>
 +#include <linux/interrupt.h>
 +#include <linux/if_ether.h>
 +#include <linux/inet.h>
 +#include <linux/netdevice.h>
 +#include <linux/etherdevice.h>
 +#include <linux/notifier.h>
 +#include <linux/init.h>
 +#include <net/ip.h>
 +#include <net/netlink.h>
 +#include <linux/ipv6.h>
 +#include <net/route.h>
 +#include <linux/skbuff.h>
 +#include <net/sock.h>
 +#include <net/pkt_sched.h>
 +#include <linux/jhash.h>
 +#ifdef CONFIG_NET_SCH_ESFQ_NFCT
 +#include <net/netfilter/nf_conntrack.h>
 +#endif
 +
 +/*	Stochastic Fairness Queuing algorithm.
 +	For more comments look at sch_sfq.c.
 +	The difference is that you can change limit, depth,
 +	hash table size and choose alternate hash types.
 +
 +	classic:	same as in sch_sfq.c
 +	dst:		destination IP address
 +	src:		source IP address
 +	fwmark:		netfilter mark value
 +	ctorigdst:	original destination IP address
 +	ctorigsrc:	original source IP address
 +	ctrepldst:	reply destination IP address
 +	ctreplsrc:	reply source IP
 +
 +*/
 +
 +#define ESFQ_HEAD 0
 +#define ESFQ_TAIL 1
 +
 +/* This type should contain at least SFQ_DEPTH*2 values */
 +typedef unsigned int esfq_index;
 +
 +struct esfq_head
 +{
 +	esfq_index	next;
 +	esfq_index	prev;
 +};
 +
 +struct esfq_sched_data
 +{
 +/* Parameters */
 +	int		perturb_period;
 +	unsigned	quantum;	/* Allotment per round: MUST BE >= MTU */
 +	int		limit;
 +	unsigned	depth;
 +	unsigned	hash_divisor;
 +	unsigned	hash_kind;
 +/* Variables */
 +	struct timer_list perturb_timer;
 +	int		perturbation;
 +	esfq_index	tail;		/* Index of current slot in round */
 +	esfq_index	max_depth;	/* Maximal depth */
 +
 +	esfq_index	*ht;			/* Hash table */
 +	esfq_index	*next;			/* Active slots link */
 +	short		*allot;			/* Current allotment per slot */
 +	unsigned short	*hash;			/* Hash value indexed by slots */
 +	struct sk_buff_head	*qs;		/* Slot queue */
 +	struct esfq_head	*dep;		/* Linked list of slots, indexed by depth */
 +};
 +
 +/* This contains the info we will hash. */
 +struct esfq_packet_info
 +{
 +	u32	proto;		/* protocol or port */
 +	u32	src;		/* source from packet header */
 +	u32	dst;		/* destination from packet header */
 +	u32	ctorigsrc;	/* original source from conntrack */
 +	u32	ctorigdst;	/* original destination from conntrack */
 +	u32	ctreplsrc;	/* reply source from conntrack */
 +	u32	ctrepldst;	/* reply destination from conntrack */
 +	u32	mark;		/* netfilter mark (fwmark) */
 +};
 +
 +static __inline__ unsigned esfq_jhash_1word(struct esfq_sched_data *q,u32 a)
 +{
 +	return jhash_1word(a, q->perturbation) & (q->hash_divisor-1);
 +}
 +
 +static __inline__ unsigned esfq_jhash_2words(struct esfq_sched_data *q, u32 a, u32 b)
 +{
 +	return jhash_2words(a, b, q->perturbation) & (q->hash_divisor-1);
 +}
 +
 +static __inline__ unsigned esfq_jhash_3words(struct esfq_sched_data *q, u32 a, u32 b, u32 c)
 +{
 +	return jhash_3words(a, b, c, q->perturbation) & (q->hash_divisor-1);
 +}
 +
 +static unsigned esfq_hash(struct esfq_sched_data *q, struct sk_buff *skb)
 +{
 +	struct esfq_packet_info info;
 +#ifdef CONFIG_NET_SCH_ESFQ_NFCT
 +	enum ip_conntrack_info ctinfo;
 +	struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
 +#endif
 +
 +	switch (skb->protocol) {
 +	case __constant_htons(ETH_P_IP):
 +	{
 +		struct iphdr *iph = ip_hdr(skb);
 +		info.dst = iph->daddr;
 +		info.src = iph->saddr;
 +		if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
 +		    (iph->protocol == IPPROTO_TCP ||
 +		     iph->protocol == IPPROTO_UDP ||
 +		     iph->protocol == IPPROTO_SCTP ||
 +		     iph->protocol == IPPROTO_DCCP ||
 +		     iph->protocol == IPPROTO_ESP))
 +			info.proto = *(((u32*)iph) + iph->ihl);
 +		else
 +			info.proto = iph->protocol;
 +		break;
 +	}
 +	case __constant_htons(ETH_P_IPV6):
 +	{
 +		struct ipv6hdr *iph = ipv6_hdr(skb);
 +		/* Hash ipv6 addresses into a u32. This isn't ideal,
 +		 * but the code is simple. */
 +		info.dst = jhash2(iph->daddr.s6_addr32, 4, q->perturbation);
 +		info.src = jhash2(iph->saddr.s6_addr32, 4, q->perturbation);
 +		if (iph->nexthdr == IPPROTO_TCP ||
 +		    iph->nexthdr == IPPROTO_UDP ||
 +		    iph->nexthdr == IPPROTO_SCTP ||
 +		    iph->nexthdr == IPPROTO_DCCP ||
 +		    iph->nexthdr == IPPROTO_ESP)
 +			info.proto = *(u32*)&iph[1];
 +		else
 +			info.proto = iph->nexthdr;
 +		break;
 +	}
 +	default:
 +		info.dst   = (u32)(unsigned long)skb_dst(skb);
 +		info.src   = (u32)(unsigned long)skb->sk;
 +		info.proto = skb->protocol;
 +	}
 +
 +	info.mark = skb->mark;
 +
 +#ifdef CONFIG_NET_SCH_ESFQ_NFCT
 +	/* defaults if there is no conntrack info */
 +	info.ctorigsrc = info.src;
 +	info.ctorigdst = info.dst;
 +	info.ctreplsrc = info.dst;
 +	info.ctrepldst = info.src;
 +	/* collect conntrack info */
 +	if (ct && ct != &nf_conntrack_untracked) {
 +		if (skb->protocol == __constant_htons(ETH_P_IP)) {
 +			info.ctorigsrc = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip;
 +			info.ctorigdst = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.ip;
 +			info.ctreplsrc = ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip;
 +			info.ctrepldst = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip;
 +		}
 +		else if (skb->protocol == __constant_htons(ETH_P_IPV6)) {
 +			/* Again, hash ipv6 addresses into a single u32. */
 +			info.ctorigsrc = jhash2(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip6, 4, q->perturbation);
 +			info.ctorigdst = jhash2(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.ip6, 4, q->perturbation);
 +			info.ctreplsrc = jhash2(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip6, 4, q->perturbation);
 +			info.ctrepldst = jhash2(ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip6, 4, q->perturbation);
 +		}
 +
 +	}
 +#endif
 +
 +	switch(q->hash_kind) {
 +	case TCA_SFQ_HASH_CLASSIC:
 +		return esfq_jhash_3words(q, info.dst, info.src, info.proto);
 +	case TCA_SFQ_HASH_DST:
 +		return esfq_jhash_1word(q, info.dst);
 +	case TCA_SFQ_HASH_SRC:
 +		return esfq_jhash_1word(q, info.src);
 +	case TCA_SFQ_HASH_FWMARK:
 +		return esfq_jhash_1word(q, info.mark);
 +#ifdef CONFIG_NET_SCH_ESFQ_NFCT
 +	case TCA_SFQ_HASH_CTORIGDST:
 +		return esfq_jhash_1word(q, info.ctorigdst);
 +	case TCA_SFQ_HASH_CTORIGSRC:
 +		return esfq_jhash_1word(q, info.ctorigsrc);
 +	case TCA_SFQ_HASH_CTREPLDST:
 +		return esfq_jhash_1word(q, info.ctrepldst);
 +	case TCA_SFQ_HASH_CTREPLSRC:
 +		return esfq_jhash_1word(q, info.ctreplsrc);
 +	case TCA_SFQ_HASH_CTNATCHG:
 +	{
 +		if (info.ctorigdst == info.ctreplsrc)
 +			return esfq_jhash_1word(q, info.ctorigsrc);
 +		return esfq_jhash_1word(q, info.ctreplsrc);
 +	}
 +#endif
 +	default:
 +		if (net_ratelimit())
 +			printk(KERN_WARNING "ESFQ: Unknown hash method. Falling back to classic.\n");
 +	}
 +	return esfq_jhash_3words(q, info.dst, info.src, info.proto);
 +}
 +
 +static inline void esfq_link(struct esfq_sched_data *q, esfq_index x)
 +{
 +	esfq_index p, n;
 +	int d = q->qs[x].qlen + q->depth;
 +
 +	p = d;
 +	n = q->dep[d].next;
 +	q->dep[x].next = n;
 +	q->dep[x].prev = p;
 +	q->dep[p].next = q->dep[n].prev = x;
 +}
 +
 +static inline void esfq_dec(struct esfq_sched_data *q, esfq_index x)
 +{
 +	esfq_index p, n;
 +
 +	n = q->dep[x].next;
 +	p = q->dep[x].prev;
 +	q->dep[p].next = n;
 +	q->dep[n].prev = p;
 +
 +	if (n == p && q->max_depth == q->qs[x].qlen + 1)
 +		q->max_depth--;
 +
 +	esfq_link(q, x);
 +}
 +
 +static inline void esfq_inc(struct esfq_sched_data *q, esfq_index x)
 +{
 +	esfq_index p, n;
 +	int d;
 +
 +	n = q->dep[x].next;
 +	p = q->dep[x].prev;
 +	q->dep[p].next = n;
 +	q->dep[n].prev = p;
 +	d = q->qs[x].qlen;
 +	if (q->max_depth < d)
 +		q->max_depth = d;
 +
 +	esfq_link(q, x);
 +}
 +
 +static unsigned int esfq_drop(struct Qdisc *sch)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	esfq_index d = q->max_depth;
 +	struct sk_buff *skb;
 +	unsigned int len;
 +
 +	/* Queue is full! Find the longest slot and
 +	   drop a packet from it */
 +
 +	if (d > 1) {
 +		esfq_index x = q->dep[d+q->depth].next;
 +		skb = q->qs[x].prev;
 +		len = skb->len;
 +		__skb_unlink(skb, &q->qs[x]);
 +		kfree_skb(skb);
 +		esfq_dec(q, x);
 +		sch->q.qlen--;
 +		sch->qstats.drops++;
 +		sch->qstats.backlog -= len;
 +		return len;
 +	}
 +
 +	if (d == 1) {
 +		/* It is difficult to believe, but ALL THE SLOTS HAVE LENGTH 1. */
 +		d = q->next[q->tail];
 +		q->next[q->tail] = q->next[d];
 +		q->allot[q->next[d]] += q->quantum;
 +		skb = q->qs[d].prev;
 +		len = skb->len;
 +		__skb_unlink(skb, &q->qs[d]);
 +		kfree_skb(skb);
 +		esfq_dec(q, d);
 +		sch->q.qlen--;
 +		q->ht[q->hash[d]] = q->depth;
 +		sch->qstats.drops++;
 +		sch->qstats.backlog -= len;
 +		return len;
 +	}
 +
 +	return 0;
 +}
 +
 +static void esfq_q_enqueue(struct sk_buff *skb, struct esfq_sched_data *q, unsigned int end)
 +{
 +	unsigned hash = esfq_hash(q, skb);
 +	unsigned depth = q->depth;
 +	esfq_index x;
 +
 +	x = q->ht[hash];
 +	if (x == depth) {
 +		q->ht[hash] = x = q->dep[depth].next;
 +		q->hash[x] = hash;
 +	}
 +
 +	if (end == ESFQ_TAIL)
 +		__skb_queue_tail(&q->qs[x], skb);
 +	else
 +		__skb_queue_head(&q->qs[x], skb);
 +
 +	esfq_inc(q, x);
 +	if (q->qs[x].qlen == 1) {		/* The flow is new */
 +		if (q->tail == depth) {	/* It is the first flow */
 +			q->tail = x;
 +			q->next[x] = x;
 +			q->allot[x] = q->quantum;
 +		} else {
 +			q->next[x] = q->next[q->tail];
 +			q->next[q->tail] = x;
 +			q->tail = x;
 +		}
 +	}
 +}
 +
 +static int esfq_enqueue(struct sk_buff *skb, struct Qdisc* sch)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	esfq_q_enqueue(skb, q, ESFQ_TAIL);
 +	sch->qstats.backlog += skb->len;
 +	if (++sch->q.qlen < q->limit-1) {
 +		sch->bstats.bytes += skb->len;
 +		sch->bstats.packets++;
 +		return 0;
 +	}
 +
 +	sch->qstats.drops++;
 +	esfq_drop(sch);
 +	return NET_XMIT_CN;
 +}
 +
 +static struct sk_buff *esfq_peek(struct Qdisc* sch)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	esfq_index a;
 +
 +	/* No active slots */
 +	if (q->tail == q->depth)
 +		return NULL;
 +
 +	a = q->next[q->tail];
 +	return skb_peek(&q->qs[a]);
 +}
 +
 +static struct sk_buff *esfq_q_dequeue(struct esfq_sched_data *q)
 +{
 +	struct sk_buff *skb;
 +	unsigned depth = q->depth;
 +	esfq_index a, old_a;
 +
 +	/* No active slots */
 +	if (q->tail == depth)
 +		return NULL;
 +
 +	a = old_a = q->next[q->tail];
 +
 +	/* Grab packet */
 +	skb = __skb_dequeue(&q->qs[a]);
 +	esfq_dec(q, a);
 +
 +	/* Is the slot empty? */
 +	if (q->qs[a].qlen == 0) {
 +		q->ht[q->hash[a]] = depth;
 +		a = q->next[a];
 +		if (a == old_a) {
 +			q->tail = depth;
 +			return skb;
 +		}
 +		q->next[q->tail] = a;
 +		q->allot[a] += q->quantum;
 +	} else if ((q->allot[a] -= skb->len) <= 0) {
 +		q->tail = a;
 +		a = q->next[a];
 +		q->allot[a] += q->quantum;
 +	}
 +
 +	return skb;
 +}
 +
 +static struct sk_buff *esfq_dequeue(struct Qdisc* sch)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	struct sk_buff *skb;
 +
 +	skb = esfq_q_dequeue(q);
 +	if (skb == NULL)
 +		return NULL;
 +	sch->q.qlen--;
 +	sch->qstats.backlog -= skb->len;
 +	return skb;
 +}
 +
 +static void esfq_q_destroy(struct esfq_sched_data *q)
 +{
 +	del_timer(&q->perturb_timer);
 +	if(q->ht)
 +		kfree(q->ht);
 +	if(q->dep)
 +		kfree(q->dep);
 +	if(q->next)
 +		kfree(q->next);
 +	if(q->allot)
 +		kfree(q->allot);
 +	if(q->hash)
 +		kfree(q->hash);
 +	if(q->qs)
 +		kfree(q->qs);
 +}
 +
 +static void esfq_destroy(struct Qdisc *sch)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	esfq_q_destroy(q);
 +}
 +
 +
 +static void esfq_reset(struct Qdisc* sch)
 +{
 +	struct sk_buff *skb;
 +
 +	while ((skb = esfq_dequeue(sch)) != NULL)
 +		kfree_skb(skb);
 +}
 +
 +static void esfq_perturbation(unsigned long arg)
 +{
 +	struct Qdisc *sch = (struct Qdisc*)arg;
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +
 +	q->perturbation = net_random()&0x1F;
 +
 +	if (q->perturb_period) {
 +		q->perturb_timer.expires = jiffies + q->perturb_period;
 +		add_timer(&q->perturb_timer);
 +	}
 +}
 +
 +static unsigned int esfq_check_hash(unsigned int kind)
 +{
 +	switch (kind) {
 +	case TCA_SFQ_HASH_CTORIGDST:
 +	case TCA_SFQ_HASH_CTORIGSRC:
 +	case TCA_SFQ_HASH_CTREPLDST:
 +	case TCA_SFQ_HASH_CTREPLSRC:
 +	case TCA_SFQ_HASH_CTNATCHG:
 +#ifndef CONFIG_NET_SCH_ESFQ_NFCT
 +	{
 +		if (net_ratelimit())
 +			printk(KERN_WARNING "ESFQ: Conntrack hash types disabled in kernel config. Falling back to classic.\n");
 +		return TCA_SFQ_HASH_CLASSIC;
 +	}
 +#endif
 +	case TCA_SFQ_HASH_CLASSIC:
 +	case TCA_SFQ_HASH_DST:
 +	case TCA_SFQ_HASH_SRC:
 +	case TCA_SFQ_HASH_FWMARK:
 +		return kind;
 +	default:
 +	{
 +		if (net_ratelimit())
 +			printk(KERN_WARNING "ESFQ: Unknown hash type. Falling back to classic.\n");
 +		return TCA_SFQ_HASH_CLASSIC;
 +	}
 +	}
 +}
 +
 +static int esfq_q_init(struct esfq_sched_data *q, struct nlattr *opt)
 +{
 +	struct tc_esfq_qopt *ctl = nla_data(opt);
 +	esfq_index p = ~0U/2;
 +	int i;
 +
 +	if (opt && opt->nla_len < nla_attr_size(sizeof(*ctl)))
 +		return -EINVAL;
 +
 +	q->perturbation = 0;
 +	q->hash_kind = TCA_SFQ_HASH_CLASSIC;
 +	q->max_depth = 0;
 +	if (opt == NULL) {
 +		q->perturb_period = 0;
 +		q->hash_divisor = 1024;
 +		q->tail = q->limit = q->depth = 128;
 +
 +	} else {
 +		struct tc_esfq_qopt *ctl = nla_data(opt);
 +		if (ctl->quantum)
 +			q->quantum = ctl->quantum;
 +		q->perturb_period = ctl->perturb_period*HZ;
 +		q->hash_divisor = ctl->divisor ? : 1024;
 +		q->tail = q->limit = q->depth = ctl->flows ? : 128;
 +
 +		if ( q->depth > p - 1 )
 +			return -EINVAL;
 +
 +		if (ctl->limit)
 +			q->limit = min_t(u32, ctl->limit, q->depth);
 +
 +		if (ctl->hash_kind) {
 +			q->hash_kind = esfq_check_hash(ctl->hash_kind);
 +		}
 +	}
 +
 +	q->ht = kmalloc(q->hash_divisor*sizeof(esfq_index), GFP_KERNEL);
 +	if (!q->ht)
 +		goto err_case;
 +	q->dep = kmalloc((1+q->depth*2)*sizeof(struct esfq_head), GFP_KERNEL);
 +	if (!q->dep)
 +		goto err_case;
 +	q->next = kmalloc(q->depth*sizeof(esfq_index), GFP_KERNEL);
 +	if (!q->next)
 +		goto err_case;
 +	q->allot = kmalloc(q->depth*sizeof(short), GFP_KERNEL);
 +	if (!q->allot)
 +		goto err_case;
 +	q->hash = kmalloc(q->depth*sizeof(unsigned short), GFP_KERNEL);
 +	if (!q->hash)
 +		goto err_case;
 +	q->qs = kmalloc(q->depth*sizeof(struct sk_buff_head), GFP_KERNEL);
 +	if (!q->qs)
 +		goto err_case;
 +
 +	for (i=0; i< q->hash_divisor; i++)
 +		q->ht[i] = q->depth;
 +	for (i=0; i<q->depth; i++) {
 +		skb_queue_head_init(&q->qs[i]);
 +		q->dep[i+q->depth].next = i+q->depth;
 +		q->dep[i+q->depth].prev = i+q->depth;
 +	}
 +
 +	for (i=0; i<q->depth; i++)
 +		esfq_link(q, i);
 +	return 0;
 +err_case:
 +	esfq_q_destroy(q);
 +	return -ENOBUFS;
 +}
 +
 +static int esfq_init(struct Qdisc *sch, struct nlattr *opt)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	int err;
 +
 +	q->quantum = psched_mtu(qdisc_dev(sch)); /* default */
 +	if ((err = esfq_q_init(q, opt)))
 +		return err;
 +
 +	init_timer(&q->perturb_timer);
 +	q->perturb_timer.data = (unsigned long)sch;
 +	q->perturb_timer.function = esfq_perturbation;
 +	if (q->perturb_period) {
 +		q->perturb_timer.expires = jiffies + q->perturb_period;
 +		add_timer(&q->perturb_timer);
 +	}
 +
 +	return 0;
 +}
 +
 +static int esfq_change(struct Qdisc *sch, struct nlattr *opt)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	struct esfq_sched_data new;
 +	struct sk_buff *skb;
 +	int err;
 +
 +	/* set up new queue */
 +	memset(&new, 0, sizeof(struct esfq_sched_data));
 +	new.quantum = psched_mtu(qdisc_dev(sch)); /* default */
 +	if ((err = esfq_q_init(&new, opt)))
 +		return err;
 +
 +	/* copy all packets from the old queue to the new queue */
 +	sch_tree_lock(sch);
 +	while ((skb = esfq_q_dequeue(q)) != NULL)
 +		esfq_q_enqueue(skb, &new, ESFQ_TAIL);
 +
 +	/* clean up the old queue */
 +	esfq_q_destroy(q);
 +
 +	/* copy elements of the new queue into the old queue */
 +	q->perturb_period = new.perturb_period;
 +	q->quantum        = new.quantum;
 +	q->limit          = new.limit;
 +	q->depth          = new.depth;
 +	q->hash_divisor   = new.hash_divisor;
 +	q->hash_kind      = new.hash_kind;
 +	q->tail           = new.tail;
 +	q->max_depth      = new.max_depth;
 +	q->ht    = new.ht;
 +	q->dep   = new.dep;
 +	q->next  = new.next;
 +	q->allot = new.allot;
 +	q->hash  = new.hash;
 +	q->qs    = new.qs;
 +
 +	/* finish up */
 +	if (q->perturb_period) {
 +		q->perturb_timer.expires = jiffies + q->perturb_period;
 +		add_timer(&q->perturb_timer);
 +	} else {
 +		q->perturbation = 0;
 +	}
 +	sch_tree_unlock(sch);
 +	return 0;
 +}
 +
 +static int esfq_dump(struct Qdisc *sch, struct sk_buff *skb)
 +{
 +	struct esfq_sched_data *q = qdisc_priv(sch);
 +	unsigned char *b = skb_tail_pointer(skb);
 +	struct tc_esfq_qopt opt;
 +
 +	opt.quantum = q->quantum;
 +	opt.perturb_period = q->perturb_period/HZ;
 +
 +	opt.limit = q->limit;
 +	opt.divisor = q->hash_divisor;
 +	opt.flows = q->depth;
 +	opt.hash_kind = q->hash_kind;
 +
 +	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
 +		goto nla_put_failure;
 +
 +	return skb->len;
 +
 +nla_put_failure:
 +	nlmsg_trim(skb, b);
 +	return -1;
 +}
 +
 +static struct Qdisc_ops esfq_qdisc_ops =
 +{
 +	.next		=	NULL,
 +	.cl_ops		=	NULL,
 +	.id		=	"esfq",
 +	.priv_size	=	sizeof(struct esfq_sched_data),
 +	.enqueue	=	esfq_enqueue,
 +	.dequeue	=	esfq_dequeue,
 +	.peek		=	esfq_peek,
 +	.drop		=	esfq_drop,
 +	.init		=	esfq_init,
 +	.reset		=	esfq_reset,
 +	.destroy	=	esfq_destroy,
 +	.change		=	esfq_change,
 +	.dump		=	esfq_dump,
 +	.owner		=	THIS_MODULE,
 +};
 +
 +static int __init esfq_module_init(void)
 +{
 +	return register_qdisc(&esfq_qdisc_ops);
 +}
 +static void __exit esfq_module_exit(void)
 +{
 +	unregister_qdisc(&esfq_qdisc_ops);
 +}
 +module_init(esfq_module_init)
 +module_exit(esfq_module_exit)
 +MODULE_LICENSE("GPL");
--- a/target/linux/generic/patches-3.13/621-sched_act_connmark.patch
+++ b/target/linux/generic/patches-3.13/621-sched_act_connmark.patch
@ -1,183 +0,0 @@
 --- /dev/null
 +++ b/net/sched/act_connmark.c
@@ -0,0 +1,148 @@
 +/*
 + * Copyright (c) 2011 Felix Fietkau <nbd@openwrt.org>
 + *
 + * This program is free software; you can redistribute it and/or modify it
 + * under the terms and conditions of the GNU General Public License,
 + * version 2, as published by the Free Software Foundation.
 + *
 + * This program is distributed in the hope 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/module.h>
 +#include <linux/init.h>
 +#include <linux/kernel.h>
 +#include <linux/skbuff.h>
 +#include <linux/rtnetlink.h>
 +#include <linux/pkt_cls.h>
 +#include <linux/ip.h>
 +#include <linux/ipv6.h>
 +#include <net/netlink.h>
 +#include <net/pkt_sched.h>
 +#include <net/act_api.h>
 +
 +#include <net/netfilter/nf_conntrack.h>
 +#include <net/netfilter/nf_conntrack_core.h>
 +
 +#define TCA_ACT_CONNMARK	20
 +
 +#define CONNMARK_TAB_MASK     3
 +static struct tcf_common *tcf_connmark_ht[CONNMARK_TAB_MASK + 1];
 +static u32 connmark_idx_gen;
 +static DEFINE_RWLOCK(connmark_lock);
 +
 +static struct tcf_hashinfo connmark_hash_info = {
 +	.htab	=	tcf_connmark_ht,
 +	.hmask	=	CONNMARK_TAB_MASK,
 +	.lock	=	&connmark_lock,
 +};
 +
 +static int tcf_connmark(struct sk_buff *skb, const struct tc_action *a,
 +		       struct tcf_result *res)
 +{
 +	struct nf_conn *c;
 +	enum ip_conntrack_info ctinfo;
 +	int proto;
 +	int r;
 +
 +	if (skb->protocol == htons(ETH_P_IP)) {
 +		if (skb->len < sizeof(struct iphdr))
 +			goto out;
 +		proto = PF_INET;
 +	} else if (skb->protocol == htons(ETH_P_IPV6)) {
 +		if (skb->len < sizeof(struct ipv6hdr))
 +			goto out;
 +		proto = PF_INET6;
 +	} else
 +		goto out;
 +
 +	r = nf_conntrack_in(dev_net(skb->dev), proto, NF_INET_PRE_ROUTING, skb);
 +	if (r != NF_ACCEPT)
 +		goto out;
 +
 +	c = nf_ct_get(skb, &ctinfo);
 +	if (!c)
 +		goto out;
 +
 +	skb->mark = c->mark;
 +	nf_conntrack_put(skb->nfct);
 +	skb->nfct = NULL;
 +
 +out:
 +	return TC_ACT_PIPE;
 +}
 +
 +static int tcf_connmark_init(struct net *net, struct nlattr *nla,
 +			     struct nlattr *est, struct tc_action *a,
 +			     int ovr, int bind)
 +{
 +	struct tcf_common *pc;
 +	int ret = 0;
 +
 +	pc = tcf_hash_check(0, a, bind, &connmark_hash_info);
 +	if (!pc) {
 +		pc = tcf_hash_create(0, est, a, sizeof(*pc), bind,
 +				     &connmark_idx_gen, &connmark_hash_info);
 +		if (IS_ERR(pc))
 +		    return PTR_ERR(pc);
 +
 +		tcf_hash_insert(pc, &connmark_hash_info);
 +		ret = ACT_P_CREATED;
 +	} else {
 +		if (!ovr) {
 +			tcf_hash_release(pc, bind, &connmark_hash_info);
 +			return -EEXIST;
 +		}
 +	}
 +
 +	return ret;
 +}
 +
 +static inline int tcf_connmark_cleanup(struct tc_action *a, int bind)
 +{
 +	if (a->priv)
 +		return tcf_hash_release(a->priv, bind, &connmark_hash_info);
 +	return 0;
 +}
 +
 +static inline int tcf_connmark_dump(struct sk_buff *skb, struct tc_action *a,
 +				int bind, int ref)
 +{
 +	return skb->len;
 +}
 +
 +static struct tc_action_ops act_connmark_ops = {
 +	.kind		=	"connmark",
 +	.hinfo		=	&connmark_hash_info,
 +	.type		=	TCA_ACT_CONNMARK,
 +	.capab		=	TCA_CAP_NONE,
 +	.owner		=	THIS_MODULE,
 +	.act		=	tcf_connmark,
 +	.dump		=	tcf_connmark_dump,
 +	.cleanup	=	tcf_connmark_cleanup,
 +	.init		=	tcf_connmark_init,
 +	.walk		=	tcf_generic_walker,
 +};
 +
 +MODULE_AUTHOR("Felix Fietkau <nbd@openwrt.org>");
 +MODULE_DESCRIPTION("Connection tracking mark restoring");
 +MODULE_LICENSE("GPL");
 +
 +static int __init connmark_init_module(void)
 +{
 +	return tcf_register_action(&act_connmark_ops);
 +}
 +
 +static void __exit connmark_cleanup_module(void)
 +{
 +	tcf_unregister_action(&act_connmark_ops);
 +}
 +
 +module_init(connmark_init_module);
 +module_exit(connmark_cleanup_module);
 --- a/net/sched/Kconfig
 +++ b/net/sched/Kconfig
@@ -694,6 +694,19 @@ config NET_ACT_CSUM
 	  To compile this code as a module, choose M here: the
 	  module will be called act_csum.
 +config NET_ACT_CONNMARK
 +        tristate "Connection Tracking Marking"
 +        depends on NET_CLS_ACT
 +        depends on NF_CONNTRACK
 +	 depends on NF_CONNTRACK_MARK
 +        ---help---
 +	  Say Y here to restore the connmark from a scheduler action
 +
 +	  If unsure, say N.
 +
 +	  To compile this code as a module, choose M here: the
 +	  module will be called act_connmark.
 +
 config NET_CLS_IND
 	bool "Incoming device classification"
 	depends on NET_CLS_U32 || NET_CLS_FW
 --- a/net/sched/Makefile
 +++ b/net/sched/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_NET_ACT_PEDIT)	+= act_pedit
 obj-$(CONFIG_NET_ACT_SIMP)	+= act_simple.o
 obj-$(CONFIG_NET_ACT_SKBEDIT)	+= act_skbedit.o
 obj-$(CONFIG_NET_ACT_CSUM)	+= act_csum.o
 +obj-$(CONFIG_NET_ACT_CONNMARK)	+= act_connmark.o
 obj-$(CONFIG_NET_SCH_FIFO)	+= sch_fifo.o
 obj-$(CONFIG_NET_SCH_CBQ)	+= sch_cbq.o
 obj-$(CONFIG_NET_SCH_HTB)	+= sch_htb.o
--- a/target/linux/generic/patches-3.13/630-packet_socket_type.patch
+++ b/target/linux/generic/patches-3.13/630-packet_socket_type.patch
@ -1,134 +0,0 @@
 This patch allows the user to specify desired packet types (outgoing,
 broadcast, unicast, etc.) on packet sockets via setsockopt.
 This can reduce the load in situations where only a limited number
 of packet types are necessary
 Signed-off-by: Felix Fietkau <nbd@openwrt.org>
 --- a/include/uapi/linux/if_packet.h
 +++ b/include/uapi/linux/if_packet.h
@@ -29,6 +29,8 @@ struct sockaddr_ll {
 /* These ones are invisible by user level */
 #define PACKET_LOOPBACK		5		/* MC/BRD frame looped back */
 #define PACKET_FASTROUTE	6		/* Fastrouted frame	*/
 +#define PACKET_MASK_ANY		0xffffffff	/* mask for packet type bits */
 +
 /* Packet socket options */
@@ -51,6 +53,7 @@ struct sockaddr_ll {
 #define PACKET_TIMESTAMP		17
 #define PACKET_FANOUT			18
 #define PACKET_TX_HAS_OFF		19
 +#define PACKET_RECV_TYPE		20
 #define PACKET_FANOUT_HASH		0
 #define PACKET_FANOUT_LB		1
 --- a/net/packet/af_packet.c
 +++ b/net/packet/af_packet.c
@@ -1414,6 +1414,7 @@ static int packet_rcv_spkt(struct sk_buf
 {
 	struct sock *sk;
 	struct sockaddr_pkt *spkt;
 +	struct packet_sock *po;
 	/*
 	 *	When we registered the protocol we saved the socket in the data
@@ -1421,6 +1422,7 @@ static int packet_rcv_spkt(struct sk_buf
 	 */
 	sk = pt->af_packet_priv;
 +	po = pkt_sk(sk);
 	/*
 	 *	Yank back the headers [hope the device set this
@@ -1433,7 +1435,7 @@ static int packet_rcv_spkt(struct sk_buf
 	 *	so that this procedure is noop.
 	 */
 -	if (skb->pkt_type == PACKET_LOOPBACK)
 +	if (!(po->pkt_type & (1 << skb->pkt_type)))
 		goto out;
 	if (!net_eq(dev_net(dev), sock_net(sk)))
@@ -1640,12 +1642,12 @@ static int packet_rcv(struct sk_buff *sk
 	int skb_len = skb->len;
 	unsigned int snaplen, res;
 -	if (skb->pkt_type == PACKET_LOOPBACK)
 -		goto drop;
 -
 	sk = pt->af_packet_priv;
 	po = pkt_sk(sk);
 +	if (!(po->pkt_type & (1 << skb->pkt_type)))
 +		goto drop;
 +
 	if (!net_eq(dev_net(dev), sock_net(sk)))
 		goto drop;
@@ -1758,12 +1760,12 @@ static int tpacket_rcv(struct sk_buff *s
 	struct timespec ts;
 	__u32 ts_status;
 -	if (skb->pkt_type == PACKET_LOOPBACK)
 -		goto drop;
 -
 	sk = pt->af_packet_priv;
 	po = pkt_sk(sk);
 +	if (!(po->pkt_type & (1 << skb->pkt_type)))
 +		goto drop;
 +
 	if (!net_eq(dev_net(dev), sock_net(sk)))
 		goto drop;
@@ -2652,6 +2654,7 @@ static int packet_create(struct net *net
 	spin_lock_init(&po->bind_lock);
 	mutex_init(&po->pg_vec_lock);
 	po->prot_hook.func = packet_rcv;
 +	po->pkt_type = PACKET_MASK_ANY & ~(1 << PACKET_LOOPBACK);
 	if (sock->type == SOCK_PACKET)
 		po->prot_hook.func = packet_rcv_spkt;
@@ -3218,6 +3221,16 @@ packet_setsockopt(struct socket *sock, i
 		po->tp_tx_has_off = !!val;
 		return 0;
 	}
 +        case PACKET_RECV_TYPE:
 +        {
 +                unsigned int val;
 +                if (optlen != sizeof(val))
 +                        return -EINVAL;
 +                if (copy_from_user(&val, optval, sizeof(val)))
 +                        return -EFAULT;
 +                po->pkt_type = val & ~BIT(PACKET_LOOPBACK);
 +                return 0;
 +        }
 	default:
 		return -ENOPROTOOPT;
 	}
@@ -3269,6 +3282,13 @@ static int packet_getsockopt(struct sock
 	case PACKET_VNET_HDR:
 		val = po->has_vnet_hdr;
 		break;
 +	case PACKET_RECV_TYPE:
 +		if (len > sizeof(unsigned int))
 +			len = sizeof(unsigned int);
 +		val = po->pkt_type;
 +
 +		data = &val;
 +		break;
 	case PACKET_VERSION:
 		val = po->tp_version;
 		break;
 --- a/net/packet/internal.h
 +++ b/net/packet/internal.h
@@ -115,6 +115,7 @@ struct packet_sock {
 	unsigned int		tp_tstamp;
 	struct net_device __rcu	*cached_dev;
 	struct packet_type	prot_hook ____cacheline_aligned_in_smp;
 +	unsigned int		pkt_type;
 };
 static struct packet_sock *pkt_sk(struct sock *sk)
--- a/target/linux/generic/patches-3.13/640-bridge_no_eap_forward.patch
+++ b/target/linux/generic/patches-3.13/640-bridge_no_eap_forward.patch
@ -1,15 +0,0 @@
 --- a/net/bridge/br_input.c
 +++ b/net/bridge/br_input.c
@@ -96,7 +96,11 @@ int br_handle_frame_finish(struct sk_buf
 	dst = NULL;
 -	if (is_broadcast_ether_addr(dest)) {
 +	if (skb->protocol == htons(ETH_P_PAE)) {
 +		skb2 = skb;
 +		/* Do not forward 802.1x/EAP frames */
 +
 +	} else if (is_broadcast_ether_addr(dest)) {
 		skb2 = skb;
 		unicast = false;
 	} else if (is_multicast_ether_addr(dest)) {
--- a/target/linux/generic/patches-3.13/641-bridge_always_accept_eap.patch
+++ b/target/linux/generic/patches-3.13/641-bridge_always_accept_eap.patch
@ -1,11 +0,0 @@
 --- a/net/bridge/br_input.c
 +++ b/net/bridge/br_input.c
@@ -83,7 +83,7 @@ int br_handle_frame_finish(struct sk_buf
 	    br_multicast_rcv(br, p, skb, vid))
 		goto drop;
 -	if (p->state == BR_STATE_LEARNING)
 +	if ((p->state == BR_STATE_LEARNING) && skb->protocol != htons(ETH_P_PAE))
 		goto drop;
 	BR_INPUT_SKB_CB(skb)->brdev = br->dev;
--- a/target/linux/generic/patches-3.13/642-bridge_port_isolate.patch
+++ b/target/linux/generic/patches-3.13/642-bridge_port_isolate.patch
@ -1,102 +0,0 @@
 --- a/net/bridge/br_private.h
 +++ b/net/bridge/br_private.h
@@ -173,6 +173,7 @@ struct net_bridge_port
 #define BR_ADMIN_COST		0x00000010
 #define BR_LEARNING		0x00000020
 #define BR_FLOOD		0x00000040
 +#define BR_ISOLATE_MODE	0x00000080
 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 	struct bridge_mcast_query	ip4_query;
 --- a/net/bridge/br_sysfs_if.c
 +++ b/net/bridge/br_sysfs_if.c
@@ -161,6 +161,22 @@ BRPORT_ATTR_FLAG(root_block, BR_ROOT_BLO
 BRPORT_ATTR_FLAG(learning, BR_LEARNING);
 BRPORT_ATTR_FLAG(unicast_flood, BR_FLOOD);
 +static ssize_t show_isolate_mode(struct net_bridge_port *p, char *buf)
 +{
 +	int isolate_mode = (p->flags & BR_ISOLATE_MODE) ? 1 : 0;
 +	return sprintf(buf, "%d\n", isolate_mode);
 +}
 +static ssize_t store_isolate_mode(struct net_bridge_port *p, unsigned long v)
 +{
 +	if (v)
 +		p->flags |= BR_ISOLATE_MODE;
 +	else
 +		p->flags &= ~BR_ISOLATE_MODE;
 +	return 0;
 +}
 +static BRPORT_ATTR(isolate_mode, S_IRUGO | S_IWUSR,
 +		   show_isolate_mode, store_isolate_mode);
 +
 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 static ssize_t show_multicast_router(struct net_bridge_port *p, char *buf)
 {
@@ -203,6 +219,7 @@ static const struct brport_attribute *br
 	&brport_attr_multicast_router,
 	&brport_attr_multicast_fast_leave,
 #endif
 +	&brport_attr_isolate_mode,
 	NULL
 };
 --- a/net/bridge/br_input.c
 +++ b/net/bridge/br_input.c
@@ -119,8 +119,8 @@ int br_handle_frame_finish(struct sk_buf
 		unicast = false;
 		br->dev->stats.multicast++;
 -	} else if ((dst = __br_fdb_get(br, dest, vid)) &&
 -			dst->is_local) {
 +	} else if ((p->flags & BR_ISOLATE_MODE) ||
 +		   ((dst = __br_fdb_get(br, dest, vid)) && dst->is_local)) {
 		skb2 = skb;
 		/* Do not forward the packet since it's local. */
 		skb = NULL;
 --- a/net/bridge/br_forward.c
 +++ b/net/bridge/br_forward.c
@@ -119,7 +119,7 @@ void br_deliver(const struct net_bridge_
 /* called with rcu_read_lock */
 void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
 {
 -	if (should_deliver(to, skb)) {
 +	if (should_deliver(to, skb) && !(to->flags & BR_ISOLATE_MODE)) {
 		if (skb0)
 			deliver_clone(to, skb, __br_forward);
 		else
@@ -175,7 +175,7 @@ static void br_flood(struct net_bridge *
 		     struct sk_buff *skb0,
 		     void (*__packet_hook)(const struct net_bridge_port *p,
 					   struct sk_buff *skb),
 -		     bool unicast)
 +		     				bool unicast, bool forward)
 {
 	struct net_bridge_port *p;
 	struct net_bridge_port *prev;
@@ -183,6 +183,8 @@ static void br_flood(struct net_bridge *
 	prev = NULL;
 	list_for_each_entry_rcu(p, &br->port_list, list) {
 +		if (forward && (p->flags & BR_ISOLATE_MODE))
 +			continue;
 		/* Do not flood unicast traffic to ports that turn it off */
 		if (unicast && !(p->flags & BR_FLOOD))
 			continue;
@@ -209,14 +211,14 @@ out:
 /* called with rcu_read_lock */
 void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb, bool unicast)
 {
 -	br_flood(br, skb, NULL, __br_deliver, unicast);
 +	br_flood(br, skb, NULL, __br_deliver, unicast, false);
 }
 /* called under bridge lock */
 void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
 		      struct sk_buff *skb2, bool unicast)
 {
 -	br_flood(br, skb, skb2, __br_forward, unicast);
 +	br_flood(br, skb, skb2, __br_forward, unicast, true);
 }
 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
--- a/target/linux/generic/patches-3.13/643-bridge_remove_ipv6_dependency.patch
+++ b/target/linux/generic/patches-3.13/643-bridge_remove_ipv6_dependency.patch
@ -1,107 +0,0 @@
 --- a/include/net/addrconf.h
 +++ b/include/net/addrconf.h
@@ -88,6 +88,12 @@ int ipv6_rcv_saddr_equal(const struct so
 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr);
 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr);
 +extern int			(*ipv6_dev_get_saddr_hook)(struct net *net,
 +						const struct net_device *dev,
 +						const struct in6_addr *daddr,
 +						unsigned int prefs,
 +						struct in6_addr *saddr);
 +
 static inline unsigned long addrconf_timeout_fixup(u32 timeout,
 						   unsigned int unit)
 {
 --- a/net/bridge/Kconfig
 +++ b/net/bridge/Kconfig
@@ -6,7 +6,6 @@ config BRIDGE
 	tristate "802.1d Ethernet Bridging"
 	select LLC
 	select STP
 -	depends on IPV6 || IPV6=n
 	---help---
 	  If you say Y here, then your Linux box will be able to act as an
 	  Ethernet bridge, which means that the different Ethernet segments it
 --- a/net/ipv6/Makefile
 +++ b/net/ipv6/Makefile
@@ -45,3 +45,4 @@ obj-y += addrconf_core.o exthdrs_core.o
 obj-$(CONFIG_INET) += output_core.o protocol.o $(ipv6-offload)
 obj-$(subst m,y,$(CONFIG_IPV6)) += inet6_hashtables.o
 +obj-$(subst m,y,$(CONFIG_IPV6)) += inet6_stubs.o
 --- a/net/ipv6/addrconf.c
 +++ b/net/ipv6/addrconf.c
@@ -1279,7 +1279,7 @@ out:
 	return ret;
 }
 -int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
 +static int __ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
 		       const struct in6_addr *daddr, unsigned int prefs,
 		       struct in6_addr *saddr)
 {
@@ -1404,7 +1404,6 @@ try_nextdev:
 	in6_ifa_put(hiscore->ifa);
 	return 0;
 }
 -EXPORT_SYMBOL(ipv6_dev_get_saddr);
 int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
 		      unsigned char banned_flags)
@@ -5154,6 +5153,9 @@ int __init addrconf_init(void)
 	ipv6_addr_label_rtnl_register();
 +	BUG_ON(ipv6_dev_get_saddr_hook != NULL);
 +	rcu_assign_pointer(ipv6_dev_get_saddr_hook, __ipv6_dev_get_saddr);
 +
 	return 0;
 errout:
 	rtnl_af_unregister(&inet6_ops);
@@ -5172,6 +5174,9 @@ void addrconf_cleanup(void)
 	struct net_device *dev;
 	int i;
 +	rcu_assign_pointer(ipv6_dev_get_saddr_hook, NULL);
 +	synchronize_rcu();
 +
 	unregister_netdevice_notifier(&ipv6_dev_notf);
 	unregister_pernet_subsys(&addrconf_ops);
 	ipv6_addr_label_cleanup();
 --- /dev/null
 +++ b/net/ipv6/inet6_stubs.c
@@ -0,0 +1,33 @@
 +/*
 + *      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/export.h>
 +#include <net/ipv6.h>
 +
 +int (*ipv6_dev_get_saddr_hook)(struct net *net, const struct net_device *dev,
 +			const struct in6_addr *daddr, unsigned int prefs,
 +			struct in6_addr *saddr);
 +
 +EXPORT_SYMBOL(ipv6_dev_get_saddr_hook);
 +
 +int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
 +			const struct in6_addr *daddr, unsigned int prefs,
 +			struct in6_addr *saddr)
 +{
 +	int ret = -EADDRNOTAVAIL;
 +	typeof(ipv6_dev_get_saddr_hook) dev_get_saddr;
 +
 +	rcu_read_lock();
 +	dev_get_saddr = rcu_dereference(ipv6_dev_get_saddr_hook);
 +
 +	if (dev_get_saddr)
 +		ret = dev_get_saddr(net, dst_dev, daddr, prefs, saddr);
 +
 +	rcu_read_unlock();
 +	return ret;
 +}
 +EXPORT_SYMBOL(ipv6_dev_get_saddr);
 +
--- a/target/linux/generic/patches-3.13/644-bridge_optimize_netfilter_hooks.patch
+++ b/target/linux/generic/patches-3.13/644-bridge_optimize_netfilter_hooks.patch
@ -1,155 +0,0 @@
 --- a/net/bridge/br_forward.c
 +++ b/net/bridge/br_forward.c
@@ -57,7 +57,7 @@ int br_dev_queue_push_xmit(struct sk_buf
 int br_forward_finish(struct sk_buff *skb)
 {
 -	return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
 +	return BR_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
 		       br_dev_queue_push_xmit);
 }
@@ -80,7 +80,7 @@ static void __br_deliver(const struct ne
 		return;
 	}
 -	NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 +	BR_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 		br_forward_finish);
 }
@@ -101,7 +101,7 @@ static void __br_forward(const struct ne
 	skb->dev = to->dev;
 	skb_forward_csum(skb);
 -	NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev,
 +	BR_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev,
 		br_forward_finish);
 }
 --- a/net/bridge/br_input.c
 +++ b/net/bridge/br_input.c
@@ -52,7 +52,7 @@ static int br_pass_frame_up(struct sk_bu
 	indev = skb->dev;
 	skb->dev = brdev;
 -	return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, indev, NULL,
 +	return BR_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, indev, NULL,
 		       netif_receive_skb);
 }
@@ -213,7 +213,7 @@ rx_handler_result_t br_handle_frame(stru
 		}
 		/* Deliver packet to local host only */
 -		if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb->dev,
 +		if (BR_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb->dev,
 			    NULL, br_handle_local_finish)) {
 			return RX_HANDLER_CONSUMED; /* consumed by filter */
 		} else {
@@ -228,7 +228,7 @@ forward:
 		if (ether_addr_equal(p->br->dev->dev_addr, dest))
 			skb->pkt_type = PACKET_HOST;
 -		if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
 +		if (BR_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
 			br_handle_local_finish))
 			break;
@@ -250,7 +250,7 @@ forward:
 		if (ether_addr_equal(p->br->dev->dev_addr, dest))
 			skb->pkt_type = PACKET_HOST;
 -		NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
 +		BR_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
 			br_handle_frame_finish);
 		break;
 	default:
 --- a/net/bridge/br_multicast.c
 +++ b/net/bridge/br_multicast.c
@@ -802,7 +802,7 @@ static void __br_multicast_send_query(st
 	if (port) {
 		__skb_push(skb, sizeof(struct ethhdr));
 		skb->dev = port->dev;
 -		NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 +		BR_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 			dev_queue_xmit);
 	} else
 		netif_rx(skb);
 --- a/net/bridge/br_netfilter.c
 +++ b/net/bridge/br_netfilter.c
@@ -73,6 +73,15 @@ static int brnf_pass_vlan_indev __read_m
 #define IS_ARP(skb) \
 	(!vlan_tx_tag_present(skb) && skb->protocol == htons(ETH_P_ARP))
 +int brnf_call_ebtables __read_mostly = 0;
 +EXPORT_SYMBOL_GPL(brnf_call_ebtables);
 +
 +bool br_netfilter_run_hooks(void)
 +{
 +	return brnf_call_iptables | brnf_call_ip6tables | brnf_call_arptables |
 +	       brnf_call_ebtables;
 +}
 +
 static inline __be16 vlan_proto(const struct sk_buff *skb)
 {
 	if (vlan_tx_tag_present(skb))
 --- a/net/bridge/br_private.h
 +++ b/net/bridge/br_private.h
@@ -717,15 +717,29 @@ static inline u16 br_get_pvid(const stru
 /* br_netfilter.c */
 #ifdef CONFIG_BRIDGE_NETFILTER
 +extern int brnf_call_ebtables;
 int br_netfilter_init(void);
 void br_netfilter_fini(void);
 void br_netfilter_rtable_init(struct net_bridge *);
 +bool br_netfilter_run_hooks(void);
 #else
 #define br_netfilter_init()	(0)
 #define br_netfilter_fini()	do { } while(0)
 #define br_netfilter_rtable_init(x)
 +#define br_netfilter_run_hooks()	false
 #endif
 +static inline int
 +BR_HOOK(uint8_t pf, unsigned int hook, struct sk_buff *skb,
 +	struct net_device *in, struct net_device *out,
 +	int (*okfn)(struct sk_buff *))
 +{
 +	if (!br_netfilter_run_hooks())
 +		return okfn(skb);
 +
 +	return NF_HOOK(pf, hook, skb, in, out, okfn);
 +}
 +
 /* br_stp.c */
 void br_log_state(const struct net_bridge_port *p);
 struct net_bridge_port *br_get_port(struct net_bridge *br, u16 port_no);
 --- a/net/bridge/br_stp_bpdu.c
 +++ b/net/bridge/br_stp_bpdu.c
@@ -54,7 +54,7 @@ static void br_send_bpdu(struct net_brid
 	skb_reset_mac_header(skb);
 -	NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 +	BR_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
 		dev_queue_xmit);
 }
 --- a/net/bridge/netfilter/ebtables.c
 +++ b/net/bridge/netfilter/ebtables.c
@@ -2407,11 +2407,13 @@ static int __init ebtables_init(void)
 	}
 	printk(KERN_INFO "Ebtables v2.0 registered\n");
 +	brnf_call_ebtables = 1;
 	return 0;
 }
 static void __exit ebtables_fini(void)
 {
 +	brnf_call_ebtables = 0;
 	nf_unregister_sockopt(&ebt_sockopts);
 	xt_unregister_target(&ebt_standard_target);
 	printk(KERN_INFO "Ebtables v2.0 unregistered\n");
--- a/target/linux/generic/patches-3.13/650-pppoe_header_pad.patch
+++ b/target/linux/generic/patches-3.13/650-pppoe_header_pad.patch
@ -1,20 +0,0 @@
 --- a/drivers/net/ppp/pppoe.c
 +++ b/drivers/net/ppp/pppoe.c
@@ -850,7 +850,7 @@ static int pppoe_sendmsg(struct kiocb *i
 		goto end;
 -	skb = sock_wmalloc(sk, total_len + dev->hard_header_len + 32,
 +	skb = sock_wmalloc(sk, total_len + dev->hard_header_len + 32 + NET_SKB_PAD,
 			   0, GFP_KERNEL);
 	if (!skb) {
 		error = -ENOMEM;
@@ -858,7 +858,7 @@ static int pppoe_sendmsg(struct kiocb *i
 	}
 	/* Reserve space for headers. */
 -	skb_reserve(skb, dev->hard_header_len);
 +	skb_reserve(skb, dev->hard_header_len + NET_SKB_PAD);
 	skb_reset_network_header(skb);
 	skb->dev = dev;
--- a/Show more
+++ b/Show more