diff options
19 files changed, 1811 insertions, 0 deletions
diff --git a/target/linux/mediatek/patches/0440-block2mtd_init.patch b/target/linux/mediatek/patches/0440-block2mtd_init.patch new file mode 100755 index 0000000..19ff9f0 --- /dev/null +++ b/target/linux/mediatek/patches/0440-block2mtd_init.patch @@ -0,0 +1,108 @@ +Index: linux-3.10.20/drivers/mtd/devices/block2mtd.c +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/devices/block2mtd.c ++++ linux-3.10.20/drivers/mtd/devices/block2mtd.c +@@ -14,6 +14,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,14 +277,17 @@ 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); + INFO("mtd%d: [%s] erase_size = %dKiB [%d]", 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: +@@ -352,9 +360,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; +@@ -365,7 +373,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) +@@ -384,8 +392,10 @@ static int block2mtd_setup2(const char * + parse_err("illegal erase size"); + } + } ++ if (token[2] && (strlen(token[2]) + 1 > 80)) ++ parse_err("mtd device name too long"); + +- add_device(name, erase_size); ++ add_device(name, erase_size, token[2]); + + return 0; + } +@@ -419,7 +429,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) + { diff --git a/target/linux/mediatek/patches/0441-block2mtd_probe.patch b/target/linux/mediatek/patches/0441-block2mtd_probe.patch new file mode 100644 index 0000000..5fdbcbc --- /dev/null +++ b/target/linux/mediatek/patches/0441-block2mtd_probe.patch @@ -0,0 +1,266 @@ +Index: linux-3.10.20/drivers/mtd/devices/block2mtd.c +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/devices/block2mtd.c ++++ linux-3.10.20/drivers/mtd/devices/block2mtd.c +@@ -7,6 +7,7 @@ + * Licence: GPL + */ + #include <linux/module.h> ++#include <linux/delay.h> + #include <linux/fs.h> + #include <linux/blkdev.h> + #include <linux/bio.h> +@@ -32,10 +33,18 @@ struct block2mtd_dev { + }; + + ++/* the mtd parsers we want to use */ ++static const char * const block2mtd_probe_types[] = { "cmdlinepart", NULL }; ++ ++/* we can map a single or a list of partitions */ ++enum { ++ B2M_SINGLE = 0, ++ B2M_PARSER, ++}; ++ + /* Static info about the MTD, used in cleanup_module */ + static LIST_HEAD(blkmtd_device_list); + +- + static struct page *page_read(struct address_space *mapping, int index) + { + return read_mapping_page(mapping, index, NULL); +@@ -211,14 +220,16 @@ 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, int offset, int length, int mtdparts) + { + 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; +- ++#ifndef MODULE ++ int i; ++#endif + if (!devname) + return NULL; + +@@ -228,15 +239,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 + +@@ -251,6 +267,16 @@ static struct block2mtd_dev *add_device( + goto devinit_err; + } + ++ if (length && (long)length % erase_size) { ++ pr_err("length must be a divisor of device size\n"); ++ goto devinit_err; ++ } ++ ++ if (offset && (long)offset % erase_size) { ++ pr_err("offset must be a divisor of device size\n"); ++ goto devinit_err; ++ } ++ + mutex_init(&dev->write_mutex); + + /* Setup the MTD structure */ +@@ -277,6 +303,7 @@ static struct block2mtd_dev *add_device( + dev->mtd.priv = dev; + dev->mtd.owner = THIS_MODULE; + ++#if 0 + part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); + part->name = name; + part->offset = 0; +@@ -285,6 +312,31 @@ static struct block2mtd_dev *add_device( + /* Device didn't get added, so free the entry */ + goto devinit_err; + } ++#else ++ if (mtdparts == B2M_PARSER) { ++ struct mtd_part_parser_data ppdata = { 0 }; ++ if (mtd_device_parse_register(&dev->mtd, block2mtd_probe_types, &ppdata, NULL, 0)) { ++ /* Device didn't get added, so free the entry */ ++ goto devinit_err; ++ } ++ } else { ++ part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); ++ part->name = name; ++ if (offset) { ++ part->offset = 0; ++ if (length && offset + length <= dev->mtd.size) ++ part->size = length; ++ else ++ part->size = dev->mtd.size - part->offset; ++ } else { ++ 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; ++ } ++ } ++#endif + list_add(&dev->list, &blkmtd_device_list); + INFO("mtd%d: [%s] erase_size = %dKiB [%d]", dev->mtd.index, + mtdname, dev->mtd.erasesize >> 10, dev->mtd.erasesize); +@@ -354,17 +406,20 @@ static inline void kill_final_newline(ch + + #ifndef MODULE + static int block2mtd_init_called = 0; +-static char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */ ++static char block2mtd_paramline[80 + 12 + 80 + 8]; /* 80 for device, 12 for erase size */ ++static char block2mtdparts_paramline[80 + 12 + 80 + 8]; /* 80 for device, 12 for erase size */ ++ + #endif + + +-static int block2mtd_setup2(const char *val) ++static int block2mtd_setup2(const char *val, int mtdparts) + { +- char buf[80 + 12 + 80]; /* 80 for device, 12 for erase size, 80 for name */ ++ char buf[80 + 12 + 80 + 8 + 12 + 12]; /* 80 for device, 12 for erase size, 80 for name, 8 for timeout, 12 for offset, 12 for size */ + char *str = buf; +- char *token[3]; ++ char *token[6]; + char *name; + size_t erase_size = PAGE_SIZE; ++ unsigned long timeout = 0, offset = 0, length = 0; + int i, ret; + + if (strnlen(val, sizeof(buf)) >= sizeof(buf)) +@@ -373,7 +428,7 @@ static int block2mtd_setup2(const char * + strcpy(str, val); + kill_final_newline(str); + +- for (i = 0; i < 3; i++) ++ for (i = 0; i < 6; i++) + token[i] = strsep(&str, ","); + + if (str) +@@ -395,7 +450,16 @@ static int block2mtd_setup2(const char * + if (token[2] && (strlen(token[2]) + 1 > 80)) + parse_err("mtd device name too long"); + +- add_device(name, erase_size, token[2]); ++ if (token[3] && kstrtoul(token[3], 0, &timeout)) ++ parse_err("invalid timeout"); ++ ++ if (token[4] && kstrtoul(token[4], 0, &offset)) ++ pr_err("invalid offset\n"); ++ ++ if (token[5] && kstrtoul(token[5], 0, &length)) ++ pr_err("invalid length\n"); ++ ++ add_device(name, erase_size, token[2], timeout, offset, length, mtdparts); + + return 0; + } +@@ -404,7 +468,7 @@ static int block2mtd_setup2(const char * + static int block2mtd_setup(const char *val, struct kernel_param *kp) + { + #ifdef MODULE +- return block2mtd_setup2(val); ++ return block2mtd_setup2(val, B2M_SINGLE); + #else + /* If more parameters are later passed in via + /sys/module/block2mtd/parameters/block2mtd +@@ -412,7 +476,7 @@ static int block2mtd_setup(const char *v + we can parse the argument now. */ + + if (block2mtd_init_called) +- return block2mtd_setup2(val); ++ return block2mtd_setup2(val, B2M_SINGLE); + + /* During early boot stage, we only save the parameters + here. We must parse them later: if the param passed +@@ -428,8 +492,38 @@ static int block2mtd_setup(const char *v + } + + ++static int block2mtdparts_setup(const char *val, struct kernel_param *kp) ++{ ++#ifdef MODULE ++ return block2mtd_setup2(val, B2M_PARSER); ++#else ++ /* If more parameters are later passed in via ++ /sys/module/block2mtd/parameters/block2mtd ++ and block2mtd_init() has already been called, ++ we can parse the argument now. */ ++ ++ if (block2mtd_init_called) ++ return block2mtd_setup2(val, B2M_PARSER); ++ ++ /* During early boot stage, we only save the parameters ++ here. We must parse them later: if the param passed ++ from kernel boot command line, block2mtd_setup() is ++ called so early that it is not possible to resolve ++ the device (even kmalloc() fails). Deter that work to ++ block2mtd_setup2(). */ ++ ++ strlcpy(block2mtdparts_paramline, val, sizeof(block2mtdparts_paramline)); ++ ++ return 0; ++#endif ++} ++ ++ + 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>]]]\""); ++ ++module_param_call(block2mtdparts, block2mtdparts_setup, NULL, NULL, 0200); ++MODULE_PARM_DESC(block2mtdparts, "Device to use. \"block2mtdparts=<dev>[,<erasesize>[,<name>[,<timeout>]]]\""); + + static int __init block2mtd_init(void) + { +@@ -437,7 +531,9 @@ static int __init block2mtd_init(void) + + #ifndef MODULE + if (strlen(block2mtd_paramline)) +- ret = block2mtd_setup2(block2mtd_paramline); ++ ret = block2mtd_setup2(block2mtd_paramline, B2M_SINGLE); ++ if (strlen(block2mtdparts_paramline)) ++ ret = block2mtd_setup2(block2mtdparts_paramline, B2M_PARSER); + block2mtd_init_called = 1; + #endif + +@@ -462,7 +558,7 @@ static void block2mtd_exit(void) + } + + +-module_init(block2mtd_init); ++late_initcall(block2mtd_init); + module_exit(block2mtd_exit); + + MODULE_LICENSE("GPL"); diff --git a/target/linux/mediatek/patches/0602-ufsd.patch b/target/linux/mediatek/patches/0602-ufsd.patch new file mode 100644 index 0000000..6ada125 --- /dev/null +++ b/target/linux/mediatek/patches/0602-ufsd.patch @@ -0,0 +1,13 @@ +Index: linux-3.10.20/fs/Kconfig +=================================================================== +--- linux-3.10.20.orig/fs/Kconfig ++++ linux-3.10.20/fs/Kconfig +@@ -186,7 +186,7 @@ menuconfig MISC_FILESYSTEMS + + if MISC_FILESYSTEMS + +-source "fs/ufsd/Kconfig" ++#source "fs/ufsd/Kconfig" + source "fs/adfs/Kconfig" + source "fs/affs/Kconfig" + source "fs/ecryptfs/Kconfig" diff --git a/target/linux/mediatek/patches/1001-xt-layer7.patch b/target/linux/mediatek/patches/1001-xt-layer7.patch new file mode 100644 index 0000000..69410c2 --- /dev/null +++ b/target/linux/mediatek/patches/1001-xt-layer7.patch @@ -0,0 +1,9 @@ +Index: linux-3.10.20/include/uapi/linux/netfilter/Kbuild +=================================================================== +--- linux-3.10.20.orig/include/uapi/linux/netfilter/Kbuild ++++ linux-3.10.20/include/uapi/linux/netfilter/Kbuild +@@ -78,3 +78,4 @@ header-y += xt_tcpmss.h + header-y += xt_tcpudp.h + header-y += xt_time.h + header-y += xt_u32.h ++header-y += xt_layer7.h diff --git a/target/linux/mediatek/patches/1002-group-sched.patch b/target/linux/mediatek/patches/1002-group-sched.patch new file mode 100644 index 0000000..46eb810 --- /dev/null +++ b/target/linux/mediatek/patches/1002-group-sched.patch @@ -0,0 +1,17 @@ +Index: linux-3.10.20/kernel/sched/rt.c +=================================================================== +--- linux-3.10.20.orig/kernel/sched/rt.c ++++ linux-3.10.20/kernel/sched/rt.c +@@ -1102,8 +1102,11 @@ static int sched_rt_runtime_exceeded(str + + if (rt_rq->rt_time > runtime) { + struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq); ++#ifdef CONFIG_RT_GROUP_SCHED + int cpu = rq_cpu(rt_rq->rq); +- ++#else ++ int cpu = 0; ++#endif + printk_sched("sched: cpu=%d rt_time %llu <-> runtime" + " [%llu -> %llu], exec_delta_time[%llu]" + ", clock_task[%llu], exec_start[%llu]\n", diff --git a/target/linux/mediatek/patches/1003-openwrt-config.patch b/target/linux/mediatek/patches/1003-openwrt-config.patch new file mode 100644 index 0000000..4df82e4 --- /dev/null +++ b/target/linux/mediatek/patches/1003-openwrt-config.patch @@ -0,0 +1,13 @@ +Index: linux-3.10.20/Kconfig +=================================================================== +--- linux-3.10.20.orig/Kconfig ++++ linux-3.10.20/Kconfig +@@ -8,4 +8,8 @@ config SRCARCH + string + option env="SRCARCH" + ++config SUPPORT_OPENWRT ++ bool "Support OpenWrt" ++ default n ++ + source "arch/$SRCARCH/Kconfig" diff --git a/target/linux/mediatek/patches/1004-mips-image-cmdline-hack.patch b/target/linux/mediatek/patches/1004-mips-image-cmdline-hack.patch new file mode 100644 index 0000000..35e1e86 --- /dev/null +++ b/target/linux/mediatek/patches/1004-mips-image-cmdline-hack.patch @@ -0,0 +1,32 @@ +Index: linux-3.10.20/arch/mips/Kconfig +=================================================================== +--- linux-3.10.20.orig/arch/mips/Kconfig ++++ linux-3.10.20/arch/mips/Kconfig +@@ -992,6 +992,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 + +Index: linux-3.10.20/arch/mips/kernel/head.S +=================================================================== +--- linux-3.10.20.orig/arch/mips/kernel/head.S ++++ linux-3.10.20/arch/mips/kernel/head.S +@@ -140,6 +140,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 diff --git a/target/linux/mediatek/patches/1006-rootfs-split.patch b/target/linux/mediatek/patches/1006-rootfs-split.patch new file mode 100644 index 0000000..e6bc21d --- /dev/null +++ b/target/linux/mediatek/patches/1006-rootfs-split.patch @@ -0,0 +1,788 @@ +Index: linux-3.10.20/drivers/mtd/Makefile +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/Makefile ++++ linux-3.10.20/drivers/mtd/Makefile +@@ -4,7 +4,12 @@ + + # Core functionality. + obj-$(CONFIG_MTD) += mtd.o +-mtd-y := mtdcore.o mtdsuper.o mtdconcat.o mtdpart.o mtdchar.o ++mtd-y += mtdcore.o mtdsuper.o mtdconcat.o mtdpart.o mtdchar.o ++mtd-$(CONFIG_MTD_SPLIT) += mtdsplit.o ++mtd-$(CONFIG_MTD_SPLIT_SEAMA_FW) += mtdsplit_seama.o ++mtd-$(CONFIG_MTD_SPLIT_SQUASHFS_ROOT) += mtdsplit_squashfs.o ++mtd-$(CONFIG_MTD_SPLIT_UIMAGE_FW) += mtdsplit_uimage.o ++mtd-$(CONFIG_MTD_SPLIT_LZMA_FW) += mtdsplit_lzma.o + + obj-$(CONFIG_MTD_OF_PARTS) += ofpart.o + obj-$(CONFIG_MTD_REDBOOT_PARTS) += redboot.o +Index: linux-3.10.20/drivers/mtd/Kconfig +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/Kconfig ++++ linux-3.10.20/drivers/mtd/Kconfig +@@ -12,6 +12,68 @@ menuconfig MTD + + if MTD + ++if SUPPORT_OPENWRT ++menu "OpenWrt specific MTD options" ++ ++config MTD_ROOTFS_ROOT_DEV ++ bool "Automatically set 'rootfs' partition to be root filesystem" ++ default n ++ ++config MTD_ROOTFS_SPLIT ++ bool "Automatically split 'rootfs' partition for squashfs" ++ select MTD_SPLIT ++ default n ++ ++config MTD_SPLIT_FIRMWARE ++ bool "Automatically split firmware partition for kernel+rootfs" ++ default n ++ ++config MTD_SPLIT_FIRMWARE_NAME ++ string "Firmware partition name" ++ depends on MTD_SPLIT_FIRMWARE ++ default "firmware" ++ default n ++ ++config MTD_UIMAGE_SPLIT ++ bool "Enable split support for firmware partitions containing a uImage" ++ depends on MTD_SPLIT_FIRMWARE ++ default n ++ ++comment "Rootfs partition parsers" ++ ++config MTD_SPLIT_SQUASHFS_ROOT ++ bool "Squashfs based root partition parser" ++ select MTD_SPLIT ++ default n ++ help ++ This provides a parsing function which allows to detect the ++ offset and size of the unused portion of a rootfs partition ++ containing a squashfs. ++comment "Firmware partition parsers" ++ ++config MTD_SPLIT_SEAMA_FW ++ bool "Seama firmware parser" ++ select MTD_SPLIT ++ default n ++ ++config MTD_SPLIT_UIMAGE_FW ++ bool "uImage based firmware partition parser" ++ select MTD_SPLIT ++ default n ++ ++config MTD_SPLIT_LZMA_FW ++ bool "LZMA compressed kernel based firmware partition parser" ++ select MTD_SPLIT ++ default n ++ ++config MTD_SPLIT ++ def_bool n ++ depends on SUPPORT_OPENWRT ++ help ++ Generic MTD split support. ++ ++endmenu ++endif # SUPPORT_OPENWRT + config MTD_TESTS + tristate "MTD tests support (DANGEROUS)" + depends on m +@@ -309,10 +371,10 @@ config MTD_SWAP + OOB. + + config MTK_MTD_NOR +- depends on ARCH_MT7623 ++ depends on ARCH_MT7623 + tristate "MTK NOR Flash Support" + help +- Support MTK NOR flash controller. ++ Support MTK NOR flash controller. + + + +Index: linux-3.10.20/drivers/mtd/mtdpart.c +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/mtdpart.c ++++ linux-3.10.20/drivers/mtd/mtdpart.c +@@ -29,10 +29,16 @@ + #include <linux/kmod.h> + #include <linux/mtd/mtd.h> + #include <linux/mtd/partitions.h> ++#if defined(CONFIG_SUPPORT_OPENWRT) ++#include <linux/magic.h> ++#endif + #include <linux/err.h> + + #include "mtdcore.h" +- ++#if defined(CONFIG_SUPPORT_OPENWRT) ++#include "mtdsplit.h" ++#define MTD_ERASE_PARTIAL 0x8000 /* partition only covers parts of an erase block */ ++#endif + #define DYNAMIC_CHANGE_MTD_WRITEABLE + #ifdef DYNAMIC_CHANGE_MTD_WRITEABLE //wschen 2011-01-05 + #include <linux/proc_fs.h> +@@ -60,6 +66,10 @@ struct mtd_part { + struct list_head list; + }; + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++static void mtd_partition_split(struct mtd_info *master, struct mtd_part *part); ++#endif ++ + /* + * Given a pointer to the MTD object in the mtd_part structure, we can retrieve + * the pointer to that structure with this macro. +@@ -243,12 +253,61 @@ static int part_erase(struct mtd_info *m + struct mtd_part *part = PART(mtd); + int ret; + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ 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->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; ++ } ++ ++ } ++#endif ++ + 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 defined(CONFIG_SUPPORT_OPENWRT) ++ if (mtd->flags & MTD_ERASE_PARTIAL) ++ kfree(instr->erase_buf); ++#endif + } + return ret; + } +@@ -257,7 +316,27 @@ void mtd_erase_callback(struct erase_inf + { + if (instr->mtd->_erase == part_erase) { + struct mtd_part *part = PART(instr->mtd); ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ 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); ++ } ++#endif + if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) + instr->fail_addr -= part->offset; + instr->addr -= part->offset; +@@ -276,7 +355,17 @@ 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); ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ 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); ++#else + return part->master->_unlock(part->master, ofs + part->offset, len); ++#endif + } + + static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) +@@ -450,6 +539,14 @@ static struct mtd_part *allocate_partiti + if (slave->offset == MTDPART_OFS_APPEND) + slave->offset = cur_offset; + if (slave->offset == MTDPART_OFS_NXTBLK) { ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ /* 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); ++#else + slave->offset = cur_offset; + if (mtd_mod_by_eb(cur_offset, master) != 0) { + /* Round up to next erasesize */ +@@ -458,6 +555,7 @@ static struct mtd_part *allocate_partiti + "0x%012llx -> 0x%012llx\n", partno, + (unsigned long long)cur_offset, (unsigned long long)slave->offset); + } ++#endif + } + if (slave->offset == MTDPART_OFS_RETAIN) { + slave->offset = cur_offset; +@@ -518,6 +616,29 @@ static struct mtd_part *allocate_partiti + slave->mtd.erasesize = master->erasesize; + } + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ if ((slave->mtd.flags & MTD_WRITEABLE) && ++ mtd_mod_by_eb(slave->offset, &slave->mtd)) { ++ /* Doesn't start on a boundary of major erase size */ ++ 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->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); ++#else + if ((slave->mtd.flags & MTD_WRITEABLE) && + mtd_mod_by_eb(slave->offset, &slave->mtd)) { + /* Doesn't start on a boundary of major erase size */ +@@ -533,6 +654,7 @@ static struct mtd_part *allocate_partiti + printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n", + part->name); + } ++#endif + + slave->mtd.ecclayout = master->ecclayout; + slave->mtd.ecc_strength = master->ecc_strength; +@@ -552,6 +674,74 @@ out_register: + return slave; + } + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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; ++ uint64_t start, end; ++ int ret = 0; ++ ++ /* the direct offset is expected */ ++ if (offset == MTDPART_OFS_APPEND || ++ offset == MTDPART_OFS_NXTBLK) ++ return -EINVAL; ++ ++ if (length == MTDPART_SIZ_FULL) ++ length = master->size - offset; ++ ++ if (length <= 0) ++ return -EINVAL; ++ ++ part.name = name; ++ part.size = length; ++ part.offset = offset; ++ part.mask_flags = 0; ++ part.ecclayout = NULL; ++ ++ new = allocate_partition(master, &part, -1, offset); ++ if (IS_ERR(new)) ++ return PTR_ERR(new); ++ ++ start = offset; ++ end = offset + length; ++ ++ mutex_lock(&mtd_partitions_mutex); ++ 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: ++ mutex_unlock(&mtd_partitions_mutex); ++ free_partition(new); ++ return -EINVAL; ++} ++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); ++} ++#else /* CONFIG_SUPPORT_OPENWRT */ + int mtd_add_partition(struct mtd_info *master, char *name, + long long offset, long long length) + { +@@ -608,6 +798,7 @@ err_inv: + return -EINVAL; + } + EXPORT_SYMBOL_GPL(mtd_add_partition); ++#endif /* CONFIG_SUPPORT_OPENWRT */ + + int mtd_del_partition(struct mtd_info *master, int partno) + { +@@ -632,6 +823,164 @@ int mtd_del_partition(struct mtd_info *m + } + EXPORT_SYMBOL_GPL(mtd_del_partition); + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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) ++{ ++ unsigned long mask = mtd->erasesize - 1; ++ ++ len += offset & mask; ++ len = (len + mask) & ~mask; ++ len -= offset & mask; ++ return len; ++} ++ ++static int split_squashfs(struct mtd_info *master, int offset, int *split_offset) ++{ ++ size_t squashfs_len; ++ int len, ret; ++ ++ ret = mtd_get_squashfs_len(master, offset, &squashfs_len); ++ if (ret) ++ return ret; ++ ++ len = mtd_pad_erasesize(master, offset, squashfs_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 = run_parsers_by_type(part, MTD_PARSER_TYPE_ROOTFS); ++ if (ret > 0) ++ return; ++ ++ 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 pad0[2]; ++ __be32 size; ++ __be32 pad1[4]; ++ __be32 name[7]; ++ __be32 kern_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; ++ ++ if (hdr.kern_size != 0 && hdr.name[0] == 0) ++ len = be32_to_cpu(hdr.kern_size); ++ else ++ len = be32_to_cpu(hdr.size) + 0x40; ++ ++ __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) ++{ ++ 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); ++} ++ ++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); ++} ++#endif /* CONFIG_SUPPORT_OPENWRT */ ++ + /* + * 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 +@@ -661,7 +1010,9 @@ int add_mtd_partitions(struct mtd_info * + mutex_unlock(&mtd_partitions_mutex); + + add_mtd_device(&slave->mtd); +- ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ mtd_partition_split(master, slave); ++#endif + cur_offset = slave->offset + slave->mtd.size; + } + #ifdef DYNAMIC_CHANGE_MTD_WRITEABLE //wschen 2011-01-05 +@@ -692,6 +1043,32 @@ static struct mtd_part_parser *get_parti + + #define put_partition_parser(p) do { module_put((p)->owner); } while (0) + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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; ++} ++#endif ++ + int register_mtd_parser(struct mtd_part_parser *p) + { + spin_lock(&part_parser_lock); +@@ -768,6 +1145,40 @@ int parse_mtd_partitions(struct mtd_info + return ret; + } + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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); ++#endif /* CONFIG_SUPPORT_OPENWRT */ ++ + int mtd_is_partition(const struct mtd_info *mtd) + { + struct mtd_part *part; +@@ -785,6 +1196,26 @@ int mtd_is_partition(const struct mtd_in + } + EXPORT_SYMBOL_GPL(mtd_is_partition); + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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); ++#endif /* CONFIG_SUPPORT_OPENWRT */ ++ + #ifdef CONFIG_MTK_MTD_NAND + u64 mtd_partition_start_address(struct mtd_info *mtd) + { +Index: linux-3.10.20/include/linux/mtd/map.h +=================================================================== +--- linux-3.10.20.orig/include/linux/mtd/map.h ++++ linux-3.10.20/include/linux/mtd/map.h +@@ -365,7 +365,7 @@ static inline map_word map_word_load_par + bitpos = (map_bankwidth(map)-1-i)*8; + #endif + orig.x[0] &= ~(0xff << bitpos); +- orig.x[0] |= buf[i-start] << bitpos; ++ orig.x[0] |= (unsigned long)buf[i-start] << bitpos; + } + } + return orig; +@@ -384,7 +384,7 @@ static inline map_word map_word_ff(struc + + if (map_bankwidth(map) < MAP_FF_LIMIT) { + int bw = 8 * map_bankwidth(map); +- r.x[0] = (1 << bw) - 1; ++ r.x[0] = (1UL << bw) - 1; + } else { + for (i=0; i<map_words(map); i++) + r.x[i] = ~0UL; +Index: linux-3.10.20/include/linux/mtd/mtd.h +=================================================================== +--- linux-3.10.20.orig/include/linux/mtd/mtd.h ++++ linux-3.10.20/include/linux/mtd/mtd.h +@@ -74,6 +74,9 @@ 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 { +@@ -347,6 +350,26 @@ static inline uint32_t mtd_mod_by_eb(uin + return do_div(sz, mtd->erasesize); + } + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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; ++} ++#endif ++ + static inline uint32_t mtd_div_by_ws(uint64_t sz, struct mtd_info *mtd) + { + if (mtd->writesize_shift) +Index: linux-3.10.20/include/linux/mtd/nand.h +=================================================================== +--- linux-3.10.20.orig/include/linux/mtd/nand.h ++++ linux-3.10.20/include/linux/mtd/nand.h +@@ -679,6 +679,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 */ +Index: linux-3.10.20/include/linux/mtd/partitions.h +=================================================================== +--- linux-3.10.20.orig/include/linux/mtd/partitions.h ++++ linux-3.10.20/include/linux/mtd/partitions.h +@@ -68,12 +68,23 @@ struct mtd_part_parser_data { + * Functions dealing with the various ways of partitioning the space + */ + ++#if defined(CONFIG_SUPPORT_OPENWRT) ++enum mtd_parser_type { ++ MTD_PARSER_TYPE_DEVICE = 0, ++ MTD_PARSER_TYPE_ROOTFS, ++ MTD_PARSER_TYPE_FIRMWARE, ++}; ++#endif ++ + 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 *); ++#if defined(CONFIG_SUPPORT_OPENWRT) ++ enum mtd_parser_type type; ++#endif + }; + + extern int register_mtd_parser(struct mtd_part_parser *parser); +@@ -83,6 +94,18 @@ 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); ++#if defined(CONFIG_SUPPORT_OPENWRT) ++struct mtd_info *mtdpart_get_master(const struct mtd_info *mtd); ++uint64_t mtdpart_get_offset(const struct mtd_info *mtd); ++#endif + uint64_t mtd_get_device_size(const struct mtd_info *mtd); ++#if defined(CONFIG_SUPPORT_OPENWRT) ++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 + #endif diff --git a/target/linux/mediatek/patches/1007-splice-api.patch b/target/linux/mediatek/patches/1007-splice-api.patch new file mode 100644 index 0000000..f4a24d9 --- /dev/null +++ b/target/linux/mediatek/patches/1007-splice-api.patch @@ -0,0 +1,12 @@ +Index: linux-3.10.20/fs/splice.c +=================================================================== +--- linux-3.10.20.orig/fs/splice.c ++++ linux-3.10.20/fs/splice.c +@@ -449,6 +449,7 @@ cleanup: + + goto done; + } ++EXPORT_SYMBOL(generic_splice_from_socket); + + static int __init init_splice_pools(void) + { diff --git a/target/linux/mediatek/patches/1008-squashfs-xz.patch b/target/linux/mediatek/patches/1008-squashfs-xz.patch new file mode 100644 index 0000000..d534063 --- /dev/null +++ b/target/linux/mediatek/patches/1008-squashfs-xz.patch @@ -0,0 +1,16 @@ +Index: linux-3.10.20/fs/squashfs/xz_wrapper.c +=================================================================== +--- linux-3.10.20.orig/fs/squashfs/xz_wrapper.c ++++ linux-3.10.20/fs/squashfs/xz_wrapper.c +@@ -39,8 +39,10 @@ struct squashfs_xz { + }; + + struct comp_opts { +- __le32 dictionary_size; + __le32 flags; ++ __le16 bit_opts; ++ __le16 fp; ++ __le32 dictionary_size; + }; + + static void *squashfs_xz_init(struct squashfs_sb_info *msblk, void *buff, diff --git a/target/linux/mediatek/patches/1010-jffs2-eof.patch b/target/linux/mediatek/patches/1010-jffs2-eof.patch new file mode 100644 index 0000000..0a86c63 --- /dev/null +++ b/target/linux/mediatek/patches/1010-jffs2-eof.patch @@ -0,0 +1,58 @@ +Index: linux-3.10.20/fs/jffs2/build.c +=================================================================== +--- linux-3.10.20.orig/fs/jffs2/build.c ++++ linux-3.10.20/fs/jffs2/build.c +@@ -114,6 +114,17 @@ 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__); ++ if (c->mtd->_unlock) ++ c->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. */ +Index: linux-3.10.20/fs/jffs2/scan.c +=================================================================== +--- linux-3.10.20.orig/fs/jffs2/scan.c ++++ linux-3.10.20/fs/jffs2/scan.c +@@ -148,8 +148,11 @@ 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)) ++ 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 +559,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); diff --git a/target/linux/mediatek/patches/1011-nand.patch b/target/linux/mediatek/patches/1011-nand.patch new file mode 100644 index 0000000..8314395 --- /dev/null +++ b/target/linux/mediatek/patches/1011-nand.patch @@ -0,0 +1,160 @@ +Index: linux-3.10.20/drivers/misc/mediatek/nand/mt7623/mtk_nand.c +=================================================================== +--- linux-3.10.20.orig/drivers/misc/mediatek/nand/mt7623/mtk_nand.c ++++ linux-3.10.20/drivers/misc/mediatek/nand/mt7623/mtk_nand.c +@@ -1066,7 +1066,13 @@ u32 mtk_nand_page_transform(struct mtd_i + (devinfo.feature_set.ptbl_idx != PPTBL_NOT_SUPPORT)) + { + //page_in_block = devinfo.feature_set.PairPage[page_in_block]; +- page_in_block = functArray[devinfo.feature_set.ptbl_idx](page_in_block); ++ if (devinfo.feature_set.ptbl_idx < 3) { ++ page_in_block = functArray[devinfo.feature_set.ptbl_idx](page_in_block); ++ } else { ++ printk("<trace> devinfo.feature_set.ptbl_idx = %d, array idx overflow! L%d, %s\n", ++ devinfo.feature_set.ptbl_idx, __LINE__, __FUNCTION__); ++ } ++ + } + + mapped_block = get_mapping_block_index(block); +@@ -6586,11 +6592,11 @@ static int mtk_nand_probe(struct platfor + printk("Thanks to GOD, UNIT Test OK!\n"); + } + #endif +-#ifdef PMT ++#if 0 //PMT + part_init_pmt(mtd, (u8 *) & g_exist_Partition[0]); + err = mtd_device_register(mtd, g_exist_Partition, part_num); + #else +- err = mtd_device_register(mtd, g_pasStatic_Partition, part_num); ++ err = mtd_device_register(mtd, g_pasStatic_Partition, 6); + #endif + + #ifdef _MTK_NAND_DUMMY_DRIVER_ +Index: linux-3.10.20/drivers/misc/mediatek/nand/mt7623/partition_mt.c +=================================================================== +--- linux-3.10.20.orig/drivers/misc/mediatek/nand/mt7623/partition_mt.c ++++ linux-3.10.20/drivers/misc/mediatek/nand/mt7623/partition_mt.c +@@ -58,7 +58,35 @@ unsigned long long partition_type_array + pt_resident new_part[PART_MAX_COUNT]; + pt_resident lastest_part[PART_MAX_COUNT]; + unsigned char part_name[PART_MAX_COUNT][MAX_PARTITION_NAME_LEN]; +-struct mtd_partition g_pasStatic_Partition[PART_MAX_COUNT]; ++struct mtd_partition g_pasStatic_Partition[PART_MAX_COUNT] = { ++ { ++ name: "ALL", ++ size: MTDPART_SIZ_FULL, ++ offset: 0, ++ }, ++ /* Put your own partition definitions here */ ++ { ++ name: "Preloader", ++ size: 0x40000, ++ offset: 0, ++ }, { ++ name: "Uboot", ++ size: 0x80000, ++ offset: MTDPART_OFS_APPEND ++ }, { ++ name: "Config", ++ size: 0x40000, ++ offset: MTDPART_OFS_APPEND ++ }, { ++ name: "Factory", ++ size: 0x40000, ++ offset: MTDPART_OFS_APPEND ++ }, { ++ name: "firmware", ++ size: MTDPART_SIZ_FULL, ++ offset: MTDPART_OFS_APPEND ++ } ++}; + //int part_num; + //struct excel_info PartInfo[PART_MAX_COUNT]; + #define MTD_SECFG_STR "seccnfg" +@@ -505,6 +533,7 @@ void construct_mtd_partition(struct mtd_ + + if (PartInfo==NULL) + { ++ printk("<trace> L%d, %s\n", __LINE__, __FUNCTION__); + PartInfo = kzalloc(PART_NUM * sizeof(struct excel_info), GFP_KERNEL); + if (!PartInfo) { + printk("%s: malloc PartInfo fail\n",__FILE__); +@@ -512,6 +541,7 @@ void construct_mtd_partition(struct mtd_ + } + memcpy(PartInfo, PartInfo_Private, PART_NUM * sizeof(struct excel_info)); + } ++ printk("<trace> L%d, %s\n", __LINE__, __FUNCTION__); + for(i = 0; i < PART_MAX_COUNT; i++) + { + if(lastest_part[i].size == 0) +Index: linux-3.10.20/drivers/mtd/mtdpart.c +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/mtdpart.c ++++ linux-3.10.20/drivers/mtd/mtdpart.c +@@ -887,6 +887,7 @@ static void split_rootfs_data(struct mtd + unsigned int split_size; + int ret; + ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + ret = run_parsers_by_type(part, MTD_PARSER_TYPE_ROOTFS); + if (ret > 0) + return; +@@ -920,6 +921,7 @@ static void split_uimage(struct mtd_info + } hdr; + size_t len; + ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + if (mtd_read(master, part->offset, sizeof(hdr), &len, (void *) &hdr)) + return; + +@@ -944,6 +946,7 @@ static void split_uimage(struct mtd_info + static void split_firmware(struct mtd_info *master, struct mtd_part *part) + { + int ret; ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + + ret = run_parsers_by_type(part, MTD_PARSER_TYPE_FIRMWARE); + if (ret > 0) +@@ -962,10 +965,14 @@ static void mtd_partition_split(struct m + { + static int rootfs_found = 0; + +- if (rootfs_found) ++ //printk("<trace> %d, %s, %s\n", __LINE__, __FUNCTION__, part->mtd.name); ++ if (rootfs_found) { ++ //printk("<trace> %d, %s, %s\n", __LINE__, __FUNCTION__, part->mtd.name); + return; ++ } + + if (!strcmp(part->mtd.name, "rootfs")) { ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + rootfs_found = 1; + + if (config_enabled(CONFIG_MTD_ROOTFS_SPLIT)) +@@ -973,9 +980,12 @@ static void mtd_partition_split(struct m + } + + if (!strcmp(part->mtd.name, SPLIT_FIRMWARE_NAME) && +- config_enabled(CONFIG_MTD_SPLIT_FIRMWARE)) ++ config_enabled(CONFIG_MTD_SPLIT_FIRMWARE)) { ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + split_firmware(master, part); ++ } + ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + arch_split_mtd_part(master, part->mtd.name, part->offset, + part->mtd.size); + } +@@ -1002,8 +1012,10 @@ int add_mtd_partitions(struct mtd_info * + + for (i = 0; i < nbparts; i++) { + slave = allocate_partition(master, parts + i, i, cur_offset); +- if (IS_ERR(slave)) ++ if (IS_ERR(slave)) { ++ //printk("<trace> %d, %s\n", __LINE__, __FUNCTION__); + return PTR_ERR(slave); ++ } + + mutex_lock(&mtd_partitions_mutex); + list_add(&slave->list, &mtd_partitions); diff --git a/target/linux/mediatek/patches/1013-nf-shortcut.patch b/target/linux/mediatek/patches/1013-nf-shortcut.patch new file mode 100644 index 0000000..5cc79d8 --- /dev/null +++ b/target/linux/mediatek/patches/1013-nf-shortcut.patch @@ -0,0 +1,25 @@ +Index: linux-3.10.20/net/netfilter/nf_shortcut.c +=================================================================== +--- linux-3.10.20.orig/net/netfilter/nf_shortcut.c ++++ linux-3.10.20/net/netfilter/nf_shortcut.c +@@ -125,9 +125,9 @@ int __init mtk_smb_hook_init(void) + struct in_ifaddr *ifa = NULL; + + #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35) +- lan_int = dev_get_by_name_rcu(&init_net, "br0"); ++ lan_int = dev_get_by_name_rcu(&init_net, "br-lan"); + #else +- lan_int = __dev_get_by_name("br0"); ++ lan_int = __dev_get_by_name("br-lan"); + #endif + if (lan_int) + in_dev = __in_dev_get_rtnl(lan_int); +@@ -137,7 +137,7 @@ int __init mtk_smb_hook_init(void) + if (in_dev) { + for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL; + ifap = &ifa->ifa_next) { +- if (!strcmp("br0", ifa->ifa_label)) ++ if (!strcmp("br-lan", ifa->ifa_label)) + { + lan_ifa = ifa; + break; /* found */ diff --git a/target/linux/mediatek/patches/1014-hwnat.patch b/target/linux/mediatek/patches/1014-hwnat.patch new file mode 100644 index 0000000..d4a6379 --- /dev/null +++ b/target/linux/mediatek/patches/1014-hwnat.patch @@ -0,0 +1,105 @@ +Index: linux-3.10.20/net/nat/hw_nat/ra_nat.c +=================================================================== +--- linux-3.10.20.orig/net/nat/hw_nat/ra_nat.c ++++ linux-3.10.20/net/nat/hw_nat/ra_nat.c +@@ -3577,12 +3577,14 @@ static void PpeSetDstPort(uint32_t Ebl) + struct net_device *dev; + #if defined (CONFIG_SUPPORT_OPENWRT) + dev=ra_dev_get_by_name("eth0"); +- printk("eth2 ifindex =%x\n", dev->ifindex); ++ printk("eth0 ifindex =%x\n", dev->ifindex); + DstPort[dev->ifindex] = dev; ++ DP_GMAC1 = dev->ifindex; + #ifdef CONFIG_RAETH_GMAC2 + dev=ra_dev_get_by_name("eth1"); +- printk("eth2 ifindex =%x\n", dev->ifindex); ++ printk("eth1 ifindex =%x\n", dev->ifindex); + DstPort[dev->ifindex] = dev; ++ DPORT_GMAC2 = dev->ifindex;; + #endif + #else + dev=ra_dev_get_by_name("eth2"); +@@ -3616,9 +3618,12 @@ static void PpeSetDstPort(uint32_t Ebl) + DstPort[DP_USB] = ra_dev_get_by_name("eth1"); // USB interface name + #endif // CONFIG_RA_HW_NAT_NIC_USB // + } else { +- +- +-#if defined (CONFIG_RA_HW_NAT_WIFI_NEW_ARCH) ++#if defined (CONFIG_RA_HW_NAT_WIFI_NEW_ARCH) ++ ++#if 1 ++ if (DstPort[DP_GMAC]) dev_put(DstPort[DP_GMAC]); ++ if (DstPort[DP_GMAC2]) dev_put(DstPort[DP_GMAC2]); ++#else + + int j = 0; + for (j=0; j<MAX_IF_NUM; j++){ +@@ -3627,9 +3632,9 @@ static void PpeSetDstPort(uint32_t Ebl) + DstPort[j] = NULL; + } + } +-#endif +- +- ++#endif ++#endif ++ + #if !defined (CONFIG_RA_HW_NAT_WIFI_NEW_ARCH) + #if defined (CONFIG_RA_HW_NAT_WIFI) + if (DstPort[DP_RA0] != NULL) { +@@ -3943,15 +3948,7 @@ static void SetAclFwd(uint32_t Ebl) + + if(Ebl){ + #if defined (CONFIG_SUPPORT_OPENWRT) +-#if defined (CONFIG_RAETH_SPECIAL_TAG) +-#if defined (CONFIG_WAN_AT_P4) +- WanInt = ra_dev_get_by_name("eth0.5"); +-#else +- WanInt = ra_dev_get_by_name("eth0.1"); +-#endif +-#else +- WanInt = ra_dev_get_by_name("eth0.2"); +-#endif ++ WanInt = ra_dev_get_by_name("eth1") + #else + #if defined (CONFIG_RAETH_SPECIAL_TAG) + #if defined (CONFIG_WAN_AT_P4) +@@ -3963,7 +3960,7 @@ static void SetAclFwd(uint32_t Ebl) + WanInt = ra_dev_get_by_name("eth2.2"); + #endif + #endif +- LanInt = ra_dev_get_by_name("br0"); ++ LanInt = ra_dev_get_by_name("br-lan"); + for(i = 0;i< 6;i++){ + value = RegRead(RALINK_ETH_SW_BASE + 0x2004 + (i * 0x100)); + value |= (0x1 << 10); +Index: linux-3.10.20/net/nat/hw_nat/Kconfig +=================================================================== +--- linux-3.10.20.orig/net/nat/hw_nat/Kconfig ++++ linux-3.10.20/net/nat/hw_nat/Kconfig +@@ -370,11 +370,10 @@ config PPE_MCAST + config RA_HW_NAT_WIFI + bool "WiFi Acceleration" + depends on RA_HW_NAT +- select RA_HW_NAT_WIFI_NEW_ARCH if CHIP_MT7615E + + config RA_HW_NAT_WIFI_NEW_ARCH +- bool "WiFi Acceleration New Architecture" +- depends on RA_HW_NAT_WIFI && CHIP_MT7615E ++ bool "WiFi Acceleration New Architecture (7615 only)" ++ depends on RA_HW_NAT_WIFI + + config RA_HW_NAT_NIC_USB + bool "PCIe Ethernet NIC/USB Acceleration" +Index: linux-3.10.20/net/nat/hw_nat/Makefile +=================================================================== +--- linux-3.10.20.orig/net/nat/hw_nat/Makefile ++++ linux-3.10.20/net/nat/hw_nat/Makefile +@@ -23,3 +23,6 @@ ifeq ($(CONFIG_RAETH_GMAC2),y) + EXTRA_CFLAGS += -DCONFIG_PSEUDO_SUPPORT + endif + ++# support wifi hwnat in openwrt ++EXTRA_CFLAGS += -DCONFIG_MBSS_SUPPORT -DCONFIG_RTDEV ++ diff --git a/target/linux/mediatek/patches/1015-switch-vlan.patch b/target/linux/mediatek/patches/1015-switch-vlan.patch new file mode 100644 index 0000000..5b86a50 --- /dev/null +++ b/target/linux/mediatek/patches/1015-switch-vlan.patch @@ -0,0 +1,71 @@ +Index: linux-3.10.20/drivers/net/raeth/raether.c +=================================================================== +--- linux-3.10.20.orig/drivers/net/raeth/raether.c ++++ linux-3.10.20/drivers/net/raeth/raether.c +@@ -5738,21 +5738,26 @@ void LANWANPartition(void) + mii_mgr_write(31, 0x2204, 0xff0003);//port2 + mii_mgr_write(31, 0x2304, 0xff0003);//port3 + mii_mgr_write(31, 0x2404, 0xff0003);//port4 ++ mii_mgr_write(31, 0x2504, 0xff0003);//port5 ++ mii_mgr_write(31, 0x2604, 0xff0003);//port6 + + /*set PVID*/ + mii_mgr_write(31, 0x2014, 0x10002);//port0 ++ /* + mii_mgr_write(31, 0x2114, 0x10001);//port1 + mii_mgr_write(31, 0x2214, 0x10001);//port2 + mii_mgr_write(31, 0x2314, 0x10001);//port3 + mii_mgr_write(31, 0x2414, 0x10001);//port4 +- /*port6 */ ++ */ ++ mii_mgr_write(31, 0x2514, 0x10001);//port5 ++ + /*VLAN member*/ + IsSwitchVlanTableBusy(); +- mii_mgr_write(31, 0x94, 0x407e0001);//VAWD1 ++ mii_mgr_write(31, 0x94, 0x40de0001);//VAWD1 + mii_mgr_write(31, 0x90, 0x80001001);//VTCR, VID=1 + IsSwitchVlanTableBusy(); + +- mii_mgr_write(31, 0x94, 0x40610001);//VAWD1 ++ mii_mgr_write(31, 0x94, 0x40210001);//VAWD1 + mii_mgr_write(31, 0x90, 0x80001002);//VTCR, VID=2 + IsSwitchVlanTableBusy(); + #endif +@@ -5765,20 +5770,25 @@ void LANWANPartition(void) + mii_mgr_write(31, 0x2204, 0xff0003);//port2 + mii_mgr_write(31, 0x2304, 0xff0003);//port3 + mii_mgr_write(31, 0x2404, 0xff0003);//port4 ++ mii_mgr_write(31, 0x2504, 0xff0003);//port5 ++ mii_mgr_write(31, 0x2604, 0xff0003);//port6 + + /*set PVID*/ + mii_mgr_write(31, 0x2014, 0x10001);//port0 ++ /* + mii_mgr_write(31, 0x2114, 0x10001);//port1 + mii_mgr_write(31, 0x2214, 0x10001);//port2 + mii_mgr_write(31, 0x2314, 0x10001);//port3 + mii_mgr_write(31, 0x2414, 0x10002);//port4 ++ */ ++ mii_mgr_write(31, 0x2514, 0x10002);//port5 + + /*VLAN member*/ + IsSwitchVlanTableBusy(); +- mii_mgr_write(31, 0x94, 0x404f0001);//VAWD1 ++ mii_mgr_write(31, 0x94, 0x40cf0001);//VAWD1 + mii_mgr_write(31, 0x90, 0x80001001);//VTCR, VID=1 + IsSwitchVlanTableBusy(); +- mii_mgr_write(31, 0x94, 0x40500001);//VAWD1 ++ mii_mgr_write(31, 0x94, 0x40300001);//VAWD1 + mii_mgr_write(31, 0x90, 0x80001002);//VTCR, VID=2 + IsSwitchVlanTableBusy(); + #endif +@@ -6040,7 +6050,7 @@ void setup_internal_gsw(void) + #endif + + +- LANWANPartition(); ++ LANWANPartition(); + mt7530_phy_setting(); + for(i=0;i<=4;i++) + { diff --git a/target/linux/mediatek/patches/1016-nand-controller-busy.patch b/target/linux/mediatek/patches/1016-nand-controller-busy.patch new file mode 100644 index 0000000..9ffca2e --- /dev/null +++ b/target/linux/mediatek/patches/1016-nand-controller-busy.patch @@ -0,0 +1,38 @@ +Index: linux-3.10.20/drivers/mtd/ralink/ralink_nand.c +=================================================================== +--- linux-3.10.20.orig/drivers/mtd/ralink/ralink_nand.c ++++ linux-3.10.20/drivers/mtd/ralink/ralink_nand.c +@@ -377,7 +377,10 @@ static int nfc_check_wp(void) + int ret; + + ret = _nfc_read_status(&result); +- //FIXME, if ret < 0 ++ if (ret) { ++ printk(KERN_WARNING "unable to tell WP. default FALSE.\n"); ++ return 0; ++ } + + return !(result & NAND_STATUS_WP); + #endif +@@ -1332,10 +1335,9 @@ nand_get_device(struct ra_nand_chip *ra, + int ret = 0; + + #if !defined (__UBOOT__) +- ret = mutex_lock_interruptible(ra->controller); ++ mutex_lock(ra->controller); + #endif /// +- if (!ret) +- ra->state = new_state; ++ ra->state = new_state; + + return ret; + +@@ -2881,7 +2883,7 @@ static int ramtd_nand_writeoob(struct mt + + ra_dbg("%s: \n", __func__); + +- nand_get_device(ra, FL_READING); ++ nand_get_device(ra, FL_WRITING); + + ret = nand_do_write_ops(ra, to, ops); + diff --git a/target/linux/mediatek/patches/1017-disable-brcm-eth-drv.patch b/target/linux/mediatek/patches/1017-disable-brcm-eth-drv.patch new file mode 100644 index 0000000..6d51c72 --- /dev/null +++ b/target/linux/mediatek/patches/1017-disable-brcm-eth-drv.patch @@ -0,0 +1,13 @@ +Index: linux-3.10.20/drivers/net/ethernet/Kconfig +=================================================================== +--- linux-3.10.20.orig/drivers/net/ethernet/Kconfig ++++ linux-3.10.20/drivers/net/ethernet/Kconfig +@@ -26,7 +26,7 @@ source "drivers/net/ethernet/apple/Kconf + source "drivers/net/ethernet/atheros/Kconfig" + source "drivers/net/ethernet/cadence/Kconfig" + source "drivers/net/ethernet/adi/Kconfig" +-source "drivers/net/ethernet/broadcom/Kconfig" ++#source "drivers/net/ethernet/broadcom/Kconfig" + source "drivers/net/ethernet/brocade/Kconfig" + source "drivers/net/ethernet/calxeda/Kconfig" + source "drivers/net/ethernet/chelsio/Kconfig" diff --git a/target/linux/mediatek/patches/1019-fix-wifi-forward-crash.patch b/target/linux/mediatek/patches/1019-fix-wifi-forward-crash.patch new file mode 100644 index 0000000..449be43 --- /dev/null +++ b/target/linux/mediatek/patches/1019-fix-wifi-forward-crash.patch @@ -0,0 +1,25 @@ +Index: linux-3.10.20/drivers/net/wireless/wifi_forward/wifi_fwd/wifi_fwd.c +=================================================================== +--- linux-3.10.20.orig/drivers/net/wireless/wifi_forward/wifi_fwd/wifi_fwd.c ++++ linux-3.10.20/drivers/net/wireless/wifi_forward/wifi_fwd/wifi_fwd.c +@@ -2473,6 +2473,9 @@ static int wifi_fwd_rx_handler(struct sk + unsigned int recv_from = 0, band_from = 0, ret = 0; + int idx = 0; + ++ if (mh == NULL || skb == NULL) { ++ return 1; ++ } + net_dev = skb->dev; + recv_from = WIFI_FWD_GET_PACKET_RECV_FROM(skb, recv_from_cb_offset); + band_from = WIFI_FWD_GET_PACKET_BAND(skb, band_cb_offset); +@@ -2506,6 +2509,10 @@ static int wifi_fwd_rx_handler(struct sk + return 2; + } + } ++ ++ if (mh->h_dest == NULL || br_lan->dev_addr == NULL) { ++ return 1; ++ } + + /* forward the packet to bridge no matter unicast or broadcast */ + if (MAC_ADDR_EQUAL(mh->h_dest, br_lan->dev_addr)) diff --git a/target/linux/mediatek/patches/1020-mt7623-nand-jffs2-workaround.patch b/target/linux/mediatek/patches/1020-mt7623-nand-jffs2-workaround.patch new file mode 100644 index 0000000..c8ef619 --- /dev/null +++ b/target/linux/mediatek/patches/1020-mt7623-nand-jffs2-workaround.patch @@ -0,0 +1,42 @@ +Index: linux-3.10.20/drivers/misc/mediatek/nand/mt7623/mtk_nand.c +=================================================================== +--- linux-3.10.20.orig/drivers/misc/mediatek/nand/mt7623/mtk_nand.c ++++ linux-3.10.20/drivers/misc/mediatek/nand/mt7623/mtk_nand.c +@@ -6247,8 +6247,9 @@ static int mtk_nand_probe(struct platfor + nand_chip->write_page = mtk_nand_write_page; + nand_chip->read_page = mtk_nand_read_page; + nand_chip->read_subpage = mtk_nand_read_subpage; +- nand_chip->ecc.write_oob = mtk_nand_write_oob; +- nand_chip->ecc.read_oob = mtk_nand_read_oob; ++ /* OpenWrt: disable oob API, otherwise jffs2 will messing it. */ ++ nand_chip->ecc.write_oob = NULL; // mtk_nand_write_oob; ++ nand_chip->ecc.read_oob = NULL; // mtk_nand_read_oob; + nand_chip->block_markbad = mtk_nand_block_markbad; // need to add nand_get_device()/nand_release_device(). + nand_chip->erase = mtk_nand_erase; + nand_chip->block_bad = mtk_nand_block_bad; +@@ -6596,7 +6597,7 @@ static int mtk_nand_probe(struct platfor + part_init_pmt(mtd, (u8 *) & g_exist_Partition[0]); + err = mtd_device_register(mtd, g_exist_Partition, part_num); + #else +- err = mtd_device_register(mtd, g_pasStatic_Partition, 6); ++ err = mtd_device_register(mtd, g_pasStatic_Partition, 7); + #endif + + #ifdef _MTK_NAND_DUMMY_DRIVER_ +Index: linux-3.10.20/drivers/misc/mediatek/nand/mt7623/partition_mt.c +=================================================================== +--- linux-3.10.20.orig/drivers/misc/mediatek/nand/mt7623/partition_mt.c ++++ linux-3.10.20/drivers/misc/mediatek/nand/mt7623/partition_mt.c +@@ -83,7 +83,11 @@ struct mtd_partition g_pasStatic_Partiti + offset: MTDPART_OFS_APPEND + }, { + name: "firmware", +- size: MTDPART_SIZ_FULL, ++ size: 0xe000000, // FIXME: size here should be revised for nand chips of different sizes. ++ offset: MTDPART_OFS_APPEND ++ }, { ++ name: "bmt", // reserve bmt area for bad block remapping ++ size: MTDPART_SIZ_FULL, // not less than BMT pool size!!! + offset: MTDPART_OFS_APPEND + } + }; |