source: trunk/target/linux/brcm63xx/patches-2.6.37/456-board_livebox.patch @ 27012

Last change on this file since 27012 was 27012, checked in by florian, 5 years ago

[brcm63xx] renumber board patches

File size: 5.5 KB
  • 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 
    34EXTRA_CFLAGS += -Werror 
  • 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/input.h> 
     17#include <linux/gpio_buttons.h> 
     18#include <asm/addrspace.h> 
     19#include <bcm63xx_board.h> 
     20#include <bcm63xx_cpu.h> 
     21#include <bcm63xx_regs.h> 
     22#include <bcm63xx_io.h> 
     23#include <bcm63xx_dev_uart.h> 
     24#include <bcm63xx_dev_pci.h> 
     25#include <bcm63xx_dev_enet.h> 
     26#include <bcm63xx_dev_pcmcia.h> 
     27#include <bcm63xx_dev_usb_ohci.h> 
     28#include <bcm63xx_dev_usb_ehci.h> 
     29#include <board_bcm963xx.h> 
     30 
     31#define PFX     "board_livebox: " 
     32 
     33static unsigned int mac_addr_used = 0; 
     34static struct board_info board; 
     35 
     36/* 
     37 * known 6348 boards 
     38 */ 
     39#ifdef CONFIG_BCM63XX_CPU_6348 
     40static struct board_info __initdata board_livebox = { 
     41        .name                           = "Livebox", 
     42        .expected_cpu_id                = 0x6348, 
     43 
     44        .has_uart0                      = 1, 
     45        .has_enet0                      = 1, 
     46        .has_enet1                      = 1, 
     47        .has_pci                        = 1, 
     48 
     49        .enet0 = { 
     50                .has_phy                = 1, 
     51                .use_internal_phy       = 1, 
     52        }, 
     53 
     54        .enet1 = { 
     55                .force_speed_100        = 1, 
     56                .force_duplex_full      = 1, 
     57        }, 
     58 
     59        .has_ohci0                      = 1, 
     60        .has_pccard                     = 1, 
     61        .has_ehci0                      = 1, 
     62}; 
     63#endif 
     64 
     65/* 
     66 * all boards 
     67 */ 
     68static const struct board_info __initdata *bcm963xx_boards[] = { 
     69#ifdef CONFIG_BCM63XX_CPU_6348 
     70        &board_livebox 
     71#endif 
     72}; 
     73 
     74/* 
     75 * early init callback 
     76 */ 
     77void __init board_prom_init(void) 
     78{ 
     79        u32 val; 
     80 
     81        /* read base address of boot chip select (0) */ 
     82        val = bcm_mpi_readl(MPI_CSBASE_REG(0)); 
     83        val &= MPI_CSBASE_BASE_MASK; 
     84 
     85        /* assume board is a Livebox */ 
     86        memcpy(&board, bcm963xx_boards[0], sizeof(board)); 
     87 
     88        /* setup pin multiplexing depending on board enabled device, 
     89         * this has to be done this early since PCI init is done 
     90         * inside arch_initcall */ 
     91        val = 0; 
     92 
     93        if (board.has_pci) { 
     94                bcm63xx_pci_enabled = 1; 
     95                if (BCMCPU_IS_6348()) 
     96                        val |= GPIO_MODE_6348_G2_PCI; 
     97        } 
     98 
     99        if (board.has_pccard) { 
     100                if (BCMCPU_IS_6348()) 
     101                        val |= GPIO_MODE_6348_G1_MII_PCCARD; 
     102        } 
     103 
     104        if (board.has_enet0 && !board.enet0.use_internal_phy) { 
     105                if (BCMCPU_IS_6348()) 
     106                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     107                                GPIO_MODE_6348_G0_EXT_MII; 
     108        } 
     109 
     110        if (board.has_enet1 && !board.enet1.use_internal_phy) { 
     111                if (BCMCPU_IS_6348()) 
     112                        val |= GPIO_MODE_6348_G3_EXT_MII | 
     113                                GPIO_MODE_6348_G0_EXT_MII; 
     114        } 
     115 
     116        bcm_gpio_writel(val, GPIO_MODE_REG); 
     117} 
     118 
     119/* 
     120 * second stage init callback, good time to panic if we couldn't 
     121 * identify on which board we're running since early printk is working 
     122 */ 
     123void __init board_setup(void) 
     124{ 
     125        if (!board.name[0]) 
     126                panic("unable to detect bcm963xx board"); 
     127        printk(KERN_INFO PFX "board name: %s\n", board.name); 
     128 
     129        /* make sure we're running on expected cpu */ 
     130        if (bcm63xx_get_cpu_id() != board.expected_cpu_id) 
     131                panic("unexpected CPU for bcm963xx board"); 
     132} 
     133 
     134/* 
     135 * return board name for /proc/cpuinfo 
     136 */ 
     137const char *board_get_name(void) 
     138{ 
     139        return board.name; 
     140} 
     141 
     142/* 
     143 * register & return a new board mac address 
     144 */ 
     145 
     146static int board_get_mac_address(u8 *mac) 
     147{ 
     148        u8 default_mac[ETH_ALEN] = {0x00, 0x07, 0x3A, 0x00, 0x00, 0x00}; 
     149        u8 *p; 
     150        int count; 
     151 
     152        memcpy(mac, default_mac, 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 
     175static struct resource mtd_resources[] = { 
     176        { 
     177                .start          = 0,    /* filled at runtime */ 
     178                .end            = 0,    /* filled at runtime */ 
     179                .flags          = IORESOURCE_MEM, 
     180        } 
     181}; 
     182 
     183static struct platform_device mtd_dev = { 
     184        .name                   = "bcm963xx-flash", 
     185        .resource               = mtd_resources, 
     186        .num_resources          = ARRAY_SIZE(mtd_resources), 
     187}; 
     188 
     189 
     190/* 
     191 * third stage init callback, register all board devices. 
     192 */ 
     193int __init board_register_devices(void) 
     194{ 
     195        u32 val; 
     196 
     197        if (board.has_uart0) 
     198                bcm63xx_uart_register(0); 
     199 
     200        if (board.has_pccard) 
     201                bcm63xx_pcmcia_register(); 
     202 
     203        if (board.has_enet0 && 
     204            !board_get_mac_address(board.enet0.mac_addr)) 
     205                bcm63xx_enet_register(0, &board.enet0); 
     206 
     207        if (board.has_enet1 && 
     208            !board_get_mac_address(board.enet1.mac_addr)) 
     209                bcm63xx_enet_register(1, &board.enet1); 
     210 
     211        if (board.has_ohci0) 
     212                bcm63xx_ohci_register(); 
     213 
     214        if (board.has_ehci0) 
     215                bcm63xx_ehci_register(); 
     216 
     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        mtd_resources[0].start = val; 
     222        mtd_resources[0].end = 0x1FFFFFFF; 
     223 
     224        platform_device_register(&mtd_dev); 
     225 
     226        return 0; 
     227} 
     228 
Note: See TracBrowser for help on using the repository browser.