Changeset 18225


Ignore:
Timestamp:
01/19/12 17:29:10 (16 months ago)
Author:
BrainSlayer
Message:

arch code

Location:
src/linux/universal/linux-3.2/arch/mips/lantiq
Files:
36 added
4 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • src/linux/universal/linux-3.2/arch/mips/lantiq/Kconfig

    r18171 r18225  
    11if LANTIQ 
     2 
     3config LANTIQ_PCIE 
     4        bool 
    25 
    36config SOC_TYPE_XWAY 
    … …  
    1720        select SOC_TYPE_XWAY 
    1821        select HW_HAS_PCI 
     22 
     23config SOC_VR9 
     24        bool "VR9" 
     25        select SOC_TYPE_XWAY 
     26        select HW_HAS_PCI 
     27        select LANTIQ_PCIE 
     28 
     29config SOC_FALCON 
     30        bool "FALCON" 
    1931endchoice 
    2032 
     33config AR9 
     34        bool "AR9 DSL Driver extensions" 
     35 
    2136source "arch/mips/lantiq/xway/Kconfig" 
     37source "arch/mips/lantiq/falcon/Kconfig" 
    2238 
    2339endif 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/Makefile

    r18171 r18225  
    55# by the Free Software Foundation. 
    66 
    7 obj-y := irq.o setup.o clk.o prom.o devices.o 
     7obj-y := irq.o setup.o clk.o prom.o devices.o dev-gpio-leds.o dev-gpio-buttons.o 
    88 
    99obj-$(CONFIG_EARLY_PRINTK) += early_printk.o 
    1010 
    1111obj-$(CONFIG_SOC_TYPE_XWAY) += xway/ 
     12obj-$(CONFIG_SOC_FALCON) += falcon/ 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/Platform

    r18171 r18225  
    77load-$(CONFIG_LANTIQ)           = 0xffffffff80002000 
    88cflags-$(CONFIG_SOC_TYPE_XWAY)  += -I$(srctree)/arch/mips/include/asm/mach-lantiq/xway 
     9cflags-$(CONFIG_SOC_TYPE_VR9)   += -I$(srctree)/arch/mips/include/asm/mach-lantiq/xway 
     10cflags-$(CONFIG_SOC_FALCON)     += -I$(srctree)/arch/mips/include/asm/mach-lantiq/falcon 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/clk.c

    r18171 r18225  
    2323 
    2424#include "clk.h" 
     25#include "prom.h" 
    2526 
    2627struct clk { 
    … …  
    4647        }, 
    4748}; 
    48  
    49 static struct resource ltq_cgu_resource = { 
    50         .name   = "cgu", 
    51         .start  = LTQ_CGU_BASE_ADDR, 
    52         .end    = LTQ_CGU_BASE_ADDR + LTQ_CGU_SIZE - 1, 
    53         .flags  = IORESOURCE_MEM, 
    54 }; 
    55  
    56 /* remapped clock register range */ 
    57 void __iomem *ltq_cgu_membase; 
    5849 
    5950void clk_init(void) 
    … …  
    134125        struct clk *clk; 
    135126 
    136         if (insert_resource(&iomem_resource, &ltq_cgu_resource) < 0) 
    137                 panic("Failed to insert cgu memory\n"); 
     127        ltq_soc_init(); 
    138128 
    139         if (request_mem_region(ltq_cgu_resource.start, 
    140                         resource_size(&ltq_cgu_resource), "cgu") < 0) 
    141                 panic("Failed to request cgu memory\n"); 
    142  
    143         ltq_cgu_membase = ioremap_nocache(ltq_cgu_resource.start, 
    144                                 resource_size(&ltq_cgu_resource)); 
    145         if (!ltq_cgu_membase) { 
    146                 pr_err("Failed to remap cgu memory\n"); 
    147                 unreachable(); 
    148         } 
    149129        clk = clk_get(0, "cpu"); 
    150130        mips_hpt_frequency = clk_get_rate(clk) / ltq_get_counter_resolution(); 
    151131        write_c0_compare(read_c0_count()); 
     132        pr_info("CPU Clock: %ldMHz\n", clk_get_rate(clk) / 1000000); 
    152133        clk_put(clk); 
    153134} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/devices.c

    r18171 r18225  
    1919#include <linux/io.h> 
    2020#include <linux/gpio.h> 
     21#include <linux/dma-mapping.h> 
    2122 
    2223#include <asm/bootinfo.h> 
    … …  
    2829 
    2930/* nor flash */ 
    30 static struct resource ltq_nor_resource = { 
    31         .name   = "nor", 
    32         .start  = LTQ_FLASH_START, 
    33         .end    = LTQ_FLASH_START + LTQ_FLASH_MAX - 1, 
    34         .flags  = IORESOURCE_MEM, 
    35 }; 
     31static struct resource ltq_nor_resource = 
     32        MEM_RES("nor", LTQ_FLASH_START, LTQ_FLASH_MAX); 
    3633 
    3734static struct platform_device ltq_nor = { 
    … …  
    4845 
    4946/* watchdog */ 
    50 static struct resource ltq_wdt_resource = { 
    51         .name   = "watchdog", 
    52         .start  = LTQ_WDT_BASE_ADDR, 
    53         .end    = LTQ_WDT_BASE_ADDR + LTQ_WDT_SIZE - 1, 
    54         .flags  = IORESOURCE_MEM, 
    55 }; 
     47static struct resource ltq_wdt_resource = 
     48        MEM_RES("watchdog", LTQ_WDT_BASE_ADDR, LTQ_WDT_SIZE); 
    5649 
    5750void __init ltq_register_wdt(void) 
    … …  
    6255/* asc ports */ 
    6356static struct resource ltq_asc0_resources[] = { 
    64         { 
    65                 .name   = "asc0", 
    66                 .start  = LTQ_ASC0_BASE_ADDR, 
    67                 .end    = LTQ_ASC0_BASE_ADDR + LTQ_ASC_SIZE - 1, 
    68                 .flags  = IORESOURCE_MEM, 
    69         }, 
     57        MEM_RES("asc0", LTQ_ASC0_BASE_ADDR, LTQ_ASC_SIZE), 
    7058        IRQ_RES(tx, LTQ_ASC_TIR(0)), 
    7159        IRQ_RES(rx, LTQ_ASC_RIR(0)), 
    … …  
    7462 
    7563static struct resource ltq_asc1_resources[] = { 
    76         { 
    77                 .name   = "asc1", 
    78                 .start  = LTQ_ASC1_BASE_ADDR, 
    79                 .end    = LTQ_ASC1_BASE_ADDR + LTQ_ASC_SIZE - 1, 
    80                 .flags  = IORESOURCE_MEM, 
    81         }, 
     64        MEM_RES("asc1", LTQ_ASC1_BASE_ADDR, LTQ_ASC_SIZE), 
    8265        IRQ_RES(tx, LTQ_ASC_TIR(1)), 
    8366        IRQ_RES(rx, LTQ_ASC_RIR(1)), 
    … …  
    119102} 
    120103#endif 
     104 
     105static unsigned int *cp1_base = 0; 
     106unsigned int* 
     107ltq_get_cp1_base(void) 
     108{ 
     109        return cp1_base; 
     110} 
     111EXPORT_SYMBOL(ltq_get_cp1_base); 
     112 
     113void __init 
     114ltq_register_tapi(void) 
     115{ 
     116#define CP1_SIZE       (1 << 20) 
     117        dma_addr_t dma; 
     118        cp1_base = 
     119                (void*)CPHYSADDR(dma_alloc_coherent(NULL, CP1_SIZE, &dma, GFP_ATOMIC)); 
     120} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/devices.h

    r18171 r18225  
    1515#define IRQ_RES(resname, irq) \ 
    1616        {.name = #resname, .start = (irq), .flags = IORESOURCE_IRQ} 
     17#define MEM_RES(resname, adr_start, adr_size) \ 
     18        { .name = resname, .flags = IORESOURCE_MEM, \ 
     19          .start = ((adr_start) & ~KSEG1), \ 
     20          .end = ((adr_start + adr_size - 1) & ~KSEG1) } 
    1721 
    1822extern void ltq_register_nor(struct physmap_flash_data *data); 
    … …  
    2024extern void ltq_register_asc(int port); 
    2125extern void ltq_register_pci(struct ltq_pci_data *data); 
     26extern void ltq_register_tapi(void); 
    2227 
    2328#endif 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/early_printk.c

    r18171 r18225  
    1313#include <lantiq_soc.h> 
    1414 
    15 /* no ioremap possible at this early stage, lets use KSEG1 instead  */ 
    16 #define LTQ_ASC_BASE    KSEG1ADDR(LTQ_ASC1_BASE_ADDR) 
    1715#define ASC_BUF         1024 
    18 #define LTQ_ASC_FSTAT   ((u32 *)(LTQ_ASC_BASE + 0x0048)) 
    19 #define LTQ_ASC_TBUF    ((u32 *)(LTQ_ASC_BASE + 0x0020)) 
     16#define LTQ_ASC_FSTAT   ((u32 *)(LTQ_EARLY_ASC + 0x0048)) 
     17#ifdef __BIG_ENDIAN 
     18#define LTQ_ASC_TBUF    ((u32 *)(LTQ_EARLY_ASC + 0x0020 + 3)) 
     19#else 
     20#define LTQ_ASC_TBUF    ((u32 *)(LTQ_EARLY_ASC + 0x0020)) 
     21#endif 
    2022#define TXMASK          0x3F00 
    2123#define TXOFFSET        8 
    … …  
    2830        do { } while ((ltq_r32(LTQ_ASC_FSTAT) & TXMASK) >> TXOFFSET); 
    2931        if (c == '\n') 
    30                 ltq_w32('\r', LTQ_ASC_TBUF); 
    31         ltq_w32(c, LTQ_ASC_TBUF); 
     32                ltq_w8('\r', LTQ_ASC_TBUF); 
     33        ltq_w8(c, LTQ_ASC_TBUF); 
    3234        local_irq_restore(flags); 
    3335} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/irq.c

    r18171 r18225  
    1010#include <linux/interrupt.h> 
    1111#include <linux/ioport.h> 
     12#include <linux/module.h> 
    1213 
    1314#include <asm/bootinfo.h> 
    … …  
    4142#define MAX_EIU                 6 
    4243 
     44/* the performance counter */ 
     45#define LTQ_PERF_IRQ            (INT_NUM_IM4_IRL0 + 31) 
     46 
    4347/* irqs generated by device attached to the EBU need to be acked in 
    4448 * a special manner 
    … …  
    100104        ltq_icu_w32((1 << irq_nr), isr); 
    101105} 
     106EXPORT_SYMBOL(ltq_mask_and_ack_irq); 
    102107 
    103108static void ltq_ack_irq(struct irq_data *d) 
    … …  
    196201 
    197202        /* if this is a EBU irq, we need to ack it or get a deadlock */ 
    198         if ((irq == LTQ_ICU_EBU_IRQ) && (module == 0)) 
     203        if ((irq == LTQ_ICU_EBU_IRQ) && (module == 0) && LTQ_EBU_PCC_ISTAT) 
    199204                ltq_ebu_w32(ltq_ebu_r32(LTQ_EBU_PCC_ISTAT) | 0x10, 
    200205                        LTQ_EBU_PCC_ISTAT); 
    … …  
    261266                panic("Failed to remap icu memory\n"); 
    262267 
    263         if (insert_resource(&iomem_resource, &ltq_eiu_resource) < 0) 
    264                 panic("Failed to insert eiu memory\n"); 
    265  
    266         if (request_mem_region(ltq_eiu_resource.start, 
    267                         resource_size(&ltq_eiu_resource), "eiu") < 0) 
    268                 panic("Failed to request eiu memory\n"); 
    269  
    270         ltq_eiu_membase = ioremap_nocache(ltq_eiu_resource.start, 
     268        if (LTQ_EIU_BASE_ADDR) { 
     269                if (insert_resource(&iomem_resource, &ltq_eiu_resource) < 0) 
     270                        panic("Failed to insert eiu memory\n"); 
     271 
     272                if (request_mem_region(ltq_eiu_resource.start, 
     273                                resource_size(&ltq_eiu_resource), "eiu") < 0) 
     274                        panic("Failed to request eiu memory\n"); 
     275 
     276                ltq_eiu_membase = ioremap_nocache(ltq_eiu_resource.start, 
    271277                                resource_size(&ltq_eiu_resource)); 
    272         if (!ltq_eiu_membase) 
    273                 panic("Failed to remap eiu memory\n"); 
     278                if (!ltq_eiu_membase) 
     279                        panic("Failed to remap eiu memory\n"); 
     280        } 
    274281 
    275282        /* make sure all irqs are turned off by default */ 
    … …  
    297304        for (i = INT_NUM_IRQ0; 
    298305                i <= (INT_NUM_IRQ0 + (5 * INT_NUM_IM_OFFSET)); i++) 
    299                 if ((i == LTQ_EIU_IR0) || (i == LTQ_EIU_IR1) || 
    300                         (i == LTQ_EIU_IR2)) 
     306                if (((i == LTQ_EIU_IR0) || (i == LTQ_EIU_IR1) || 
     307                        (i == LTQ_EIU_IR2)) && LTQ_EIU_BASE_ADDR) 
    301308                        irq_set_chip_and_handler(i, &ltq_eiu_type, 
    302309                                handle_level_irq); 
    … …  
    317324                IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5); 
    318325#endif 
     326 
     327        cp0_perfcount_irq = LTQ_PERF_IRQ; 
    319328} 
    320329 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/machtypes.h

    r18171 r18225  
    1616        LTQ_MACH_EASY50712,     /* Danube evaluation board */ 
    1717        LTQ_MACH_EASY50601,     /* Amazon SE evaluation board */ 
     18 
     19        /* FALCON */ 
     20        LANTIQ_MACH_EASY98000,          /* Falcon Eval Board, NOR Flash */ 
     21        LANTIQ_MACH_EASY98000SF,        /* Falcon Eval Board, Serial Flash */ 
     22        LANTIQ_MACH_EASY98000NAND,      /* Falcon Eval Board, NAND Flash */ 
     23        LANTIQ_MACH_EASY98020,          /* EASY98020 Eval Board */ 
     24        LANTIQ_MACH_EASY98020_1LAN,     /* EASY98020 Eval Board (1 LAN port) */ 
     25        LANTIQ_MACH_EASY98020_2LAN,     /* EASY98020 Eval Board (2 LAN port) */ 
     26        LANTIQ_MACH_95C3AM1,            /* 95C3AM1 Eval Board */ 
     27 
     28        /* FRITZ!BOX */ 
     29        LANTIQ_MACH_FRITZ3370,          /* FRITZ!BOX 3370 vdsl cpe */ 
     30 
     31        /* Arcadyan */ 
     32        LANTIQ_MACH_ARV3527P,           /* Arcor easybox a401 */ 
     33        LANTIQ_MACH_ARV4510PW,          /* Wippies Homebox */ 
     34        LANTIQ_MACH_ARV4518PW,          /* Airties WAV-221, SMC-7908A-ISP */ 
     35        LANTIQ_MACH_ARV4520PW,          /* Airties WAV-281, Arcor EasyboxA800 */ 
     36        LANTIQ_MACH_ARV452CPW,          /* Arcor EasyboxA801 */ 
     37        LANTIQ_MACH_ARV4525PW,          /* Speedport W502V */ 
     38        LANTIQ_MACH_ARV7525PW,          /* Speedport W303V */ 
     39        LANTIQ_MACH_ARV752DPW,          /* Arcor easybox a802 */ 
     40        LANTIQ_MACH_ARV752DPW22,        /* Arcor easybox a803 */ 
     41        LANTIQ_MACH_ARV7518PW,          /* ASTORIA */ 
     42 
     43        /* Netgear */ 
     44        LANTIQ_MACH_DGN3500B,           /* Netgear DGN3500 */ 
     45 
     46        /* Gigaset */ 
     47        LANTIQ_MACH_GIGASX76X,          /* Gigaset SX76x */ 
     48 
     49        /* Buffalo */ 
     50        LANTIQ_MACH_WBMR,               /* WBMR-HP-G300H */ 
    1851}; 
    1952 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/prom.c

    r18171 r18225  
    1616#include "prom.h" 
    1717#include "clk.h" 
     18 
     19/* access to the ebu needs to be locked between different drivers */ 
     20DEFINE_SPINLOCK(ebu_lock); 
     21EXPORT_SYMBOL_GPL(ebu_lock); 
    1822 
    1923static struct ltq_soc_info soc_info; 
    … …  
    4044} 
    4145 
     46#ifdef CONFIG_IMAGE_CMDLINE_HACK 
     47extern char __image_cmdline[]; 
     48 
     49static void __init 
     50prom_init_image_cmdline(void) 
     51{ 
     52        char *p = __image_cmdline; 
     53        int replace = 0; 
     54 
     55        if (*p == '-') { 
     56                replace = 1; 
     57                p++; 
     58        } 
     59 
     60        if (*p == '\0') 
     61                return; 
     62 
     63        if (replace) { 
     64                strlcpy(arcs_cmdline, p, sizeof(arcs_cmdline)); 
     65        } else { 
     66                strlcat(arcs_cmdline, " ", sizeof(arcs_cmdline)); 
     67                strlcat(arcs_cmdline, p, sizeof(arcs_cmdline)); 
     68        } 
     69} 
     70#else 
     71static void __init prom_init_image_cmdline(void) { return; } 
     72#endif 
     73 
    4274static void __init prom_init_cmdline(void) 
    4375{ 
    … …  
    4678        int i; 
    4779 
     80        arcs_cmdline[0] = '\0'; 
     81 
    4882        for (i = 0; i < argc; i++) { 
    49                 char *p = (char *)  KSEG1ADDR(argv[i]); 
     83                char *p = (char *) KSEG1ADDR(argv[i]); 
    5084 
    51                 if (p && *p) { 
     85                if (CPHYSADDR(p) && *p) { 
    5286                        strlcat(arcs_cmdline, p, sizeof(arcs_cmdline)); 
    5387                        strlcat(arcs_cmdline, " ", sizeof(arcs_cmdline)); 
    5488                } 
    5589        } 
     90        prom_init_image_cmdline(); 
     91} 
     92 
     93void __iomem *ltq_remap_resource(struct resource *res) 
     94{ 
     95        __iomem void *ret = NULL; 
     96        struct resource *lookup = lookup_resource(&iomem_resource, res->start); 
     97 
     98        if (lookup && strcmp(lookup->name, res->name)) { 
     99                panic("conflicting memory range %s\n", res->name); 
     100                return NULL; 
     101        } 
     102        if (!lookup) { 
     103                if (insert_resource(&iomem_resource, res) < 0) { 
     104                        panic("Failed to insert %s memory\n", res->name); 
     105                        return NULL; 
     106                } 
     107        } 
     108        if (request_mem_region(res->start, 
     109                        resource_size(res), res->name) < 0) { 
     110                panic("Failed to request %s memory\n", res->name); 
     111                goto err_res; 
     112        } 
     113 
     114        ret = ioremap_nocache(res->start, resource_size(res)); 
     115        if (!ret) 
     116                goto err_mem; 
     117 
     118        pr_debug("remap: 0x%08X-0x%08X : \"%s\"\n", 
     119                res->start, res->end, res->name); 
     120        return ret; 
     121 
     122err_mem: 
     123        panic("Failed to remap %s memory\n", res->name); 
     124        release_mem_region(res->start, resource_size(res)); 
     125 
     126err_res: 
     127        release_resource(res); 
     128        return NULL; 
    56129} 
    57130 
    58131void __init prom_init(void) 
    59132{ 
    60         struct clk *clk; 
    61  
    62133        ltq_soc_detect(&soc_info); 
    63134        clk_init(); 
    64         clk = clk_get(0, "cpu"); 
    65         snprintf(soc_info.sys_type, LTQ_SYS_TYPE_LEN - 1, "%s rev1.%d", 
    66                 soc_info.name, soc_info.rev); 
    67         clk_put(clk); 
     135        snprintf(soc_info.sys_type, LTQ_SYS_TYPE_LEN - 1, "%s rev %s", 
     136                soc_info.name, soc_info.rev_type); 
    68137        soc_info.sys_type[LTQ_SYS_TYPE_LEN - 1] = '\0'; 
    69138        pr_info("SoC: %s\n", soc_info.sys_type); 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/prom.h

    r18171 r18225  
    1010#define _LTQ_PROM_H__ 
    1111 
     12#define LTQ_SYS_REV_LEN         0x10 
    1213#define LTQ_SYS_TYPE_LEN        0x100 
    1314 
    … …  
    1516        unsigned char *name; 
    1617        unsigned int rev; 
     18        unsigned char rev_type[LTQ_SYS_REV_LEN]; 
     19        unsigned int srev; 
    1720        unsigned int partnum; 
    1821        unsigned int type; 
    … …  
    2124 
    2225extern void ltq_soc_detect(struct ltq_soc_info *i); 
     26extern void ltq_soc_init(void); 
    2327extern void ltq_soc_setup(void); 
    2428 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/setup.c

    r18171 r18225  
    1919#include "prom.h" 
    2020 
     21/* assume 16M as default incase uboot fails to pass proper ramsize */ 
     22unsigned long physical_memsize = 16L; 
     23 
    2124void __init plat_mem_setup(void) 
    2225{ 
    23         /* assume 16M as default incase uboot fails to pass proper ramsize */ 
    24         unsigned long memsize = 16; 
    2526        char **envp = (char **) KSEG1ADDR(fw_arg2); 
    2627 
    … …  
    3637                if (!strncmp(e, "memsize=", 8)) { 
    3738                        e += 8; 
    38                         if (strict_strtoul(e, 0, &memsize)) 
     39                        if (strict_strtoul(e, 0, &physical_memsize)) 
    3940                                pr_warn("bad memsize specified\n"); 
    4041                } 
    4142                envp++; 
    4243        } 
    43         memsize *= 1024 * 1024; 
    44         add_memory_region(0x00000000, memsize, BOOT_MEM_RAM); 
     44        physical_memsize *= 1024 * 1024; 
     45        add_memory_region(0x00000000, physical_memsize, BOOT_MEM_RAM); 
    4546} 
    4647 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/Kconfig

    r18171 r18225  
    55config LANTIQ_MACH_EASY50712 
    66        bool "Easy50712 - Danube" 
     7        default y 
     8 
     9config LANTIQ_MACH_ARV45XX 
     10        bool "ARV45XX" 
     11        default y 
     12 
     13config LANTIQ_MACH_NETGEAR 
     14        bool "Netgear" 
     15        default y 
     16 
     17config LANTIQ_MACH_GIGASX76X 
     18        bool "GIGASX76X" 
     19        default y 
     20 
     21config LANTIQ_MACH_WBMR 
     22        bool "WBMR-HP-G300H" 
    723        default y 
    824 
    … …  
    2238 
    2339endif 
     40 
     41if SOC_VR9 
     42 
     43menu "MIPS Machine" 
     44 
     45config LANTIQ_MACH_FRITZ3370 
     46        bool "Fritz!Box 3370" 
     47        default y 
     48 
     49endmenu 
     50 
     51endif 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/Makefile

    r18171 r18225  
    1 obj-y := pmu.o ebu.o reset.o gpio.o gpio_stp.o gpio_ebu.o devices.o dma.o 
     1obj-y := sysctrl.o reset.o gpio.o gpio_stp.o gpio_ebu.o devices.o dma.o nand.o timer.o 
    22 
    3 obj-$(CONFIG_SOC_XWAY) += clk-xway.o prom-xway.o setup-xway.o 
    4 obj-$(CONFIG_SOC_AMAZON_SE) += clk-ase.o prom-ase.o setup-ase.o 
     3obj-y += dev-dwc_otg.o dev-wifi-ath5k.o 
     4 
     5obj-$(CONFIG_SOC_XWAY) += clk-xway.o prom-xway.o 
     6obj-$(CONFIG_SOC_AMAZON_SE) += clk-ase.o prom-ase.o 
     7obj-$(CONFIG_SOC_VR9) += clk-vr9.o prom-vr9.o 
    58 
    69obj-$(CONFIG_LANTIQ_MACH_EASY50712) += mach-easy50712.o 
    710obj-$(CONFIG_LANTIQ_MACH_EASY50601) += mach-easy50601.o 
     11obj-$(CONFIG_LANTIQ_MACH_FRITZ3370) += mach-fritz.o 
     12obj-$(CONFIG_LANTIQ_MACH_ARV45XX) += mach-arv45xx.o 
     13obj-$(CONFIG_LANTIQ_MACH_NETGEAR) += mach-netgear.o 
     14obj-$(CONFIG_LANTIQ_MACH_GIGASX76X) += mach-gigasx76x.o 
     15obj-$(CONFIG_LANTIQ_MACH_WBMR) += mach-wbmr.o 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/clk-xway.c

    r18171 r18225  
    213213EXPORT_SYMBOL(ltq_get_cpu_hz); 
    214214 
     215unsigned int getCPUClock(void) 
     216{ 
     217    return ltq_get_cpu_hz()/1000000; 
     218} 
     219 
    215220unsigned int ltq_get_fpi_hz(void) 
    216221{ 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/devices.c

    r18171 r18225  
    2020#include <linux/io.h> 
    2121#include <linux/gpio.h> 
     22#include <linux/spi/spi.h> 
    2223 
    2324#include <asm/bootinfo.h> 
    … …  
    3233/* gpio */ 
    3334static struct resource ltq_gpio_resource[] = { 
    34         { 
    35                 .name   = "gpio0", 
    36                 .start  = LTQ_GPIO0_BASE_ADDR, 
    37                 .end    = LTQ_GPIO0_BASE_ADDR + LTQ_GPIO_SIZE - 1, 
    38                 .flags  = IORESOURCE_MEM, 
    39         }, { 
    40                 .name   = "gpio1", 
    41                 .start  = LTQ_GPIO1_BASE_ADDR, 
    42                 .end    = LTQ_GPIO1_BASE_ADDR + LTQ_GPIO_SIZE - 1, 
    43                 .flags  = IORESOURCE_MEM, 
    44         }, { 
    45                 .name   = "gpio2", 
    46                 .start  = LTQ_GPIO2_BASE_ADDR, 
    47                 .end    = LTQ_GPIO2_BASE_ADDR + LTQ_GPIO_SIZE - 1, 
    48                 .flags  = IORESOURCE_MEM, 
    49         } 
     35        MEM_RES("gpio0", LTQ_GPIO0_BASE_ADDR, LTQ_GPIO_SIZE), 
     36        MEM_RES("gpio1", LTQ_GPIO1_BASE_ADDR, LTQ_GPIO_SIZE), 
     37        MEM_RES("gpio2", LTQ_GPIO2_BASE_ADDR, LTQ_GPIO_SIZE), 
     38        MEM_RES("gpio3", LTQ_GPIO3_BASE_ADDR, LTQ_GPIO3_SIZE), 
    5039}; 
    5140 
    … …  
    6150                platform_device_register_simple("ltq_gpio", 2, 
    6251                        &ltq_gpio_resource[2], 1); 
     52                platform_device_register_simple("ltq_gpio", 3, 
     53                        &ltq_gpio_resource[3], 1); 
    6354        } 
    6455} 
    6556 
    6657/* serial to parallel conversion */ 
    67 static struct resource ltq_stp_resource = { 
    68         .name   = "stp", 
    69         .start  = LTQ_STP_BASE_ADDR, 
    70         .end    = LTQ_STP_BASE_ADDR + LTQ_STP_SIZE - 1, 
    71         .flags  = IORESOURCE_MEM, 
    72 }; 
     58static struct resource ltq_stp_resource = 
     59        MEM_RES("stp", LTQ_STP_BASE_ADDR, LTQ_STP_SIZE); 
    7360 
    7461void __init ltq_register_gpio_stp(void) 
    … …  
    7966/* asc ports - amazon se has its own serial mapping */ 
    8067static struct resource ltq_ase_asc_resources[] = { 
    81         { 
    82                 .name   = "asc0", 
    83                 .start  = LTQ_ASC1_BASE_ADDR, 
    84                 .end    = LTQ_ASC1_BASE_ADDR + LTQ_ASC_SIZE - 1, 
    85                 .flags  = IORESOURCE_MEM, 
    86         }, 
     68        MEM_RES("asc0", LTQ_ASC1_BASE_ADDR, LTQ_ASC_SIZE), 
    8769        IRQ_RES(tx, LTQ_ASC_ASE_TIR), 
    8870        IRQ_RES(rx, LTQ_ASC_ASE_RIR), 
    … …  
    9779 
    9880/* ethernet */ 
    99 static struct resource ltq_etop_resources = { 
    100         .name   = "etop", 
    101         .start  = LTQ_ETOP_BASE_ADDR, 
    102         .end    = LTQ_ETOP_BASE_ADDR + LTQ_ETOP_SIZE - 1, 
    103         .flags  = IORESOURCE_MEM, 
     81static struct resource ltq_etop_resources[] = { 
     82        MEM_RES("etop", LTQ_ETOP_BASE_ADDR, LTQ_ETOP_SIZE), 
     83        MEM_RES("gbit", LTQ_GBIT_BASE_ADDR, LTQ_GBIT_SIZE), 
    10484}; 
    10585 
    10686static struct platform_device ltq_etop = { 
    10787        .name           = "ltq_etop", 
    108         .resource       = &ltq_etop_resources, 
     88        .resource       = ltq_etop_resources, 
    10989        .num_resources  = 1, 
    11090}; 
    … …  
    11393ltq_register_etop(struct ltq_eth_data *eth) 
    11494{ 
     95        /* only register the gphy on socs that have one */ 
     96        if (ltq_is_ar9() | ltq_is_vr9()) 
     97                ltq_etop.num_resources = 2; 
    11598        if (eth) { 
    11699                ltq_etop.dev.platform_data = eth; 
    … …  
    118101        } 
    119102} 
     103 
     104/* madwifi */ 
     105int lantiq_emulate_madwifi_eep = 0; 
     106EXPORT_SYMBOL(lantiq_emulate_madwifi_eep); 
     107 
     108int lantiq_madwifi_eep_addr = 0; 
     109EXPORT_SYMBOL(lantiq_madwifi_eep_addr); 
     110 
     111void __init 
     112ltq_register_madwifi_eep(unsigned long long addr) 
     113{ 
     114        lantiq_madwifi_eep_addr = addr; 
     115        lantiq_emulate_madwifi_eep = 1; 
     116} 
     117 
     118/* ebu */ 
     119static struct resource ltq_ebu_resource = 
     120{ 
     121        .name   = "gpio_ebu", 
     122        .start  = LTQ_EBU_GPIO_START, 
     123        .end    = LTQ_EBU_GPIO_START + LTQ_EBU_GPIO_SIZE - 1, 
     124        .flags  = IORESOURCE_MEM, 
     125}; 
     126 
     127static struct platform_device ltq_ebu = 
     128{ 
     129        .name           = "ltq_ebu", 
     130        .resource       = &ltq_ebu_resource, 
     131        .num_resources  = 1, 
     132}; 
     133 
     134void __init 
     135ltq_register_gpio_ebu(unsigned int value) 
     136{ 
     137        ltq_ebu.dev.platform_data = (void*) value; 
     138        platform_device_register(&ltq_ebu); 
     139} 
     140 
     141/* gpio buttons */ 
     142static struct gpio_buttons_platform_data ltq_gpio_buttons_platform_data; 
     143 
     144static struct platform_device ltq_gpio_buttons_platform_device = 
     145{ 
     146        .name = "gpio-buttons", 
     147        .id = 0, 
     148        .dev = { 
     149                .platform_data = (void *) &ltq_gpio_buttons_platform_data, 
     150        }, 
     151}; 
     152 
     153void __init 
     154ltq_register_gpio_buttons(struct gpio_button *buttons, int cnt) 
     155{ 
     156        ltq_gpio_buttons_platform_data.buttons = buttons; 
     157        ltq_gpio_buttons_platform_data.nbuttons = cnt; 
     158        platform_device_register(&ltq_gpio_buttons_platform_device); 
     159} 
     160 
     161static struct resource ltq_spi_resources[] = { 
     162        { 
     163                .start  = LTQ_SSC_BASE_ADDR, 
     164                .end    = LTQ_SSC_BASE_ADDR + LTQ_SSC_SIZE - 1, 
     165                .flags  = IORESOURCE_MEM, 
     166        }, 
     167        IRQ_RES(spi_tx, LTQ_SSC_TIR), 
     168        IRQ_RES(spi_rx, LTQ_SSC_RIR), 
     169        IRQ_RES(spi_err, LTQ_SSC_EIR), 
     170}; 
     171 
     172static struct resource ltq_spi_resources_ar9[] = { 
     173        { 
     174                .start  = LTQ_SSC_BASE_ADDR, 
     175                .end    = LTQ_SSC_BASE_ADDR + LTQ_SSC_SIZE - 1, 
     176                .flags  = IORESOURCE_MEM, 
     177        }, 
     178        IRQ_RES(spi_tx, LTQ_SSC_TIR_AR9), 
     179        IRQ_RES(spi_rx, LTQ_SSC_RIR_AR9), 
     180        IRQ_RES(spi_err, LTQ_SSC_EIR), 
     181}; 
     182 
     183static struct platform_device ltq_spi = { 
     184        .name           = "ltq-spi", 
     185        .resource       = ltq_spi_resources, 
     186        .num_resources  = ARRAY_SIZE(ltq_spi_resources), 
     187}; 
     188 
     189void __init ltq_register_spi(struct ltq_spi_platform_data *pdata, 
     190                struct spi_board_info const *info, unsigned n) 
     191{ 
     192        if(ltq_is_ar9()) 
     193                ltq_spi.resource = ltq_spi_resources_ar9; 
     194        spi_register_board_info(info, n); 
     195        ltq_spi.dev.platform_data = pdata; 
     196        platform_device_register(&ltq_spi); 
     197} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/devices.h

    r18171 r18225  
    1212#include "../devices.h" 
    1313#include <linux/phy.h> 
     14#include <linux/spi/spi.h> 
     15#include <linux/gpio_buttons.h> 
    1416 
    1517extern void ltq_register_gpio(void); 
    … …  
    1719extern void ltq_register_ase_asc(void); 
    1820extern void ltq_register_etop(struct ltq_eth_data *eth); 
     21extern void ltq_register_gpio_ebu(unsigned int value); 
     22extern void ltq_register_spi(struct ltq_spi_platform_data *pdata, 
     23        struct spi_board_info const *info, unsigned n); 
     24extern void ltq_register_madwifi_eep(unsigned long long addr); 
     25extern void ltq_register_gpio_buttons(struct gpio_button *buttons, int cnt); 
    1926 
    2027#endif 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/dma.c

    r18171 r18225  
    2525#include <xway_dma.h> 
    2626 
     27#include "../devices.h" 
     28 
    2729#define LTQ_DMA_CTRL            0x10 
    2830#define LTQ_DMA_CPOLL           0x14 
    … …  
    5658                                                ltq_dma_membase + (z)) 
    5759 
    58 static struct resource ltq_dma_resource = { 
    59         .name   = "dma", 
    60         .start  = LTQ_DMA_BASE_ADDR, 
    61         .end    = LTQ_DMA_BASE_ADDR + LTQ_DMA_SIZE - 1, 
    62         .flags  = IORESOURCE_MEM, 
    63 }; 
     60static struct resource ltq_dma_resource = 
     61        MEM_RES("dma", LTQ_DMA_BASE_ADDR, LTQ_DMA_SIZE); 
    6462 
    6563static void __iomem *ltq_dma_membase; 
    … …  
    221219        int i; 
    222220 
    223         /* insert and request the memory region */ 
    224         if (insert_resource(&iomem_resource, &ltq_dma_resource) < 0) 
    225                 panic("Failed to insert dma memory\n"); 
    226  
    227         if (request_mem_region(ltq_dma_resource.start, 
    228                         resource_size(&ltq_dma_resource), "dma") < 0) 
    229                 panic("Failed to request dma memory\n"); 
    230  
    231221        /* remap dma register range */ 
    232         ltq_dma_membase = ioremap_nocache(ltq_dma_resource.start, 
    233                                 resource_size(&ltq_dma_resource)); 
     222        ltq_dma_membase = ltq_remap_resource(&ltq_dma_resource); 
    234223        if (!ltq_dma_membase) 
    235224                panic("Failed to remap dma memory\n"); 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/gpio.c

    r18171 r18225  
    2222#define LTQ_GPIO_ALTSEL1        0x10 
    2323#define LTQ_GPIO_OD             0x14 
    24  
     24#define LTQ_GPIO_PUDSEL         0x1C 
     25#define LTQ_GPIO_PUDEN          0x20 
     26#define LTQ_GPIO3_OD            0x24 
     27#define LTQ_GPIO3_ALTSEL1       0x24 
     28 
     29/* PORT3 only has 8 pins and its register layout 
     30   is slightly different */ 
    2531#define PINS_PER_PORT           16 
    26 #define MAX_PORTS               3 
     32#define PINS_PORT3              8 
     33#define MAX_PORTS               4 
     34#define MAX_PIN                 56 
    2735 
    2836#define ltq_gpio_getbit(m, r, p)        (!!(ltq_r32(m + r) & (1 << p))) 
    … …  
    5462        int id = 0; 
    5563 
    56         if (pin >= (MAX_PORTS * PINS_PER_PORT)) 
     64        if (pin >= MAX_PIN) 
    5765                return -EINVAL; 
    5866        if (gpio_request(pin, name)) { 
    … …  
    7482                ltq_gpio_clearbit(ltq_gpio_port[id].membase, 
    7583                        LTQ_GPIO_ALTSEL0, pin); 
    76         if (alt1) 
    77                 ltq_gpio_setbit(ltq_gpio_port[id].membase, 
    78                         LTQ_GPIO_ALTSEL1, pin); 
    79         else 
    80                 ltq_gpio_clearbit(ltq_gpio_port[id].membase, 
    81                         LTQ_GPIO_ALTSEL1, pin); 
     84        if (id == 3) { 
     85                if (alt1) 
     86                        ltq_gpio_setbit(ltq_gpio_port[1].membase, 
     87                                LTQ_GPIO3_ALTSEL1, pin); 
     88                else 
     89                        ltq_gpio_clearbit(ltq_gpio_port[1].membase, 
     90                                LTQ_GPIO3_ALTSEL1, pin); 
     91        } else { 
     92                if (alt1) 
     93                        ltq_gpio_setbit(ltq_gpio_port[id].membase, 
     94                                LTQ_GPIO_ALTSEL1, pin); 
     95                else 
     96                        ltq_gpio_clearbit(ltq_gpio_port[id].membase, 
     97                                LTQ_GPIO_ALTSEL1, pin); 
     98        } 
    8299        return 0; 
    83100} 
    … …  
    105122        struct ltq_gpio *ltq_gpio = container_of(chip, struct ltq_gpio, chip); 
    106123 
    107         ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_OD, offset); 
     124        if (chip->ngpio == PINS_PORT3) 
     125                ltq_gpio_clearbit(ltq_gpio_port[0].membase, 
     126                                LTQ_GPIO3_OD, offset); 
     127        else 
     128                ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_OD, offset); 
    108129        ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_DIR, offset); 
     130        ltq_gpio_setbit(ltq_gpio->membase, LTQ_GPIO_PUDSEL, offset); 
     131        ltq_gpio_setbit(ltq_gpio->membase, LTQ_GPIO_PUDEN, offset); 
    109132 
    110133        return 0; 
    … …  
    116139        struct ltq_gpio *ltq_gpio = container_of(chip, struct ltq_gpio, chip); 
    117140 
    118         ltq_gpio_setbit(ltq_gpio->membase, LTQ_GPIO_OD, offset); 
     141        if (chip->ngpio == PINS_PORT3) 
     142                ltq_gpio_setbit(ltq_gpio_port[0].membase, LTQ_GPIO3_OD, offset); 
     143        else 
     144                ltq_gpio_setbit(ltq_gpio->membase, LTQ_GPIO_OD, offset); 
    119145        ltq_gpio_setbit(ltq_gpio->membase, LTQ_GPIO_DIR, offset); 
     146        ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_PUDSEL, offset); 
     147        ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_PUDEN, offset); 
    120148        ltq_gpio_set(chip, offset, value); 
    121149 
    … …  
    128156 
    129157        ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_ALTSEL0, offset); 
    130         ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_ALTSEL1, offset); 
     158        if (chip->ngpio == PINS_PORT3) 
     159                ltq_gpio_clearbit(ltq_gpio_port[1].membase, 
     160                                LTQ_GPIO3_ALTSEL1, offset); 
     161        else 
     162                ltq_gpio_clearbit(ltq_gpio->membase, LTQ_GPIO_ALTSEL1, offset); 
    131163        return 0; 
    132164} 
    … …  
    141173                return -EINVAL; 
    142174        } 
     175 
     176        /* dirty hack - The registers of port3 are not mapped linearly. 
     177           Port 3 may only load if Port 1/2 are mapped */ 
     178        if ((pdev->id == 3) && (!ltq_gpio_port[1].membase || !ltq_gpio_port[2].membase)) { 
     179                dev_err(&pdev->dev, 
     180                        "ports 1/2 need to be loaded before port 3 works\n"); 
     181                return -ENOMEM; 
     182        } 
     183 
    143184        res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
    144185        if (!res) { 
    … …  
    170211        ltq_gpio_port[pdev->id].chip.request = ltq_gpio_req; 
    171212        ltq_gpio_port[pdev->id].chip.base = PINS_PER_PORT * pdev->id; 
    172         ltq_gpio_port[pdev->id].chip.ngpio = PINS_PER_PORT; 
     213        if (pdev->id == 3) 
     214                ltq_gpio_port[pdev->id].chip.ngpio = PINS_PORT3; 
     215        else 
     216                ltq_gpio_port[pdev->id].chip.ngpio = PINS_PER_PORT; 
    173217        platform_set_drvdata(pdev, &ltq_gpio_port[pdev->id]); 
    174218        return gpiochip_add(&ltq_gpio_port[pdev->id].chip); 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/gpio_ebu.c

    r18171 r18225  
    6262        .direction_output = ltq_ebu_direction_output, 
    6363        .set = ltq_ebu_set, 
    64         .base = 72, 
     64        .base = 100, 
    6565        .ngpio = 16, 
    66         .can_sleep = 1, 
    6766        .owner = THIS_MODULE, 
    6867}; 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/gpio_stp.c

    r18171 r18225  
    3636 
    3737#define LTQ_STP_GROUP0          (1 << 0) 
     38#define LTQ_STP_GROUP1          (1 << 1) 
     39#define LTQ_STP_GROUP2          (1 << 2) 
    3840 
    3941#define LTQ_STP_RISING          0 
    … …  
    7173        .direction_output = ltq_stp_direction_output, 
    7274        .set = ltq_stp_set, 
    73         .base = 48, 
     75        .base = 200, 
    7476        .ngpio = 24, 
    75         .can_sleep = 1, 
    7677        .owner = THIS_MODULE, 
    7778}; 
    … …  
    9495        ltq_stp_w32_mask(LTQ_STP_EDGE_MASK, LTQ_STP_FALLING, LTQ_STP_CON0); 
    9596 
    96         /* per default stp 15-0 are set */ 
    97         ltq_stp_w32_mask(0, LTQ_STP_GROUP0, LTQ_STP_CON1); 
     97        /* enable all three led groups */ 
     98        ltq_stp_w32_mask(0, LTQ_STP_GROUP0 | LTQ_STP_GROUP1 | LTQ_STP_GROUP2, 
     99                LTQ_STP_CON1); 
    98100 
    99101        /* stp are update periodically by the FPI bus */ 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/mach-easy50601.c

    r18171 r18225  
    3333                .name   = "linux", 
    3434                .offset = 0x20000, 
    35                 .size   = 0xE0000, 
    36         }, 
    37         { 
    38                 .name   = "rootfs", 
    39                 .offset = 0x100000, 
    40                 .size   = 0x300000, 
     35                .size   = 0x3d0000, 
    4136        }, 
    4237}; 
    … …  
    4742}; 
    4843 
     44static struct ltq_eth_data ltq_eth_data = { 
     45        .mii_mode = -1, /* use EPHY */ 
     46}; 
     47 
    4948static void __init easy50601_init(void) 
    5049{ 
    5150        ltq_register_nor(&easy50601_flash_data); 
     51        ltq_register_etop(&ltq_eth_data); 
    5252} 
    5353 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/mach-easy50712.c

    r18171 r18225  
    3535                .name   = "linux", 
    3636                .offset = 0x20000, 
    37                 .size   = 0xe0000, 
    38         }, 
    39         { 
    40                 .name   = "rootfs", 
    41                 .offset = 0x100000, 
    42                 .size   = 0x300000, 
     37                .size   = 0x3d0000, 
    4338        }, 
    4439}; 
    … …  
    6762        ltq_register_pci(&ltq_pci_data); 
    6863        ltq_register_etop(&ltq_eth_data); 
     64        ltq_register_tapi(); 
    6965} 
    7066 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/prom-ase.c

    r18171 r18225  
    1414#include <lantiq_soc.h> 
    1515 
     16#include "devices.h" 
    1617#include "../prom.h" 
    1718 
    … …  
    2728        i->partnum = (ltq_r32(LTQ_MPS_CHIPID) & PART_MASK) >> PART_SHIFT; 
    2829        i->rev = (ltq_r32(LTQ_MPS_CHIPID) & REV_MASK) >> REV_SHIFT; 
     30        sprintf(i->rev_type, "1.%d", i->rev); 
    2931        switch (i->partnum) { 
    3032        case SOC_ID_AMAZON_SE: 
    … …  
    3840        } 
    3941} 
     42 
     43void __init ltq_soc_setup(void) 
     44{ 
     45        ltq_register_ase_asc(); 
     46        ltq_register_gpio(); 
     47        ltq_register_wdt(); 
     48} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/prom-xway.c

    r18171 r18225  
    1414#include <lantiq_soc.h> 
    1515 
     16#include "devices.h" 
    1617#include "../prom.h" 
    1718 
    … …  
    2930        i->partnum = (ltq_r32(LTQ_MPS_CHIPID) & PART_MASK) >> PART_SHIFT; 
    3031        i->rev = (ltq_r32(LTQ_MPS_CHIPID) & REV_MASK) >> REV_SHIFT; 
     32        sprintf(i->rev_type, "1.%d", i->rev); 
    3133        switch (i->partnum) { 
    3234        case SOC_ID_DANUBE1: 
    … …  
    5355        } 
    5456} 
     57 
     58void __init ltq_soc_setup(void) 
     59{ 
     60        ltq_register_asc(0); 
     61        ltq_register_asc(1); 
     62        ltq_register_gpio(); 
     63        ltq_register_wdt(); 
     64} 

  • src/linux/universal/linux-3.2/arch/mips/lantiq/xway/reset.c

    r18171 r18225  
    1616#include <lantiq_soc.h> 
    1717 
     18#include "../devices.h" 
     19 
    1820#define ltq_rcu_w32(x, y)       ltq_w32((x), ltq_rcu_membase + (y)) 
    1921#define ltq_rcu_r32(x)          ltq_r32(ltq_rcu_membase + (x)) 
    … …  
    2628#define LTQ_RCU_STAT_SHIFT      26 
    2729 
    28 static struct resource ltq_rcu_resource = { 
    29         .name   = "rcu", 
    30         .start  = LTQ_RCU_BASE_ADDR, 
    31         .end    = LTQ_RCU_BASE_ADDR + LTQ_RCU_SIZE - 1, 
    32         .flags  = IORESOURCE_MEM, 
    33 }; 
     30static struct resource ltq_rcu_resource = 
     31        MEM_RES("rcu", LTQ_RCU_BASE_ADDR, LTQ_RCU_SIZE); 
    3432 
    3533/* remapped base addr of the reset control unit */ 
    … …  
    6866static int __init mips_reboot_setup(void) 
    6967{ 
    70         /* insert and request the memory region */ 
    71         if (insert_resource(&iomem_resource, &ltq_rcu_resource) < 0) 
    72                 panic("Failed to insert rcu memory\n"); 
    73  
    74         if (request_mem_region(ltq_rcu_resource.start, 
    75                         resource_size(&ltq_rcu_resource), "rcu") < 0) 
    76                 panic("Failed to request rcu memory\n"); 
    77  
    7868        /* remap rcu register range */ 
    79         ltq_rcu_membase = ioremap_nocache(ltq_rcu_resource.start, 
    80                                 resource_size(&ltq_rcu_resource)); 
     69        ltq_rcu_membase = ltq_remap_resource(&ltq_rcu_resource); 
    8170        if (!ltq_rcu_membase) 
    8271                panic("Failed to remap rcu memory\n"); 
Note: See TracChangeset for help on using the changeset viewer.