Changeset 12415

Show
Ignore:
Timestamp:
06/30/09 17:02:18 (5 months ago)
Author:
BrainSlayer
Message:

latest adm5120 update incl. remap patch

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • src/linux/adm5120/linux-2.6.23/.config

    r11895 r12415  
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.24.111 
    4 # Mon Apr  6 11:23:59 2009 
     4# Tue Jun 30 13:35:08 2009 
    55# 
    66CONFIG_MIPS=y 
     
    686686# CONFIG_IMQ_BEHAVIOR_BB is not set 
    687687CONFIG_IMQ_NUM_DEVS=2 
    688 # CONFIG_TUN is not set 
     688CONFIG_TUN=y 
    689689# CONFIG_ARCNET is not set 
    690690# CONFIG_PHYLIB is not set 
  • src/linux/adm5120/linux-2.6.23/.config_full

    r11405 r12415  
    685685# CONFIG_IMQ_BEHAVIOR_BB is not set 
    686686CONFIG_IMQ_NUM_DEVS=2 
    687 # CONFIG_TUN is not set 
     687CONFIG_TUN=y 
    688688# CONFIG_ARCNET is not set 
    689689# CONFIG_PHYLIB is not set 
  • src/linux/adm5120/linux-2.6.23/.config_np28g

    r11405 r12415  
    685685# CONFIG_IMQ_BEHAVIOR_BB is not set 
    686686CONFIG_IMQ_NUM_DEVS=2 
    687 # CONFIG_TUN is not set 
     687CONFIG_TUN=y 
    688688# CONFIG_ARCNET is not set 
    689689# CONFIG_PHYLIB is not set 
  • src/linux/adm5120/linux-2.6.23/arch/mips/Makefile

    r10172 r12415  
    8484cflags-y                        += -msoft-float 
    8585LDFLAGS_vmlinux                 += -G 0 -static -n -nostdlib 
    86 MODFLAGS                        += -mlong-calls 
     86MODFLAGS                        += -mno-long-calls 
    8787 
    8888cflags-y += -ffreestanding 
  • src/linux/adm5120/linux-2.6.23/arch/mips/adm5120/boards/compex.c

    r11371 r12415  
    8181 
    8282unsigned char wp54_vlans[6] __initdata = { 
    83         0x41, 0x42, 0x00, 0x00, 0x00, 0x00 
     83        0x41, 0x42, 0x44, 0x48, 0x50, 0x00 
    8484}; 
    8585 
     
    171171        .board_setup    = wp54_setup, 
    172172        .board_reset    = wp54_reset, 
    173         .eth_num_ports  = 2
     173        .eth_num_ports  = 5
    174174        .eth_vlans      = wp54_vlans, 
    175175        .num_devices    = ARRAY_SIZE(wp54_devices), 
     
    182182        .board_setup    = wp54_setup, 
    183183        .board_reset    = wp54_reset, 
    184         .eth_num_ports  = 2
     184        .eth_num_ports  = 5
    185185        .eth_vlans      = wp54_vlans, 
    186186        .num_devices    = ARRAY_SIZE(wp54_devices), 
     
    193193        .board_setup    = wp54_wrt_setup, 
    194194        .board_reset    = wp54_reset, 
    195         .eth_num_ports  = 2
     195        .eth_num_ports  = 5
    196196        .eth_vlans      = wp54_vlans, 
    197197        .num_devices    = ARRAY_SIZE(wp54_devices), 
     
    204204        .board_setup    = wp54_setup, 
    205205        .board_reset    = wp54_reset, 
    206         .eth_num_ports  = 2
     206        .eth_num_ports  = 5
    207207        .eth_vlans      = wp54_vlans, 
    208208        .num_devices    = ARRAY_SIZE(wp54_devices), 
     
    215215        .board_setup    = wp54_setup, 
    216216        .board_reset    = wp54_reset, 
    217         .eth_num_ports  = 2
    218         .eth_vlans      = wp54_vlans, 
    219         .num_devices    = ARRAY_SIZE(wp54_devices), 
    220         .devices        = wp54_devices, 
    221         .pci_nr_irqs    = ARRAY_SIZE(wp54_pci_irqs), 
    222         .pci_irq_map    = wp54_pci_irqs, 
    223 ADM5120_BOARD_END 
     217        .eth_num_ports  = 5
     218        .eth_vlans      = wp54_vlans, 
     219        .num_devices    = ARRAY_SIZE(wp54_devices), 
     220        .devices        = wp54_devices, 
     221        .pci_nr_irqs    = ARRAY_SIZE(wp54_pci_irqs), 
     222        .pci_irq_map    = wp54_pci_irqs, 
     223ADM5120_BOARD_END 
  • src/linux/adm5120/linux-2.6.23/arch/mips/adm5120/proc_gpio.c

    r11371 r12415  
    154154    int gpiocount; 
    155155 
    156     gpiocount = 8
     156    gpiocount = 22
    157157 
    158158    /* create directory gpio */ 
  • src/linux/adm5120/linux-2.6.23/arch/mips/kernel/module.c

    r10172 r12415  
    3030#include <linux/module.h> 
    3131#include <linux/spinlock.h> 
     32#include <linux/mm.h> 
    3233#include <asm/pgtable.h>        /* MODULE_START */ 
    3334 
     
    4344static DEFINE_SPINLOCK(dbe_lock); 
    4445 
     46static void *alloc_phys(unsigned long size) 
     47{ 
     48        unsigned order; 
     49        struct page *page; 
     50        struct page *p; 
     51 
     52        size = PAGE_ALIGN(size); 
     53        order = get_order(size); 
     54 
     55        page = alloc_pages( 
     56                GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN | __GFP_THISNODE, 
     57                order); 
     58        if (!page) 
     59                return 0; 
     60 
     61        split_page(page, order); 
     62 
     63        for (p = page + (size >> PAGE_SHIFT); p < page + (1 << order); ++p) 
     64                __free_page(p); 
     65 
     66        return page_address(page); 
     67} 
     68 
     69static void free_phys(void *ptr, unsigned long size) 
     70{ 
     71        struct page *page; 
     72        struct page *end; 
     73 
     74        page = virt_to_page(ptr); 
     75        end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT); 
     76 
     77        for (; page < end; ++page) 
     78                __free_pages(page, 0); 
     79} 
     80 
    4581void *module_alloc(unsigned long size) 
    4682{ 
     
    5894        return __vmalloc_area(area, GFP_KERNEL, PAGE_KERNEL); 
    5995#else 
     96        unsigned addr; 
     97        void *ptr; 
     98 
     99        size = PAGE_ALIGN(size); 
    60100        if (size == 0) 
    61101                return NULL; 
    62         return vmalloc(size); 
     102 
     103        ptr = alloc_phys(size); 
     104        if (ptr) 
     105                return ptr; 
     106 
     107        /* try to allocate contiguos chunk of memory not spanning 256Mb 
     108           range, so all jump instructions can work */ 
     109        addr = VMALLOC_START; 
     110        while (addr < VMALLOC_END) { 
     111                unsigned end = ALIGN(addr + 1, 1u << 28); 
     112 
     113                if (addr + size <= end) { 
     114                        struct vm_struct *area 
     115                                = __get_vm_area(size, VM_ALLOC, addr, end); 
     116 
     117                        if (area) 
     118                                return __vmalloc_area( 
     119                                        area, GFP_KERNEL, PAGE_KERNEL); 
     120                } 
     121                addr = end; 
     122        } 
     123        return NULL; 
    63124#endif 
     125} 
     126 
     127static inline int is_phys(void *ptr) 
     128{ 
     129        unsigned addr = (unsigned) ptr; 
     130        return addr && (addr < VMALLOC_START || addr > VMALLOC_END); 
    64131} 
    65132 
     
    67134void module_free(struct module *mod, void *module_region) 
    68135{ 
     136        if (is_phys(module_region)) { 
     137                if (mod->module_init == module_region) 
     138                        free_phys(module_region, mod->init_size); 
     139                else if (mod->module_core == module_region) 
     140                        free_phys(module_region, mod->core_size); 
     141                else 
     142                    BUG(); 
     143                return; 
     144        } 
     145 
    69146        vfree(module_region); 
    70147        /* FIXME: If module_region == mod->init_region, trim exception 
     
    78155} 
    79156 
     157/* Get the potential trampolines size required of the init and 
     158   non-init sections */ 
     159static unsigned get_plt_size(const Elf32_Ehdr *hdr, 
     160                             const Elf32_Shdr *sechdrs, 
     161                             const char *secstrings, 
     162                             unsigned symindex, 
     163                             int is_init) 
     164{ 
     165        unsigned long ret = 0; 
     166        unsigned i, j; 
     167        Elf_Sym *syms; 
     168 
     169        /* Everything marked ALLOC (this includes the exported symbols) */ 
     170        for (i = 1; i < hdr->e_shnum; ++i) { 
     171                unsigned int info = sechdrs[i].sh_info; 
     172 
     173                if (sechdrs[i].sh_type != SHT_REL 
     174                    && sechdrs[i].sh_type != SHT_RELA) 
     175                        continue; 
     176 
     177                /* Not a valid relocation section? */ 
     178                if (info >= hdr->e_shnum) 
     179                        continue; 
     180 
     181                /* Don't bother with non-allocated sections */ 
     182                if (!(sechdrs[info].sh_flags & SHF_ALLOC)) 
     183                        continue; 
     184 
     185                /* If it's called *.init*, and we're not init, we're 
     186                   not interested */ 
     187                if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != 0) 
     188                    != is_init) 
     189                        continue; 
     190 
     191                syms = (Elf_Sym *) sechdrs[symindex].sh_addr; 
     192                if (sechdrs[i].sh_type == SHT_REL) { 
     193                        Elf_Mips_Rel *rel = (void *) sechdrs[i].sh_addr; 
     194                        unsigned size = sechdrs[i].sh_size / sizeof(*rel); 
     195 
     196                        for (j = 0; j < size; ++j) { 
     197                                Elf_Sym *sym; 
     198 
     199                                if (ELF_MIPS_R_TYPE(rel[j]) != R_MIPS_26) 
     200                                        continue; 
     201                                sym = syms + ELF_MIPS_R_SYM(rel[j]); 
     202                                if (!is_init && sym->st_shndx != SHN_UNDEF) 
     203                                        continue; 
     204 
     205                                ret += sizeof(unsigned[4]); 
     206                        } 
     207                } else { 
     208                        Elf_Mips_Rela *rela = (void *) sechdrs[i].sh_addr; 
     209                        unsigned size = sechdrs[i].sh_size / sizeof(*rela); 
     210 
     211                        for (j = 0; j < size; ++j) { 
     212                                Elf_Sym *sym; 
     213 
     214                                if (ELF_MIPS_R_TYPE(rela[j]) != R_MIPS_26) 
     215                                        continue; 
     216                                sym = syms + ELF_MIPS_R_SYM(rela[j]); 
     217                                if (!is_init && sym->st_shndx != SHN_UNDEF) 
     218                                        continue; 
     219 
     220                                ret += sizeof(unsigned[4]); 
     221                        } 
     222                } 
     223 
     224        } 
     225 
     226        return ret; 
     227} 
     228 
     229int module_relayout(Elf32_Ehdr *hdr, 
     230                    Elf32_Shdr *sechdrs, 
     231                    char *secstrings, 
     232                    unsigned symindex, 
     233                    struct module *me) 
     234{ 
     235        unsigned core_plt_size = get_plt_size( 
     236            hdr, sechdrs, secstrings, symindex, 0); 
     237        unsigned init_plt_size = get_plt_size( 
     238            hdr, sechdrs, secstrings, symindex, 1); 
     239 
     240        if (core_plt_size > 0) 
     241                me->core_size = PAGE_ALIGN(me->core_size); 
     242        me->arch.core_plt_offset = me->core_size; 
     243        me->core_size = me->core_size + core_plt_size; 
     244 
     245        me->arch.init_plt_offset = me->init_size; 
     246        me->init_size = me->init_size + init_plt_size; 
     247 
     248        return 0; 
     249} 
     250 
    80251static int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v) 
    81252{ 
     
    94265        *location = v; 
    95266 
     267        return 0; 
     268} 
     269 
     270static Elf_Addr add_plt_entry_to(unsigned *plt_offset, 
     271                                 void *start, unsigned size, Elf_Addr v) 
     272{ 
     273        unsigned *tramp = start + *plt_offset; 
     274        if (*plt_offset == size) return 0; 
     275 
     276        *plt_offset += sizeof(unsigned[4]); 
     277 
     278        /* adjust carry for addiu */ 
     279        if (v & 0x00008000)  
     280                v += 0x10000; 
     281         
     282        tramp[0] = 0x3c190000 | (v >> 16);      /* lui t9, hi16 */ 
     283        tramp[1] = 0x27390000 | (v & 0xffff);   /* addiu t9, t9, lo16 */ 
     284        tramp[2] = 0x03200008;                  /* jr t9 */ 
     285        tramp[3] = 0x00000000;                  /* nop */ 
     286         
     287        return (Elf_Addr) tramp; 
     288} 
     289 
     290static Elf_Addr add_plt_entry(struct module *me, void *location, Elf_Addr v) 
     291{ 
     292        if (location >= me->module_core 
     293            && location < me->module_core + me->core_size) { 
     294                return add_plt_entry_to(&me->arch.core_plt_offset, 
     295                                        me->module_core, me->core_size, v); 
     296        } else if (location > me->module_init 
     297                   && location < me->module_init + me->init_size) { 
     298                return add_plt_entry_to(&me->arch.init_plt_offset, 
     299                                        me->module_init, me->init_size, v); 
     300        } else { 
     301                printk(KERN_ERR "module %s: " 
     302                       "relocation to unknown segment %u\n", 
     303                       me->name, v); 
     304        } 
    96305        return 0; 
    97306} 
     
    105314 
    106315        if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) { 
     316                v = add_plt_entry(me, location, 
     317                                  v + ((*location & 0x03ffffff) << 2)); 
     318                if (v == 0) { 
    107319                printk(KERN_ERR 
    108320                       "module %s: relocation overflow\n", 
     
    110322                return -ENOEXEC; 
    111323        } 
     324                *location = (*location & ~0x03ffffff) | 
     325                            ((v >> 2) & 0x03ffffff); 
     326                return 0; 
     327        } 
    112328 
    113329        *location = (*location & ~0x03ffffff) | 
     
    125341 
    126342        if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) { 
     343                v = add_plt_entry(me, location, v); 
     344                if (v == 0) { 
    127345                printk(KERN_ERR 
    128346                       "module %s: relocation overflow\n", 
    129347                       me->name); 
    130348                return -ENOEXEC; 
     349        } 
    131350        } 
    132351 
     
    400619                spin_unlock_irq(&dbe_lock); 
    401620        } 
     621 
     622        if (me->arch.core_plt_offset < me->core_size 
     623            && PAGE_ALIGN(me->arch.core_plt_offset) == me->arch.core_plt_offset 
     624            && is_phys(me->module_core)) { 
     625                free_phys(me->module_core + me->arch.core_plt_offset, 
     626                          me->core_size - me->arch.core_plt_offset); 
     627                me->core_size = me->arch.core_plt_offset; 
     628        } 
    402629        return 0; 
    403630} 
  • src/linux/adm5120/linux-2.6.23/arch/mips/kernel/scall32-o32.S

    r10172 r12415  
    647647        sys     sys_ppoll               5 
    648648        sys     sys_unshare             1 
    649         sys     sys_splice              4 
     649        sys     sys_splice              6 
    650650        sys     sys_sync_file_range     7       /* 4305 */ 
    651651        sys     sys_tee                 4 
  • src/linux/adm5120/linux-2.6.23/arch/mips/kernel/vmlinux.lds.S

    r10172 r12415  
    135135    *(.bss) 
    136136    *(COMMON) 
    137   } 
     137    . = (ALIGN(_PAGE_SIZE) - .) < 8 ? ALIGN(_PAGE_SIZE) + 4 : . ; 
     138 } 
    138139  __bss_stop = .; 
    139140 
  • src/linux/adm5120/linux-2.6.23/arch/mips/mm/c-r4k.c

    r10172 r12415  
    914914                c->dcache.waybit = __ffs(dcache_size/c->dcache.ways); 
    915915 
     916#ifdef CONFIG_CPU_HAS_PREFETCH 
    916917                c->options |= MIPS_CPU_PREFETCH; 
     918#endif 
    917919                break; 
    918920        } 
  • src/linux/adm5120/linux-2.6.23/crypto/api.c

    r10172 r12415  
    394394        return ERR_PTR(err); 
    395395} 
    396 EXPORT_SYMBOL_GPL(crypto_alloc_base); 
     396EXPORT_SYMBOL(crypto_alloc_base); 
    397397  
    398398/* 
     
    422422} 
    423423 
    424 EXPORT_SYMBOL_GPL(crypto_free_tfm); 
     424EXPORT_SYMBOL(crypto_free_tfm); 
    425425 
    426426int crypto_alg_available(const char *name, u32 flags) 
  • src/linux/adm5120/linux-2.6.23/drivers/net/adm5120sw.c

    r11952 r12415  
    798798static inline void adm5120_if_napi_disable(struct net_device *dev) {} 
    799799#endif /* CONFIG_ADM5120_SWITCH_NAPI */ 
     800static void adm5120_if_set_multicast_list(struct net_device *dev); 
    800801 
    801802/* ------------------------------------------------------------------------ */ 
     803#define SW_DIS_SA_LEARN_MASK                                    0x0000003F 
    802804 
    803805static int adm5120_if_open(struct net_device *dev) 
     
    820822                sw_int_unmask(SWITCH_INTS_USED); 
    821823 
     824 
    822825        /* enable (additional) port */ 
    823826        t = sw_read_reg(SWITCH_REG_PORT_CONF0); 
     
    828831        sw_write_reg(SWITCH_REG_PORT_CONF0, t); 
    829832 
     833 
     834//wp54g patch 
     835        sw_write_reg(SWITCH_REG_PORT_CONF1, sw_read_reg(SWITCH_REG_PORT_CONF1) | SW_DIS_SA_LEARN_MASK); 
     836        adm5120_if_set_multicast_list(dev); 
     837        adm5120_write_mac(dev); 
     838/* 
     839//important: promisc mode 
     840#define SW_DIS_UN_SHIFT                                                 9 
     841#define SW_DIS_UN_MASK                                                  (0x3F << SW_DIS_UN_SHIFT) 
     842#define SW_DIS_MC_SHIFT                                                 16 
     843#define SW_DIS_MC_MASK                                                  (0x3F << SW_DIS_MC_SHIFT) 
     844#define SW_DIS_BC_SHIFT                                                 24 
     845#define SW_DIS_BC_MASK                                                  (0x3F << SW_DIS_BC_SHIFT) 
     846 
     847        if (dev->flags & IFF_PROMISC) { 
     848                printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", 
     849                        dev->name); 
     850                sw_write_reg(SWITCH_REG_CPUP_CONF, sw_read_reg(SWITCH_REG_CPUP_CONF) & ~(SW_DIS_BC_MASK | SW_DIS_MC_MASK | SW_DIS_UN_MASK)); 
     851        } else if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) { 
     852                sw_write_reg(SWITCH_REG_CPUP_CONF, sw_read_reg(SWITCH_REG_CPUP_CONF) & ~(SW_DIS_BC_MASK | SW_DIS_MC_MASK | SW_DIS_UN_MASK)); 
     853        } else { 
     854                sw_write_reg(SWITCH_REG_CPUP_CONF, (sw_read_reg(SWITCH_REG_CPUP_CONF) & ~(SW_DIS_BC_MASK | SW_DIS_UN_MASK)) | SW_DIS_MC_MASK); 
     855        } 
     856 
     857        // Sets the switch bridge mode 
     858        sw_write_reg(SWITCH_REG_CPUP_CONF, sw_read_reg(SWITCH_REG_CPUP_CONF) | CPUP_CONF_BTM); 
     859*/ 
    830860        netif_start_queue(dev); 
    831861 
     
    10751105 
    10761106        adm5120_nrdevs = adm5120_eth_num_ports; 
    1077         sw_write_reg(SWITCH_REG_PORT0_LED, 0x9); 
    1078         sw_write_reg(SWITCH_REG_PORT1_LED, 0x9); 
    1079         sw_write_reg(SWITCH_REG_PORT2_LED, 0x9); 
    1080         sw_write_reg(SWITCH_REG_PORT3_LED, 0x9); 
    1081         sw_write_reg(SWITCH_REG_PORT4_LED, 0x9); 
     1107        sw_write_reg(SWITCH_REG_PORT0_LED,(LED_MODE_LINK_ACT << LED0_MODE_SHIFT) | (LED_MODE_SPEED << LED1_MODE_SHIFT) | (LED_MODE_LINK << LED2_MODE_SHIFT)); 
     1108        sw_write_reg(SWITCH_REG_PORT1_LED,(LED_MODE_LINK_ACT << LED0_MODE_SHIFT) | (LED_MODE_SPEED << LED1_MODE_SHIFT) | (LED_MODE_LINK << LED2_MODE_SHIFT)); 
     1109        sw_write_reg(SWITCH_REG_PORT2_LED,(LED_MODE_LINK_ACT << LED0_MODE_SHIFT) | (LED_MODE_SPEED << LED1_MODE_SHIFT) | (LED_MODE_LINK << LED2_MODE_SHIFT)); 
     1110        sw_write_reg(SWITCH_REG_PORT3_LED,(LED_MODE_LINK_ACT << LED0_MODE_SHIFT) | (LED_MODE_SPEED << LED1_MODE_SHIFT) | (LED_MODE_LINK << LED2_MODE_SHIFT)); 
     1111        sw_write_reg(SWITCH_REG_PORT4_LED,(LED_MODE_LINK_ACT << LED0_MODE_SHIFT) | (LED_MODE_SPEED << LED1_MODE_SHIFT) | (LED_MODE_LINK << LED2_MODE_SHIFT)); 
    10821112 
    10831113        t = CPUP_CONF_DCPUP | CPUP_CONF_CRCP | 
     
    10851115                SWITCH_PORTS_NOCPU << CPUP_CONF_DMCP_SHIFT ; 
    10861116        sw_write_reg(SWITCH_REG_CPUP_CONF, t); 
     1117 
     1118 
     1119 
    10871120 
    10881121        t = (SWITCH_PORTS_NOCPU << PORT_CONF0_EMCP_SHIFT) | 
  • src/linux/adm5120/linux-2.6.23/include/asm-mips/module.h

    r10172 r12415  
    1010        const struct exception_table_entry *dbe_start; 
    1111        const struct exception_table_entry *dbe_end; 
     12 
     13        unsigned int core_plt_offset; 
     14        unsigned int init_plt_offset; 
    1215}; 
    1316 
     
    6669/* Given an address, look for it in the exception tables. */ 
    6770const struct exception_table_entry*search_module_dbetables(unsigned long addr); 
     71int module_relayout(Elf32_Ehdr *hdr, Elf32_Shdr *sechdrs, 
     72                    char *secstrings, unsigned symindex, struct module *me); 
    6873#else 
    6974/* Given an address, look for it in the exception tables. */ 
  • src/linux/adm5120/linux-2.6.23/include/asm-mips/string.h

    r10172 r12415  
    109109        ".set\tnoreorder\n\t" 
    110110        ".set\tnoat\n" 
    111         "1:\tlbu\t%3,(%0)\n\t" 
    112         "beqz\t%2,2f\n\t" 
     111        "1:\tbeqz\t%2,2f\n\t" 
     112        "nop\n\t" 
     113        "lbu\t%3,(%0)\n\t" 
    113114        "lbu\t$1,(%1)\n\t" 
    114115        "subu\t%2,1\n\t" 
  • src/linux/adm5120/linux-2.6.23/kernel/module.c

    r10172 r12415  
    17381738        layout_sections(mod, hdr, sechdrs, secstrings); 
    17391739 
     1740#ifdef __mips 
     1741        module_relayout(hdr, sechdrs, secstrings, symindex, mod); 
     1742#endif 
     1743 
    17401744        /* Do the allocs. */ 
    17411745        ptr = module_alloc(mod->core_size); 
  • src/linux/adm5120/linux-2.6.23/mm/page_alloc.c

    r10172 r12415  
    12651265 
    12661266        /* 
     1267         * Code in arch/mips/kernel/module.c wants physically 
     1268         * contiguous memory only if there is plenty of free of them. 
     1269         */ 
     1270        if ((gfp_mask & (__GFP_THISNODE | __GFP_NORETRY | __GFP_NOWARN)) 
     1271            == (__GFP_THISNODE | __GFP_NORETRY | __GFP_NOWARN)) 
     1272                goto nopage; 
     1273 
     1274        /* 
    12671275         * GFP_THISNODE (meaning __GFP_THISNODE, __GFP_NORETRY and 
    12681276         * __GFP_NOWARN set) should not cause reclaim since the subsystem 
     
    12771285        for (z = zonelist->zones; *z; z++) 
    12781286                wakeup_kswapd(*z, order); 
     1287 
     1288        if (gfp_mask & 0x80000000) 
     1289            goto nopage; 
    12791290 
    12801291        /*