Ticket #8677: 454-board_livebox.patch

File 454-board_livebox.patch, 9.9 KB (added by danitool <dgcbueu@…>, 5 years ago)
  • arch/mips/bcm63xx/boards/Kconfig

    a b config BOARD_BCM963XX 
    88        select SSB 
    99       help 
    1010 
     11config BOARD_LIVEBOX 
     12        bool "Inventel Livebox(es) boards" 
     13        select SSB 
     14        help 
     15         Inventel Livebox boards using the RedBoot bootloader. 
     16 
    1117endchoice 
  • arch/mips/bcm63xx/boards/Makefile

    a b  
    11obj-$(CONFIG_BOARD_BCM963XX)            += board_bcm963xx.o 
     2obj-$(CONFIG_BOARD_LIVEBOX)             += board_livebox.o 
    23 
    34ccflags-y := -Werror 
  • drivers/mtd/maps/bcm963xx-flash.c

    a b  
    3333#include <asm/mach-bcm63xx/bcm963xx_tag.h> 
    3434 
    3535#define BCM63XX_BUSWIDTH        2               /* Buswidth */ 
    36 #define BCM63XX_EXTENDED_SIZE   0xBFC00000      /* Extended flash address */ 
     36unsigned int BCM63XX_EXTENDED_SIZE;             /* Extended flash address */ 
    3737 
    3838#define PFX KBUILD_MODNAME ": " 
    3939 
     
    192192        } 
    193193 
    194194        bcm963xx_map.phys = r->start; 
     195        BCM63XX_EXTENDED_SIZE = bcm963xx_map.phys + 0xA0000000; 
    195196        bcm963xx_map.size = resource_size(r); 
    196197        bcm963xx_map.virt = ioremap(r->start, resource_size(r)); 
    197198        if (!bcm963xx_map.virt) { 
  • new file arch/mips/bcm63xx/boards/board_livebox.c

    - +  
     1/* 
     2 * This file is subject to the terms and conditions of the GNU General Public 
     3 * License.  See the file "COPYING" in the main directory of this archive 
     4 * for more details. 
     5 * 
     6 * Copyright (C) 2008 Florian Fainelli <florian@openwrt.org> 
     7 */ 
     8 
     9#include <linux/init.h> 
     10#include <linux/kernel.h> 
     11#include <linux/string.h> 
     12#include <linux/platform_device.h> 
     13#include <linux/mtd/mtd.h> 
     14#include <linux/mtd/partitions.h> 
     15#include <linux/mtd/physmap.h> 
     16#include <linux/ssb/ssb.h> 
     17#include <linux/gpio_buttons.h> 
     18#include <linux/input.h> 
     19#include <linux/spi/spi.h> 
     20#include <linux/spi/spi_gpio.h> 
     21#include <asm/addrspace.h> 
     22#include <bcm63xx_board.h> 
     23#include <bcm63xx_cpu.h> 
     24#include <bcm63xx_dev_uart.h> 
     25#include <bcm63xx_regs.h> 
     26#include <bcm63xx_io.h> 
     27#include <bcm63xx_dev_pci.h> 
     28#include <bcm63xx_dev_enet.h> 
     29#include <bcm63xx_dev_dsp.h> 
     30#include <bcm63xx_dev_pcmcia.h> 
     31#include <bcm63xx_dev_usb_ohci.h> 
     32#include <bcm63xx_dev_usb_ehci.h> 
     33#include <bcm63xx_dev_usb_udc.h> 
     34#include <bcm63xx_dev_spi.h> 
     35#include <board_bcm963xx.h> 
     36 
     37#define PFX     "board_livebox: " 
     38 
     39static unsigned int mac_addr_used = 0; 
     40static struct board_info board; 
     41 
     42/* 
     43 * known 6348 boards 
     44 */ 
     45#ifdef CONFIG_BCM63XX_CPU_6348 
     46static struct board_info __initdata board_livebox = { 
     47        .name                           = "Livebox", 
     48        .expected_cpu_id                = 0x6348, 
     49 
     50        .has_uart0                      = 1, 
     51        .has_enet0                      = 1, 
     52        .has_enet1                      = 1, 
     53        .has_pci                        = 1, 
     54 
     55        .enet1 = { 
     56                  .has_phy              = 1, 
     57                  .phy_id               = 31, 
     58        }, 
     59 
     60        .enet0 = { 
     61                .has_phy                = 1, 
     62                .use_internal_phy       = 1, 
     63        }, 
     64 
     65        .has_ohci0                      = 1, 
     66        .has_udc0                       = 1, 
     67        .has_pccard                     = 1, 
     68        /*the pccard (PCMCIA) connector can be soldered if not present*/ 
     69 
     70        .has_dsp                        = 0, /*TODO some Liveboxes have dsp*/ 
     71        .dsp = { 
     72                .gpio_rst               = 6, 
     73                .gpio_int               = 35, 
     74                .cs                     = 2, 
     75                .ext_irq                = 2, 
     76        }, 
     77                /*eth1 shares gpio6 with dsp*/ 
     78 
     79        .leds = { 
     80                { 
     81                        .name           = "adsl-fail", 
     82                        .gpio           = 0, 
     83                        .active_low     = 0, 
     84                        .default_trigger = "default-on", 
     85                }, 
     86                { 
     87                        .name           = "adsl", 
     88                        .gpio           = 1, 
     89                        .active_low     = 0, 
     90                }, 
     91                { 
     92                        .name           = "traffic", 
     93                        .gpio           = 2, 
     94                        .active_low     = 0, 
     95                }, 
     96                { 
     97                        .name           = "phone", 
     98                        .gpio           = 3, 
     99                        .active_low     = 0, 
     100                }, 
     101                { 
     102                        .name           = "wifi", 
     103                        .gpio           = 4, 
     104                        .active_low     = 0, 
     105                }, 
     106        }, 
     107 
     108        .buttons = { 
     109                { 
     110                        .desc           = "BTN_1", 
     111                        .gpio           = 36, 
     112                        .active_low     = 1, 
     113                        .type           = EV_KEY, 
     114                        .code           = BTN_1, 
     115                        .threshold      = 3, 
     116                }, 
     117                { 
     118                        .desc           = "BTN_2", 
     119                        .gpio           = 7, 
     120                        .active_low     = 1, 
     121                        .type           = EV_KEY, 
     122                        .code           = BTN_2, 
     123                        .threshold      = 3, 
     124                }, 
     125 
     126        }, 
     127}; 
     128#endif 
     129 
     130/* 
     131 * all boards 
     132 */ 
     133static const struct board_info __initdata *bcm963xx_boards[] = { 
     134#ifdef CONFIG_BCM63XX_CPU_6348 
     135        &board_livebox 
     136#endif 
     137}; 
     138/* 
     139 * return board name for /proc/cpuinfo 
     140 */ 
     141const char *board_get_name(void) 
     142{ 
     143        return board.name; 
     144} 
     145 
     146/* 
     147 * register & return a new board mac address 
     148 */ 
     149 
     150static int board_get_mac_address(u8 *mac) 
     151{ 
     152        u8 default_mac[ETH_ALEN] = {0x00, 0x07, 0x3A, 0x00, 0x00, 0x00}; 
     153        u8 *p; 
     154        int count; 
     155 
     156        memcpy(mac, default_mac, ETH_ALEN); 
     157 
     158        p = mac + ETH_ALEN - 1; 
     159        count = mac_addr_used; 
     160 
     161        while (count--) { 
     162                do { 
     163                        (*p)++; 
     164                        if (*p != 0) 
     165                                break; 
     166                        p--; 
     167                } while (p != mac); 
     168        } 
     169 
     170        if (p == mac) { 
     171                printk(KERN_ERR PFX "unable to fetch mac address\n"); 
     172                return -ENODEV; 
     173        } 
     174        mac_addr_used++; 
     175 
     176        return 0; 
     177} 
     178 
     179#define MIPS_BASE       0xff400000 
     180#define RAC_CR0         0x00 /*offset*/ 
     181#define RAC_PF_I        (1 << 2) 
     182#define RAC_I           (1 << 0) 
     183#define RAC_CR1         0x04 /*offset*/ 
     184#define RAC_UPB_SHFT    16  
     185#define RAC_LWB_SHFT    0  
     186 
     187static void __cpuinit set_cpuregs(void) 
     188{ 
     189        volatile unsigned int *cr0, *cr1; 
     190        cr0 = (volatile unsigned int *)(MIPS_BASE + RAC_CR0); 
     191        cr1 = (volatile unsigned int *)(MIPS_BASE + RAC_CR1); 
     192 
     193        printk("board_livebox: setting cpu registers...\n"); 
     194         
     195        *cr0 = RAC_I | RAC_PF_I ; 
     196        *cr1 = (0x200 << RAC_UPB_SHFT); 
     197          printk("RAC changed: RAC_CR0 = 0x%0x, RAC_CR1 = 0x%0x\n", (int)*cr0, (int)*cr1); 
     198        /*REGISTER 12, SELECT 0*/ 
     199        write_c0_status(0x10000000); 
     200        /*REGISTER 16, SELECT 0*/ 
     201        write_c0_config(0x80008083); 
     202        /*REGISTER 22, SELECT 0*/ 
     203        write_c0_diag(0xe3880000);  
     204} 
     205 
     206/* 
     207 * early init callback 
     208 */ 
     209 
     210void __init board_prom_init(void) 
     211{ 
     212        u32 val; 
     213        u8 *boot_addr; 
     214         
     215 
     216        set_cpuregs(); 
     217 
     218        /* read base address of boot chip select (0) */ 
     219        val = bcm_mpi_readl(MPI_CSBASE_REG(0)); 
     220        val &= MPI_CSBASE_BASE_MASK; 
     221        boot_addr = (u8 *)KSEG1ADDR(val); 
     222        printk(KERN_INFO PFX "Boot address 0x%08x\n",(unsigned int)boot_addr); 
     223 
     224        /* assume board is a Livebox */ 
     225        memcpy(&board, bcm963xx_boards[0], sizeof(board)); 
     226 
     227        /* setup pin multiplexing depending on board enabled device, 
     228         * this has to be done this early since PCI init is done 
     229         * inside arch_initcall */ 
     230        val = 0; 
     231 
     232#ifdef CONFIG_PCI 
     233        if (board.has_pci) { 
     234                bcm63xx_pci_enabled = 1; 
     235                if (BCMCPU_IS_6348()) 
     236                        val |= GPIO_MODE_6348_G2_PCI; 
     237        } 
     238#endif 
     239        if (board.has_pccard) { 
     240                if (BCMCPU_IS_6348()) 
     241                        val |= GPIO_MODE_6348_G1_MII_PCCARD; 
     242        } 
     243 
     244        if (board.has_enet0 && !board.enet0.use_internal_phy) { 
     245                if (BCMCPU_IS_6348()) 
     246                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     247                                GPIO_MODE_6348_G0_EXT_MII; 
     248        } 
     249 
     250        if (board.has_enet1 && !board.enet1.use_internal_phy) { 
     251                if (BCMCPU_IS_6348()) 
     252                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     253                                GPIO_MODE_6348_G0_EXT_MII; 
     254                        printk(KERN_INFO PFX "resetting gpio6 for eth1...\n"); 
     255                        gpio_request(6, "dsp_eth_rst"); 
     256                        gpio_direction_output(6, 0); 
     257                        gpio_set_value(6, 1); 
     258        } 
     259 
     260        bcm_gpio_writel(val, GPIO_MODE_REG); 
     261} 
     262 
     263/* 
     264 * second stage init callback, good time to panic if we couldn't 
     265 * identify on which board we're running since early printk is working 
     266 */ 
     267void __init board_setup(void) 
     268{ 
     269        if (!board.name[0]) 
     270                panic("unable to detect bcm963xx board"); 
     271        printk(KERN_INFO PFX "board name: %s\n", board.name); 
     272 
     273        /* make sure we're running on expected cpu */ 
     274        if (bcm63xx_get_cpu_id() != board.expected_cpu_id) 
     275                panic("unexpected CPU for bcm963xx board"); 
     276} 
     277 
     278static struct resource mtd_resources[] = { 
     279        { 
     280                .start          = 0,    /* filled at runtime */ 
     281                .end            = 0,    /* filled at runtime */ 
     282                .flags          = IORESOURCE_MEM, 
     283        } 
     284}; 
     285 
     286static struct platform_device mtd_dev = { 
     287        .name                   = "bcm963xx-flash", 
     288        .resource               = mtd_resources, 
     289        .num_resources          = ARRAY_SIZE(mtd_resources), 
     290}; 
     291 
     292static struct resource gpiodev_resource = { 
     293        .start                  = 0xFFFFFFFF, 
     294}; 
     295 
     296static struct gpio_led_platform_data bcm63xx_led_data; 
     297 
     298static struct platform_device bcm63xx_gpio_leds = { 
     299        .name                   = "leds-gpio", 
     300        .id                     = 0, 
     301        .dev.platform_data      = &bcm63xx_led_data, 
     302}; 
     303 
     304static struct gpio_buttons_platform_data bcm63xx_gpio_buttons_data = { 
     305        .poll_interval  = 20, 
     306}; 
     307 
     308static struct platform_device bcm63xx_gpio_buttons_device = { 
     309        .name           = "gpio-buttons", 
     310        .id             = 0, 
     311        .dev.platform_data = &bcm63xx_gpio_buttons_data, 
     312}; 
     313 
     314/* 
     315 * third stage init callback, register all board devices. 
     316 */ 
     317int __init board_register_devices(void) 
     318{ 
     319        u32 val; 
     320        int led_count = 0; 
     321        int button_count = 0; 
     322 
     323        if (board.has_uart0) 
     324                bcm63xx_uart_register(0); 
     325 
     326        if (board.has_uart1) 
     327                bcm63xx_uart_register(1); 
     328 
     329        if (board.has_pccard) 
     330                bcm63xx_pcmcia_register(); 
     331 
     332        if (board.has_enet0 && 
     333            !board_get_mac_address(board.enet0.mac_addr)) 
     334                bcm63xx_enet_register(0, &board.enet0); 
     335 
     336        if (board.has_enet1 && 
     337            !board_get_mac_address(board.enet1.mac_addr)) 
     338                bcm63xx_enet_register(1, &board.enet1); 
     339 
     340        if (board.has_ehci0) 
     341                bcm63xx_ehci_register(); 
     342 
     343        if (board.has_ohci0) 
     344                bcm63xx_ohci_register(); 
     345 
     346        if (board.has_dsp) 
     347                bcm63xx_dsp_register(&board.dsp); 
     348 
     349        if (board.has_udc0) 
     350                bcm63xx_udc_register(); 
     351 
     352        if (board.num_devs) 
     353                platform_add_devices(board.devs, board.num_devs); 
     354 
     355        bcm63xx_spi_register(); 
     356         
     357        /* read base address of boot chip select (0) */ 
     358        val = bcm_mpi_readl(MPI_CSBASE_REG(0)); 
     359        val &= MPI_CSBASE_BASE_MASK; 
     360        printk(KERN_NOTICE "Livebox: mtd start address 0x%08lx --> 0x1e400000...\n", (long unsigned int)val); 
     361        mtd_resources[0].start = 0x1e400000; 
     362        mtd_resources[0].end = 0x1EBFFFFF; 
     363 
     364        platform_device_register(&mtd_dev); 
     365 
     366        platform_device_register_simple("GPIODEV", 0, &gpiodev_resource, 1); 
     367 
     368        /* count number of LEDs defined by this device */ 
     369        while (led_count < ARRAY_SIZE(board.leds) && board.leds[led_count].name) 
     370                led_count++; 
     371 
     372        bcm63xx_led_data.num_leds = led_count; 
     373        bcm63xx_led_data.leds = board.leds; 
     374 
     375        platform_device_register(&bcm63xx_gpio_leds); 
     376 
     377        /* count number of BUTTONs defined by this device */ 
     378        while (button_count < ARRAY_SIZE(board.buttons) && board.buttons[button_count].desc) 
     379                button_count++; 
     380 
     381        if (button_count) { 
     382                bcm63xx_gpio_buttons_data.nbuttons = button_count; 
     383                bcm63xx_gpio_buttons_data.buttons = board.buttons; 
     384 
     385                platform_device_register(&bcm63xx_gpio_buttons_device); 
     386        } 
     387 
     388        return 0; 
     389}