Ticket #8677: 454-board_livebox.2.patch

File 454-board_livebox.2.patch, 9.2 KB (added by danitool <dgcbueu@…>, 4 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  
    233233                printk(KERN_INFO PFX "assuming RedBoot bootloader\n"); 
    234234                if (bcm963xx_mtd_info->size > 0x00400000) { 
    235235                        printk(KERN_INFO PFX "Support for extended flash memory size : 0x%lx ; ONLY 64MBIT SUPPORT\n", bcm963xx_mtd_info->size); 
    236                         bcm963xx_map.virt = (u32)(BCM63XX_EXTENDED_SIZE); 
     236                        bcm963xx_map.virt = (u32)KSEG1ADDR(bcm963xx_map.phys); 
    237237                } 
    238238 
    239239#ifdef CONFIG_MTD_REDBOOT_PARTS 
  • 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        .enet0 = { 
     56                .has_phy                = 1, 
     57                .use_internal_phy       = 1, 
     58        }, 
     59 
     60        .enet1 = { 
     61                  .has_phy              = 1, 
     62                  .phy_id               = 31, 
     63        }, 
     64 
     65        .has_ohci0                      = 1, 
     66        .has_udc0                       = 1, 
     67        .has_pccard                     = 1, 
     68 
     69        .has_dsp                        = 0, /*TODO some Liveboxes have dsp*/ 
     70        .dsp = { 
     71                .gpio_rst               = 6, /*FIXME eth1 shares gpio6 with dsp?*/ 
     72                .gpio_int               = 35, 
     73                .cs                     = 2, 
     74                .ext_irq                = 2, 
     75        }, 
     76 
     77        .leds = { 
     78                { 
     79                        .name           = "adsl-fail", 
     80                        .gpio           = 0, 
     81                        .active_low     = 0, 
     82                        .default_trigger = "default-on", 
     83                }, 
     84                { 
     85                        .name           = "adsl", 
     86                        .gpio           = 1, 
     87                        .active_low     = 0, 
     88                }, 
     89                { 
     90                        .name           = "traffic", 
     91                        .gpio           = 2, 
     92                        .active_low     = 0, 
     93                }, 
     94                { 
     95                        .name           = "phone", 
     96                        .gpio           = 3, 
     97                        .active_low     = 0, 
     98                }, 
     99                { 
     100                        .name           = "wifi", 
     101                        .gpio           = 4, 
     102                        .active_low     = 0, 
     103                }, 
     104        }, 
     105 
     106        .buttons = { 
     107                { 
     108                        .desc           = "BTN_1", 
     109                        .gpio           = 36, 
     110                        .active_low     = 1, 
     111                        .type           = EV_KEY, 
     112                        .code           = BTN_1, 
     113                        .threshold      = 3, 
     114                }, 
     115                { 
     116                        .desc           = "BTN_2", 
     117                        .gpio           = 7, 
     118                        .active_low     = 1, 
     119                        .type           = EV_KEY, 
     120                        .code           = BTN_2, 
     121                        .threshold      = 3, 
     122                }, 
     123 
     124        }, 
     125}; 
     126#endif 
     127 
     128/* 
     129 * all boards 
     130 */ 
     131static const struct board_info __initdata *bcm963xx_boards[] = { 
     132#ifdef CONFIG_BCM63XX_CPU_6348 
     133        &board_livebox 
     134#endif 
     135}; 
     136/* 
     137 * return board name for /proc/cpuinfo 
     138 */ 
     139const char *board_get_name(void) 
     140{ 
     141        return board.name; 
     142} 
     143 
     144/* 
     145 * register & return a new board mac address 
     146 */ 
     147static int board_get_mac_address(u8 *mac) 
     148{ 
     149        u8 *p; 
     150        int count; 
     151 
     152        memcpy(mac, (u8 *)0xBEBFF377, ETH_ALEN); 
     153 
     154        p = mac + ETH_ALEN - 1; 
     155        count = mac_addr_used; 
     156 
     157        while (count--) { 
     158                do { 
     159                        (*p)++; 
     160                        if (*p != 0) 
     161                                break; 
     162                        p--; 
     163                } while (p != mac); 
     164        } 
     165 
     166        if (p == mac) { 
     167                printk(KERN_ERR PFX "unable to fetch mac address\n"); 
     168                return -ENODEV; 
     169        } 
     170        mac_addr_used++; 
     171 
     172        return 0; 
     173} 
     174 
     175/* 
     176 * early init callback 
     177 */ 
     178 
     179void __init board_prom_init(void) 
     180{ 
     181        u32 val; 
     182        unsigned char hw_version; 
     183 
     184        /* GET THE HARDWARE VERSION */ 
     185        val = bcm_gpio_readl(GPIO_CTL_LO_REG); 
     186        val &= ~0x000000FF; 
     187        bcm_gpio_writel(val, GPIO_CTL_LO_REG); 
     188        hw_version = (unsigned char)bcm_gpio_readl(GPIO_DATA_LO_REG) & 0xFF; 
     189        if (hw_version == 0x90) 
     190                printk(KERN_INFO PFX "Hardware version 0x%02X BLUE5G.9\n", hw_version); 
     191        else    printk(KERN_INFO PFX "Hardware version 0x%02X BLUE5G UNKNOWN\n", hw_version); 
     192              
     193        /*Print some critical registers*/ 
     194        printk("\nRAC_CR0 = 0x%0x, RAC_CR1 = 0x%0x\n", *(volatile unsigned int *)0xFF400000, 
     195               *(volatile unsigned int *)0xFF400004); 
     196        printk("C0 register($16, 0): 0x%x\n", read_c0_config()); 
     197        printk("C0 register($22, 0): 0x%x\n\n", read_c0_diag()); 
     198 
     199        /* assume board is a Livebox */ 
     200        memcpy(&board, bcm963xx_boards[0], sizeof(board)); 
     201 
     202        /* setup pin multiplexing depending on board enabled device, 
     203         * this has to be done this early since PCI init is done 
     204         * inside arch_initcall */ 
     205        val = 0; 
     206 
     207#ifdef CONFIG_PCI 
     208        if (board.has_pci) { 
     209                bcm63xx_pci_enabled = 1; 
     210                if (BCMCPU_IS_6348()) 
     211                        val |= GPIO_MODE_6348_G2_PCI; 
     212        } 
     213#endif 
     214        if (board.has_pccard) { 
     215                if (BCMCPU_IS_6348()) 
     216                        val |= GPIO_MODE_6348_G1_MII_PCCARD; 
     217        } 
     218 
     219        if (board.has_enet0 && !board.enet0.use_internal_phy) { 
     220                if (BCMCPU_IS_6348()) 
     221                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     222                                GPIO_MODE_6348_G0_EXT_MII; 
     223        } 
     224 
     225        if (board.has_enet1 && !board.enet1.use_internal_phy) { 
     226                if (BCMCPU_IS_6348()) 
     227                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     228                                GPIO_MODE_6348_G0_EXT_MII; 
     229                        printk(KERN_INFO PFX "resetting gpio6 for eth1...\n"); 
     230                        gpio_request(6, "dsp_eth_rst"); 
     231                        gpio_direction_output(6, 0); 
     232                        gpio_set_value(6, 1); 
     233        } 
     234 
     235        bcm_gpio_writel(val, GPIO_MODE_REG); 
     236} 
     237 
     238/* 
     239 * second stage init callback, good time to panic if we couldn't 
     240 * identify on which board we're running since early printk is working 
     241 */ 
     242void __init board_setup(void) 
     243{ 
     244        if (!board.name[0]) 
     245                panic("unable to detect bcm963xx board"); 
     246        printk(KERN_INFO PFX "board name: %s\n", board.name); 
     247 
     248        /* make sure we're running on expected cpu */ 
     249        if (bcm63xx_get_cpu_id() != board.expected_cpu_id) 
     250                panic("unexpected CPU for bcm963xx board"); 
     251} 
     252 
     253static struct resource mtd_resources[] = { 
     254        { 
     255                .start          = 0,    /* filled at runtime */ 
     256                .end            = 0,    /* filled at runtime */ 
     257                .flags          = IORESOURCE_MEM, 
     258        } 
     259}; 
     260 
     261static struct platform_device mtd_dev = { 
     262        .name                   = "bcm963xx-flash", 
     263        .resource               = mtd_resources, 
     264        .num_resources          = ARRAY_SIZE(mtd_resources), 
     265}; 
     266 
     267static struct resource gpiodev_resource = { 
     268        .start                  = 0xFFFFFFFF, 
     269}; 
     270 
     271static struct gpio_led_platform_data bcm63xx_led_data; 
     272 
     273static struct platform_device bcm63xx_gpio_leds = { 
     274        .name                   = "leds-gpio", 
     275        .id                     = 0, 
     276        .dev.platform_data      = &bcm63xx_led_data, 
     277}; 
     278 
     279static struct gpio_buttons_platform_data bcm63xx_gpio_buttons_data = { 
     280        .poll_interval  = 20, 
     281}; 
     282 
     283static struct platform_device bcm63xx_gpio_buttons_device = { 
     284        .name           = "gpio-buttons", 
     285        .id             = 0, 
     286        .dev.platform_data = &bcm63xx_gpio_buttons_data, 
     287}; 
     288 
     289/* 
     290 * third stage init callback, register all board devices. 
     291 */ 
     292int __init board_register_devices(void) 
     293{ 
     294        u32 val; 
     295        int led_count = 0; 
     296        int button_count = 0; 
     297 
     298        if (board.has_uart0) 
     299                bcm63xx_uart_register(0); 
     300 
     301        if (board.has_uart1) 
     302                bcm63xx_uart_register(1); 
     303 
     304        if (board.has_pccard) 
     305                bcm63xx_pcmcia_register(); 
     306 
     307        if (board.has_enet0 && 
     308            !board_get_mac_address(board.enet0.mac_addr)) 
     309                bcm63xx_enet_register(0, &board.enet0); 
     310 
     311        if (board.has_enet1 && 
     312            !board_get_mac_address(board.enet1.mac_addr)) 
     313                bcm63xx_enet_register(1, &board.enet1); 
     314 
     315        if (board.has_ehci0) 
     316                bcm63xx_ehci_register(); 
     317 
     318        if (board.has_ohci0) 
     319                bcm63xx_ohci_register(); 
     320 
     321        if (board.has_dsp) 
     322                bcm63xx_dsp_register(&board.dsp); 
     323 
     324        if (board.has_udc0) 
     325                bcm63xx_udc_register(); 
     326 
     327        bcm63xx_spi_register(); 
     328         
     329        /* read base address of boot chip select (0) */ 
     330        val = bcm_mpi_readl(MPI_CSBASE_REG(0)); 
     331        val &= MPI_CSBASE_BASE_MASK; 
     332                printk(KERN_NOTICE "detected mtd start address 0x%02X, but forcing to 0x1e400000...\n", val); 
     333        mtd_resources[0].start = 0x1e400000; 
     334        mtd_resources[0].end = 0x1EBFFFFF; 
     335 
     336        platform_device_register(&mtd_dev); 
     337 
     338        platform_device_register_simple("GPIODEV", 0, &gpiodev_resource, 1); 
     339 
     340        /* count number of LEDs defined by this device */ 
     341        while (led_count < ARRAY_SIZE(board.leds) && board.leds[led_count].name) 
     342                led_count++; 
     343 
     344        bcm63xx_led_data.num_leds = led_count; 
     345        bcm63xx_led_data.leds = board.leds; 
     346 
     347        platform_device_register(&bcm63xx_gpio_leds); 
     348 
     349        /* count number of BUTTONs defined by this device */ 
     350        while (button_count < ARRAY_SIZE(board.buttons) && board.buttons[button_count].desc) 
     351                button_count++; 
     352 
     353        if (button_count) { 
     354                bcm63xx_gpio_buttons_data.nbuttons = button_count; 
     355                bcm63xx_gpio_buttons_data.buttons = board.buttons; 
     356 
     357                platform_device_register(&bcm63xx_gpio_buttons_device); 
     358        } 
     359 
     360        return 0; 
     361}