source: trunk/target/linux/ixp4xx/patches-3.0/190-cambria_support.patch @ 27493

Last change on this file since 27493 was 27493, checked in by kaloz, 5 years ago

[ixp4xx]: add 3.0 support

File size: 12.9 KB
  • new file arch/arm/mach-ixp4xx/cambria-pci.c

    - +  
     1/* 
     2 * arch/arch/mach-ixp4xx/cambria-pci.c 
     3 * 
     4 * PCI setup routines for Gateworks Cambria series 
     5 * 
     6 * Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org> 
     7 * 
     8 * based on coyote-pci.c: 
     9 *      Copyright (C) 2002 Jungo Software Technologies. 
     10 *      Copyright (C) 2003 MontaVista Softwrae, Inc. 
     11 * 
     12 * Maintainer: Imre Kaloz <kaloz@openwrt.org> 
     13 * 
     14 * This program is free software; you can redistribute it and/or modify 
     15 * it under the terms of the GNU General Public License version 2 as 
     16 * published by the Free Software Foundation. 
     17 * 
     18 */ 
     19 
     20#include <linux/kernel.h> 
     21#include <linux/pci.h> 
     22#include <linux/init.h> 
     23#include <linux/irq.h> 
     24 
     25#include <asm/mach-types.h> 
     26#include <mach/hardware.h> 
     27#include <asm/irq.h> 
     28 
     29#include <asm/mach/pci.h> 
     30 
     31extern void ixp4xx_pci_preinit(void); 
     32extern int ixp4xx_setup(int nr, struct pci_sys_data *sys); 
     33extern struct pci_bus *ixp4xx_scan_bus(int nr, struct pci_sys_data *sys); 
     34 
     35void __init cambria_pci_preinit(void) 
     36{ 
     37        irq_set_irq_type(IRQ_IXP4XX_GPIO11, IRQ_TYPE_LEVEL_LOW); 
     38        irq_set_irq_type(IRQ_IXP4XX_GPIO10, IRQ_TYPE_LEVEL_LOW); 
     39        irq_set_irq_type(IRQ_IXP4XX_GPIO9, IRQ_TYPE_LEVEL_LOW); 
     40        irq_set_irq_type(IRQ_IXP4XX_GPIO8, IRQ_TYPE_LEVEL_LOW); 
     41 
     42        ixp4xx_pci_preinit(); 
     43} 
     44 
     45static int __init cambria_map_irq(struct pci_dev *dev, u8 slot, u8 pin) 
     46{ 
     47        if (slot == 1) 
     48                return IRQ_IXP4XX_GPIO11; 
     49        else if (slot == 2) 
     50                return IRQ_IXP4XX_GPIO10; 
     51        else if (slot == 3) 
     52                return IRQ_IXP4XX_GPIO9; 
     53        else if (slot == 4) 
     54                return IRQ_IXP4XX_GPIO8; 
     55        else return -1; 
     56} 
     57 
     58struct hw_pci cambria_pci __initdata = { 
     59        .nr_controllers = 1, 
     60        .preinit =        cambria_pci_preinit, 
     61        .swizzle =        pci_std_swizzle, 
     62        .setup =          ixp4xx_setup, 
     63        .scan =           ixp4xx_scan_bus, 
     64        .map_irq =        cambria_map_irq, 
     65}; 
     66 
     67int __init cambria_pci_init(void) 
     68{ 
     69        if (machine_is_cambria()) 
     70                pci_common_init(&cambria_pci); 
     71        return 0; 
     72} 
     73 
     74subsys_initcall(cambria_pci_init); 
  • new file arch/arm/mach-ixp4xx/cambria-setup.c

    - +  
     1/* 
     2 * arch/arm/mach-ixp4xx/cambria-setup.c 
     3 * 
     4 * Board setup for the Gateworks Cambria series 
     5 * 
     6 * Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org> 
     7 * 
     8 * based on coyote-setup.c: 
     9 *      Copyright (C) 2003-2005 MontaVista Software, Inc. 
     10 * 
     11 * Author: Imre Kaloz <kaloz@openwrt.org> 
     12 */ 
     13 
     14#include <linux/device.h> 
     15#include <linux/i2c.h> 
     16#include <linux/i2c-gpio.h> 
     17#include <linux/i2c/at24.h> 
     18#include <linux/if_ether.h> 
     19#include <linux/init.h> 
     20#include <linux/kernel.h> 
     21#include <linux/leds.h> 
     22#include <linux/memory.h> 
     23#include <linux/netdevice.h> 
     24#include <linux/serial.h> 
     25#include <linux/serial_8250.h> 
     26#include <linux/slab.h> 
     27#include <linux/socket.h> 
     28#include <linux/types.h> 
     29#include <linux/tty.h> 
     30 
     31#include <mach/hardware.h> 
     32#include <asm/irq.h> 
     33#include <asm/mach-types.h> 
     34#include <asm/mach/arch.h> 
     35#include <asm/mach/flash.h> 
     36#include <asm/setup.h> 
     37 
     38struct cambria_board_info { 
     39        unsigned char   *model; 
     40        void            (*setup)(void); 
     41}; 
     42 
     43static struct cambria_board_info *cambria_info __initdata; 
     44 
     45static struct flash_platform_data cambria_flash_data = { 
     46        .map_name       = "cfi_probe", 
     47        .width          = 2, 
     48}; 
     49 
     50static struct resource cambria_flash_resource = { 
     51        .flags          = IORESOURCE_MEM, 
     52}; 
     53 
     54static struct platform_device cambria_flash = { 
     55        .name           = "IXP4XX-Flash", 
     56        .id             = 0, 
     57        .dev            = { 
     58                .platform_data = &cambria_flash_data, 
     59        }, 
     60        .num_resources  = 1, 
     61        .resource       = &cambria_flash_resource, 
     62}; 
     63 
     64static struct i2c_gpio_platform_data cambria_i2c_gpio_data = { 
     65        .sda_pin        = 7, 
     66        .scl_pin        = 6, 
     67}; 
     68 
     69static struct platform_device cambria_i2c_gpio = { 
     70        .name           = "i2c-gpio", 
     71        .id             = 0, 
     72        .dev = { 
     73                .platform_data  = &cambria_i2c_gpio_data, 
     74        }, 
     75}; 
     76 
     77static struct eth_plat_info cambria_npec_data = { 
     78        .phy            = 1, 
     79        .rxq            = 4, 
     80        .txreadyq       = 21, 
     81}; 
     82 
     83static struct eth_plat_info cambria_npea_data = { 
     84        .phy            = 2, 
     85        .rxq            = 2, 
     86        .txreadyq       = 19, 
     87}; 
     88 
     89static struct platform_device cambria_npec_device = { 
     90        .name                   = "ixp4xx_eth", 
     91        .id                     = IXP4XX_ETH_NPEC, 
     92        .dev.platform_data      = &cambria_npec_data, 
     93}; 
     94 
     95static struct platform_device cambria_npea_device = { 
     96        .name                   = "ixp4xx_eth", 
     97        .id                     = IXP4XX_ETH_NPEA, 
     98        .dev.platform_data      = &cambria_npea_data, 
     99}; 
     100 
     101static struct resource cambria_uart_resource = { 
     102        .start  = IXP4XX_UART1_BASE_PHYS, 
     103        .end    = IXP4XX_UART1_BASE_PHYS + 0x0fff, 
     104        .flags  = IORESOURCE_MEM, 
     105}; 
     106 
     107static struct plat_serial8250_port cambria_uart_data[] = { 
     108        { 
     109                .mapbase        = IXP4XX_UART1_BASE_PHYS, 
     110                .membase        = (char *)IXP4XX_UART1_BASE_VIRT + REG_OFFSET, 
     111                .irq            = IRQ_IXP4XX_UART1, 
     112                .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST, 
     113                .iotype         = UPIO_MEM, 
     114                .regshift       = 2, 
     115                .uartclk        = IXP4XX_UART_XTAL, 
     116        }, 
     117        { }, 
     118}; 
     119 
     120static struct platform_device cambria_uart = { 
     121        .name           = "serial8250", 
     122        .id             = PLAT8250_DEV_PLATFORM, 
     123        .dev = { 
     124                .platform_data  = cambria_uart_data, 
     125        }, 
     126        .num_resources  = 1, 
     127        .resource       = &cambria_uart_resource, 
     128}; 
     129 
     130static struct resource cambria_pata_resources[] = { 
     131        { 
     132                .flags  = IORESOURCE_MEM 
     133        }, 
     134        { 
     135                .flags  = IORESOURCE_MEM, 
     136        }, 
     137        { 
     138                .name   = "intrq", 
     139                .start  = IRQ_IXP4XX_GPIO12, 
     140                .end    = IRQ_IXP4XX_GPIO12, 
     141                .flags  = IORESOURCE_IRQ, 
     142        }, 
     143}; 
     144 
     145static struct ixp4xx_pata_data cambria_pata_data = { 
     146        .cs0_bits       = 0xbfff3c03, 
     147        .cs1_bits       = 0xbfff3c03, 
     148}; 
     149 
     150static struct platform_device cambria_pata = { 
     151        .name                   = "pata_ixp4xx_cf", 
     152        .id                     = 0, 
     153        .dev.platform_data      = &cambria_pata_data, 
     154        .num_resources          = ARRAY_SIZE(cambria_pata_resources), 
     155        .resource               = cambria_pata_resources, 
     156}; 
     157 
     158static struct gpio_led cambria_gpio_leds[] = { 
     159        { 
     160                .name           = "user",  /* green led */ 
     161                .gpio           = 5, 
     162                .active_low     = 1, 
     163        } 
     164}; 
     165 
     166static struct gpio_led_platform_data cambria_gpio_leds_data = { 
     167        .num_leds       = 1, 
     168        .leds           = cambria_gpio_leds, 
     169}; 
     170 
     171static struct platform_device cambria_gpio_leds_device = { 
     172        .name           = "leds-gpio", 
     173        .id             = -1, 
     174        .dev.platform_data = &cambria_gpio_leds_data, 
     175}; 
     176 
     177static struct latch_led cambria_latch_leds[] = { 
     178        { 
     179                .name   = "ledA",  /* green led */ 
     180                .bit    = 0, 
     181        }, 
     182        { 
     183                .name   = "ledB",  /* green led */ 
     184                .bit    = 1, 
     185        }, 
     186        { 
     187                .name   = "ledC",  /* green led */ 
     188                .bit    = 2, 
     189        }, 
     190        { 
     191                .name   = "ledD",  /* green led */ 
     192                .bit    = 3, 
     193        }, 
     194        { 
     195                .name   = "ledE",  /* green led */ 
     196                .bit    = 4, 
     197        }, 
     198        { 
     199                .name   = "ledF",  /* green led */ 
     200                .bit    = 5, 
     201        }, 
     202        { 
     203                .name   = "ledG",  /* green led */ 
     204                .bit    = 6, 
     205        }, 
     206        { 
     207                .name   = "ledH",  /* green led */ 
     208                .bit    = 7, 
     209        } 
     210}; 
     211 
     212static struct latch_led_platform_data cambria_latch_leds_data = { 
     213        .num_leds       = 8, 
     214        .leds           = cambria_latch_leds, 
     215        .mem            = 0x53F40000, 
     216}; 
     217 
     218static struct platform_device cambria_latch_leds_device = { 
     219        .name           = "leds-latch", 
     220        .id             = -1, 
     221        .dev.platform_data = &cambria_latch_leds_data, 
     222}; 
     223 
     224static struct resource cambria_usb0_resources[] = { 
     225        { 
     226                .start  = 0xCD000000, 
     227                .end    = 0xCD000300, 
     228                .flags  = IORESOURCE_MEM, 
     229        }, 
     230        { 
     231                .start  = 32, 
     232                .flags  = IORESOURCE_IRQ, 
     233        }, 
     234}; 
     235 
     236static struct resource cambria_usb1_resources[] = { 
     237        { 
     238                .start  = 0xCE000000, 
     239                .end    = 0xCE000300, 
     240                .flags  = IORESOURCE_MEM, 
     241        }, 
     242        { 
     243                .start  = 33, 
     244                .flags  = IORESOURCE_IRQ, 
     245        }, 
     246}; 
     247 
     248static u64 ehci_dma_mask = ~(u32)0; 
     249 
     250static struct platform_device cambria_usb0_device =  { 
     251        .name           = "ixp4xx-ehci", 
     252        .id             = 0, 
     253        .resource       = cambria_usb0_resources, 
     254        .num_resources  = ARRAY_SIZE(cambria_usb0_resources), 
     255        .dev = { 
     256                .dma_mask               = &ehci_dma_mask, 
     257                .coherent_dma_mask      = 0xffffffff, 
     258        }, 
     259}; 
     260 
     261static struct platform_device cambria_usb1_device = { 
     262        .name           = "ixp4xx-ehci", 
     263        .id             = 1, 
     264        .resource       = cambria_usb1_resources, 
     265        .num_resources  = ARRAY_SIZE(cambria_usb1_resources), 
     266        .dev = { 
     267                .dma_mask               = &ehci_dma_mask, 
     268                .coherent_dma_mask      = 0xffffffff, 
     269        }, 
     270}; 
     271 
     272static struct platform_device *cambria_devices[] __initdata = { 
     273        &cambria_i2c_gpio, 
     274        &cambria_flash, 
     275        &cambria_uart, 
     276}; 
     277 
     278static void __init cambria_gw23xx_setup(void) 
     279{ 
     280        platform_device_register(&cambria_npec_device); 
     281        platform_device_register(&cambria_npea_device); 
     282} 
     283 
     284static void __init cambria_gw2350_setup(void) 
     285{ 
     286        platform_device_register(&cambria_npec_device); 
     287        platform_device_register(&cambria_npea_device); 
     288 
     289        platform_device_register(&cambria_usb0_device); 
     290        platform_device_register(&cambria_usb1_device); 
     291 
     292        platform_device_register(&cambria_gpio_leds_device); 
     293} 
     294 
     295static void __init cambria_gw2358_setup(void) 
     296{ 
     297        platform_device_register(&cambria_npec_device); 
     298        platform_device_register(&cambria_npea_device); 
     299 
     300        platform_device_register(&cambria_usb0_device); 
     301        platform_device_register(&cambria_usb1_device); 
     302 
     303        platform_device_register(&cambria_pata); 
     304 
     305        platform_device_register(&cambria_latch_leds_device); 
     306} 
     307 
     308static struct cambria_board_info cambria_boards[] __initdata = { 
     309        { 
     310                .model  = "GW2350", 
     311                .setup  = cambria_gw2350_setup, 
     312        }, { 
     313                .model  = "GW2358", 
     314                .setup  = cambria_gw2358_setup, 
     315        } 
     316}; 
     317 
     318static struct cambria_board_info * __init cambria_find_board_info(char *model) 
     319{ 
     320        int i; 
     321        model[6] = '\0'; 
     322 
     323        for (i = 0; i < ARRAY_SIZE(cambria_boards); i++) { 
     324                struct cambria_board_info *info = &cambria_boards[i]; 
     325                if (strcmp(info->model, model) == 0) 
     326                        return info; 
     327        } 
     328 
     329        return NULL; 
     330} 
     331 
     332static struct memory_accessor *at24_mem_acc; 
     333 
     334static void at24_setup(struct memory_accessor *mem_acc, void *context) 
     335{ 
     336        char mac_addr[ETH_ALEN]; 
     337        char model[7]; 
     338 
     339        at24_mem_acc = mem_acc; 
     340 
     341        /* Read MAC addresses */ 
     342        if (at24_mem_acc->read(at24_mem_acc, mac_addr, 0x0, 6) == 6) { 
     343                memcpy(&cambria_npec_data.hwaddr, mac_addr, ETH_ALEN); 
     344        } 
     345        if (at24_mem_acc->read(at24_mem_acc, mac_addr, 0x6, 6) == 6) { 
     346                memcpy(&cambria_npea_data.hwaddr, mac_addr, ETH_ALEN); 
     347        } 
     348 
     349        /* Read the first 6 bytes of the model number */ 
     350        if (at24_mem_acc->read(at24_mem_acc, model, 0x20, 6) == 6) { 
     351                cambria_info = cambria_find_board_info(model); 
     352        } 
     353 
     354} 
     355 
     356static struct at24_platform_data cambria_eeprom_info = { 
     357        .byte_len       = 1024, 
     358        .page_size      = 16, 
     359        .flags          = AT24_FLAG_READONLY, 
     360        .setup          = at24_setup, 
     361}; 
     362 
     363static struct i2c_board_info __initdata cambria_i2c_board_info[] = { 
     364        { 
     365                I2C_BOARD_INFO("ds1672", 0x68), 
     366        }, 
     367        { 
     368                I2C_BOARD_INFO("ad7418", 0x28), 
     369        }, 
     370        { 
     371                I2C_BOARD_INFO("24c08", 0x51), 
     372                .platform_data  = &cambria_eeprom_info 
     373        }, 
     374}; 
     375 
     376static void __init cambria_init(void) 
     377{ 
     378        ixp4xx_sys_init(); 
     379 
     380        cambria_flash_resource.start = IXP4XX_EXP_BUS_BASE(0); 
     381        cambria_flash_resource.end = IXP4XX_EXP_BUS_BASE(0) + SZ_32M - 1; 
     382 
     383        *IXP4XX_EXP_CS0 |= IXP4XX_FLASH_WRITABLE; 
     384        *IXP4XX_EXP_CS1 = *IXP4XX_EXP_CS0; 
     385 
     386        platform_add_devices(cambria_devices, ARRAY_SIZE(cambria_devices)); 
     387 
     388        cambria_pata_resources[0].start = 0x53e00000; 
     389        cambria_pata_resources[0].end = 0x53e3ffff; 
     390 
     391        cambria_pata_resources[1].start = 0x53e40000; 
     392        cambria_pata_resources[1].end = 0x53e7ffff; 
     393 
     394        cambria_pata_data.cs0_cfg = IXP4XX_EXP_CS3; 
     395        cambria_pata_data.cs1_cfg = IXP4XX_EXP_CS3; 
     396 
     397        i2c_register_board_info(0, cambria_i2c_board_info, 
     398                                ARRAY_SIZE(cambria_i2c_board_info)); 
     399} 
     400 
     401static int __init cambria_model_setup(void) 
     402{ 
     403        if (!machine_is_cambria()) 
     404                return 0; 
     405 
     406        if (cambria_info) { 
     407                printk(KERN_DEBUG "Running on Gateworks Cambria %s\n", 
     408                                cambria_info->model); 
     409                cambria_info->setup(); 
     410        } else { 
     411                printk(KERN_INFO "Unknown/missing Cambria model number" 
     412                                " -- defaults will be used\n"); 
     413                cambria_gw23xx_setup(); 
     414        } 
     415 
     416        return 0; 
     417} 
     418late_initcall(cambria_model_setup); 
     419 
     420MACHINE_START(CAMBRIA, "Gateworks Cambria series") 
     421        /* Maintainer: Imre Kaloz <kaloz@openwrt.org> */ 
     422        .map_io         = ixp4xx_map_io, 
     423        .init_irq       = ixp4xx_init_irq, 
     424        .timer          = &ixp4xx_timer, 
     425        .boot_params    = 0x0100, 
     426        .init_machine   = cambria_init, 
     427MACHINE_END 
  • arch/arm/mach-ixp4xx/Kconfig

    a b config MACH_AVILA 
    2525          Avila Network Platform. For more information on this platform, 
    2626          see <file:Documentation/arm/IXP4xx>. 
    2727 
     28config MACH_CAMBRIA 
     29        bool "Cambria" 
     30        select PCI 
     31        help 
     32          Say 'Y' here if you want your kernel to support the Gateworks 
     33          Cambria series. For more information on this platform, 
     34          see <file:Documentation/arm/IXP4xx>. 
     35 
    2836config MACH_LOFT 
    2937    bool "Loft" 
    3038    depends on MACH_AVILA 
    config CPU_IXP46X 
    222230 
    223231config CPU_IXP43X 
    224232        bool 
    225         depends on MACH_KIXRP435 
     233        depends on MACH_KIXRP435 || MACH_CAMBRIA 
    226234        default y 
    227235 
    228236config MACH_GTWX5715 
  • arch/arm/mach-ixp4xx/Makefile

    a b obj-pci-n := 
    77 
    88obj-pci-$(CONFIG_ARCH_IXDP4XX)          += ixdp425-pci.o 
    99obj-pci-$(CONFIG_MACH_AVILA)            += avila-pci.o 
     10obj-pci-$(CONFIG_MACH_CAMBRIA)          += cambria-pci.o 
    1011obj-pci-$(CONFIG_MACH_IXDPG425)         += ixdpg425-pci.o 
    1112obj-pci-$(CONFIG_ARCH_ADI_COYOTE)       += coyote-pci.o 
    1213obj-pci-$(CONFIG_MACH_GTWX5715)         += gtwx5715-pci.o 
    obj-y += common.o 
    3031 
    3132obj-$(CONFIG_ARCH_IXDP4XX)      += ixdp425-setup.o 
    3233obj-$(CONFIG_MACH_AVILA)        += avila-setup.o 
     34obj-$(CONFIG_MACH_CAMBRIA)      += cambria-setup.o 
    3335obj-$(CONFIG_MACH_IXDPG425)     += coyote-setup.o 
    3436obj-$(CONFIG_ARCH_ADI_COYOTE)   += coyote-setup.o 
    3537obj-$(CONFIG_MACH_GTWX5715)     += gtwx5715-setup.o 
Note: See TracBrowser for help on using the repository browser.