source: trunk/target/linux/brcm47xx/patches-3.0/0004-bcma-add-SOC-bus.patch @ 27301

Last change on this file since 27301 was 27301, checked in by hauke, 5 years ago

brcm47xx: add initial support for devices with bcma bus.

Ethernet and wifi are not working and this is highly experimental.

File size: 7.5 KB
  • drivers/bcma/Kconfig

    From a807b2fb233af60028ed38ba237953bcffdf33e9 Mon Sep 17 00:00:00 2001
    From: Hauke Mehrtens <hauke@hauke-m.de>
    Date: Sat, 18 Jun 2011 14:31:53 +0200
    Subject: [PATCH 04/14] bcma: add SOC bus
    
    This patch adds support for using bcma on an embedded bus. An embedded
    system like the bcm4716 could register this bus and it searches for the
    bcma cores then.
    
    Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
    ---
     drivers/bcma/Kconfig          |    5 +
     drivers/bcma/Makefile         |    1 +
     drivers/bcma/host_soc.c       |  178 +++++++++++++++++++++++++++++++++++++++++
     drivers/bcma/main.c           |    1 +
     drivers/bcma/scan.c           |   24 +++++-
     include/linux/bcma/bcma.h     |    4 +
     include/linux/bcma/bcma_soc.h |   16 ++++
     7 files changed, 227 insertions(+), 2 deletions(-)
     create mode 100644 drivers/bcma/host_soc.c
     create mode 100644 include/linux/bcma/bcma_soc.h
    
    a b config BCMA_HOST_PCI 
    2727        bool "Support for BCMA on PCI-host bus" 
    2828        depends on BCMA_HOST_PCI_POSSIBLE 
    2929 
     30config BCMA_HOST_SOC 
     31        bool 
     32        depends on BCMA && MIPS 
     33        default n 
     34 
    3035config BCMA_DEBUG 
    3136        bool "BCMA debugging" 
    3237        depends on BCMA 
  • drivers/bcma/Makefile

    a b bcma-y += main.o scan.o core.o sprom 
    22bcma-y                                  += driver_chipcommon.o driver_chipcommon_pmu.o 
    33bcma-y                                  += driver_pci.o 
    44bcma-$(CONFIG_BCMA_HOST_PCI)            += host_pci.o 
     5bcma-$(CONFIG_BCMA_HOST_SOC)            += host_soc.o 
    56obj-$(CONFIG_BCMA)                      += bcma.o 
    67 
    78ccflags-$(CONFIG_BCMA_DEBUG)            := -DDEBUG 
  • new file drivers/bcma/host_soc.c

    - +  
     1/* 
     2 * Broadcom specific AMBA 
     3 * System on Chip (SoC) Host 
     4 * 
     5 * Licensed under the GNU/GPL. See COPYING for details. 
     6 */ 
     7 
     8#include "bcma_private.h" 
     9#include "scan.h" 
     10#include <linux/bcma/bcma.h> 
     11#include <linux/bcma/bcma_soc.h> 
     12 
     13static u8 bcma_host_soc_read8(struct bcma_device *core, u16 offset) 
     14{ 
     15        return readb(core->io_addr + offset); 
     16} 
     17 
     18static u16 bcma_host_soc_read16(struct bcma_device *core, u16 offset) 
     19{ 
     20        return readw(core->io_addr + offset); 
     21} 
     22 
     23static u32 bcma_host_soc_read32(struct bcma_device *core, u16 offset) 
     24{ 
     25        return readl(core->io_addr + offset); 
     26} 
     27 
     28static void bcma_host_soc_write8(struct bcma_device *core, u16 offset, 
     29                                 u8 value) 
     30{ 
     31        writeb(value, core->io_addr + offset); 
     32} 
     33 
     34static void bcma_host_soc_write16(struct bcma_device *core, u16 offset, 
     35                                 u16 value) 
     36{ 
     37        writew(value, core->io_addr + offset); 
     38} 
     39 
     40static void bcma_host_soc_write32(struct bcma_device *core, u16 offset, 
     41                                 u32 value) 
     42{ 
     43        writel(value, core->io_addr + offset); 
     44} 
     45 
     46#ifdef CONFIG_BCMA_BLOCKIO 
     47static void bcma_host_soc_block_read(struct bcma_device *core, void *buffer, 
     48                                     size_t count, u16 offset, u8 reg_width) 
     49{ 
     50        void __iomem *addr = core->io_addr + offset; 
     51 
     52        switch (reg_width) { 
     53        case sizeof(u8): { 
     54                u8 *buf = buffer; 
     55 
     56                while (count) { 
     57                        *buf = __raw_readb(addr); 
     58                        buf++; 
     59                        count--; 
     60                } 
     61                break; 
     62        } 
     63        case sizeof(u16): { 
     64                __le16 *buf = buffer; 
     65 
     66                WARN_ON(count & 1); 
     67                while (count) { 
     68                        *buf = (__force __le16)__raw_readw(addr); 
     69                        buf++; 
     70                        count -= 2; 
     71                } 
     72                break; 
     73        } 
     74        case sizeof(u32): { 
     75                __le32 *buf = buffer; 
     76 
     77                WARN_ON(count & 3); 
     78                while (count) { 
     79                        *buf = (__force __le32)__raw_readl(addr); 
     80                        buf++; 
     81                        count -= 4; 
     82                } 
     83                break; 
     84        } 
     85        default: 
     86                WARN_ON(1); 
     87        } 
     88} 
     89 
     90static void bcma_host_soc_block_write(struct bcma_device *core, 
     91                                      const void *buffer, 
     92                                      size_t count, u16 offset, u8 reg_width) 
     93{ 
     94        void __iomem *addr = core->io_addr + offset; 
     95 
     96        switch (reg_width) { 
     97        case sizeof(u8): { 
     98                const u8 *buf = buffer; 
     99 
     100                while (count) { 
     101                        __raw_writeb(*buf, addr); 
     102                        buf++; 
     103                        count--; 
     104                } 
     105                break; 
     106        } 
     107        case sizeof(u16): { 
     108                const __le16 *buf = buffer; 
     109 
     110                WARN_ON(count & 1); 
     111                while (count) { 
     112                        __raw_writew((__force u16)(*buf), addr); 
     113                        buf++; 
     114                        count -= 2; 
     115                } 
     116                break; 
     117        } 
     118        case sizeof(u32): { 
     119                const __le32 *buf = buffer; 
     120 
     121                WARN_ON(count & 3); 
     122                while (count) { 
     123                        __raw_writel((__force u32)(*buf), addr); 
     124                        buf++; 
     125                        count -= 4; 
     126                } 
     127                break; 
     128        } 
     129        default: 
     130                WARN_ON(1); 
     131        } 
     132} 
     133#endif /* CONFIG_BCMA_BLOCKIO */ 
     134 
     135static u32 bcma_host_soc_aread32(struct bcma_device *core, u16 offset) 
     136{ 
     137        return readl(core->io_wrap + offset); 
     138} 
     139 
     140static void bcma_host_soc_awrite32(struct bcma_device *core, u16 offset, 
     141                                  u32 value) 
     142{ 
     143        writel(value, core->io_wrap + offset); 
     144} 
     145 
     146const struct bcma_host_ops bcma_host_soc_ops = { 
     147        .read8          = bcma_host_soc_read8, 
     148        .read16         = bcma_host_soc_read16, 
     149        .read32         = bcma_host_soc_read32, 
     150        .write8         = bcma_host_soc_write8, 
     151        .write16        = bcma_host_soc_write16, 
     152        .write32        = bcma_host_soc_write32, 
     153#ifdef CONFIG_BCMA_BLOCKIO 
     154        .block_read     = bcma_host_soc_block_read, 
     155        .block_write    = bcma_host_soc_block_write, 
     156#endif 
     157        .aread32        = bcma_host_soc_aread32, 
     158        .awrite32       = bcma_host_soc_awrite32, 
     159}; 
     160 
     161int __init bcma_host_soc_register(struct bcma_soc *soc) 
     162{ 
     163        struct bcma_bus *bus = &soc->bus; 
     164 
     165        /* iomap only first core. We have to read some register on this core 
     166         * to scan the bus. 
     167         */ 
     168        bus->mmio = ioremap(BCMA_ADDR_BASE, BCMA_CORE_SIZE * 1); 
     169        if (!bus->mmio) 
     170                return -ENOMEM; 
     171 
     172        /* Host specific */ 
     173        bus->hosttype = BCMA_HOSTTYPE_SOC; 
     174        bus->ops = &bcma_host_soc_ops; 
     175 
     176        /* Register */ 
     177        return bcma_bus_early_register(bus, &soc->core_cc, &soc->core_mips); 
     178} 
  • drivers/bcma/main.c

    a b static int bcma_register_cores(struct bc 
    9595                        break; 
    9696                case BCMA_HOSTTYPE_NONE: 
    9797                case BCMA_HOSTTYPE_SDIO: 
     98                case BCMA_HOSTTYPE_SOC: 
    9899                        break; 
    99100                } 
    100101 
  • drivers/bcma/scan.c

    a b static int bcma_get_next_core(struct bcm 
    337337                        } 
    338338                } 
    339339        } 
     340        if (bus->hosttype == BCMA_HOSTTYPE_SOC) { 
     341                core->io_addr = ioremap(core->addr, BCMA_CORE_SIZE); 
     342                if (!core->io_addr) 
     343                        return -ENOMEM; 
     344                core->io_wrap = ioremap(core->wrap, BCMA_CORE_SIZE); 
     345                if (!core->io_wrap) 
     346                        return -ENOMEM; 
     347        } 
    340348        return 0; 
    341349} 
    342350 
    int bcma_bus_scan(struct bcma_bus *bus) 
    369377        bcma_init_bus(bus); 
    370378 
    371379        erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM); 
    372         eromptr = bus->mmio; 
     380        if (bus->hosttype == BCMA_HOSTTYPE_SOC) { 
     381                eromptr = ioremap(erombase, BCMA_CORE_SIZE); 
     382                if (!eromptr) 
     383                        return -ENOMEM; 
     384        } else 
     385                eromptr = bus->mmio; 
     386 
    373387        eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32); 
    374388 
    375389        bcma_scan_switch_core(bus, erombase); 
    int __init bcma_bus_scan_early(struct bc 
    417431        int err, core_num = 0; 
    418432 
    419433        erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM); 
    420         eromptr = bus->mmio; 
     434        if (bus->hosttype == BCMA_HOSTTYPE_SOC) { 
     435                eromptr = ioremap(erombase, BCMA_CORE_SIZE); 
     436                if (!eromptr) 
     437                        return -ENOMEM; 
     438        } else 
     439                eromptr = bus->mmio; 
     440 
    421441        eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32); 
    422442 
    423443        bcma_scan_switch_core(bus, erombase); 
  • include/linux/bcma/bcma.h

    a b enum bcma_hosttype { 
    1717        BCMA_HOSTTYPE_NONE, 
    1818        BCMA_HOSTTYPE_PCI, 
    1919        BCMA_HOSTTYPE_SDIO, 
     20        BCMA_HOSTTYPE_SOC, 
    2021}; 
    2122 
    2223struct bcma_chipinfo { 
    struct bcma_device { 
    133134        u32 addr; 
    134135        u32 wrap; 
    135136 
     137        void __iomem *io_addr; 
     138        void __iomem *io_wrap; 
     139 
    136140        void *drvdata; 
    137141        struct list_head list; 
    138142}; 
  • new file include/linux/bcma/bcma_soc.h

    - +  
     1#ifndef LINUX_BCMA_SOC_H_ 
     2#define LINUX_BCMA_SOC_H_ 
     3 
     4#include <linux/bcma/bcma.h> 
     5 
     6struct bcma_soc { 
     7        struct bcma_bus bus; 
     8        struct bcma_device core_cc; 
     9        struct bcma_device core_mips; 
     10}; 
     11 
     12int __init bcma_host_soc_register(struct bcma_soc *soc); 
     13 
     14int bcma_bus_register(struct bcma_bus *bus); 
     15 
     16#endif /* LINUX_BCMA_SOC_H_ */ 
Note: See TracBrowser for help on using the repository browser.