source: trunk/target/linux/generic/patches-3.0/025-bcma_backport.patch @ 27293

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

kernel: update ssb and bcma to linux-next next-20110627

File size: 13.9 KB
  • drivers/bcma/Kconfig

    a b config BCMA 
    1313          Bus driver for Broadcom specific Advanced Microcontroller Bus 
    1414          Architecture. 
    1515 
     16# Support for Block-I/O. SELECT this from the driver that needs it. 
     17config BCMA_BLOCKIO 
     18        bool 
     19        depends on BCMA 
     20 
    1621config BCMA_HOST_PCI_POSSIBLE 
    1722        bool 
    1823        depends on BCMA && PCI = y 
  • drivers/bcma/Makefile

    a b  
    1 bcma-y                                  += main.o scan.o core.o 
     1bcma-y                                  += main.o scan.o core.o sprom.o 
    22bcma-y                                  += driver_chipcommon.o driver_chipcommon_pmu.o 
    33bcma-y                                  += driver_pci.o 
    44bcma-$(CONFIG_BCMA_HOST_PCI)            += host_pci.o 
  • drivers/bcma/bcma_private.h

    a b  
    1313struct bcma_bus; 
    1414 
    1515/* main.c */ 
    16 extern int bcma_bus_register(struct bcma_bus *bus); 
    17 extern void bcma_bus_unregister(struct bcma_bus *bus); 
     16int bcma_bus_register(struct bcma_bus *bus); 
     17void bcma_bus_unregister(struct bcma_bus *bus); 
    1818 
    1919/* scan.c */ 
    2020int bcma_bus_scan(struct bcma_bus *bus); 
    2121 
     22/* sprom.c */ 
     23int bcma_sprom_get(struct bcma_bus *bus); 
     24 
    2225#ifdef CONFIG_BCMA_HOST_PCI 
    2326/* host_pci.c */ 
    2427extern int __init bcma_host_pci_init(void); 
  • drivers/bcma/core.c

    a b bool bcma_core_is_enabled(struct bcma_de 
    1919} 
    2020EXPORT_SYMBOL_GPL(bcma_core_is_enabled); 
    2121 
    22 static void bcma_core_disable(struct bcma_device *core, u32 flags) 
     22void bcma_core_disable(struct bcma_device *core, u32 flags) 
    2323{ 
    2424        if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET) 
    2525                return; 
    static void bcma_core_disable(struct bcm 
    3131        bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET); 
    3232        udelay(1); 
    3333} 
     34EXPORT_SYMBOL_GPL(bcma_core_disable); 
    3435 
    3536int bcma_core_enable(struct bcma_device *core, u32 flags) 
    3637{ 
  • drivers/bcma/driver_chipcommon_pmu.c

    a b static void bcma_pmu_resources_init(stru 
    5353                max_msk = 0xFFFF; 
    5454                break; 
    5555        case 43224: 
     56        case 43225: 
    5657                break; 
    5758        default: 
    5859                pr_err("PMU resource config unknown for device 0x%04X\n", 
    void bcma_pmu_swreg_init(struct bcma_drv 
    7475        case 0x4313: 
    7576        case 0x4331: 
    7677        case 43224: 
     78        case 43225: 
    7779                break; 
    7880        default: 
    7981                pr_err("PMU switch/regulators init unknown for device " 
    void bcma_pmu_workarounds(struct bcma_dr 
    9698                if (bus->chipinfo.rev == 0) { 
    9799                        pr_err("Workarounds for 43224 rev 0 not fully " 
    98100                                "implemented\n"); 
    99                         bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0); 
     101                        bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x00F000F0); 
    100102                } else { 
    101103                        bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0); 
    102104                } 
    103105                break; 
     106        case 43225: 
     107                break; 
    104108        default: 
    105109                pr_err("Workarounds unknown for device 0x%04X\n", 
    106110                        bus->chipinfo.id); 
  • drivers/bcma/driver_pci.c

    a b void bcma_core_pci_init(struct bcma_drv_ 
    161161{ 
    162162        bcma_pcicore_serdes_workaround(pc); 
    163163} 
     164 
     165int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core, 
     166                          bool enable) 
     167{ 
     168        struct pci_dev *pdev = pc->core->bus->host_pci; 
     169        u32 coremask, tmp; 
     170        int err; 
     171 
     172        err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp); 
     173        if (err) 
     174                goto out; 
     175 
     176        coremask = BIT(core->core_index) << 8; 
     177        if (enable) 
     178                tmp |= coremask; 
     179        else 
     180                tmp &= ~coremask; 
     181 
     182        err = pci_write_config_dword(pdev, BCMA_PCI_IRQMASK, tmp); 
     183 
     184out: 
     185        return err; 
     186} 
     187EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl); 
  • drivers/bcma/host_pci.c

    a b static void bcma_host_pci_write32(struct 
    6565        iowrite32(value, core->bus->mmio + offset); 
    6666} 
    6767 
     68#ifdef CONFIG_BCMA_BLOCKIO 
     69void bcma_host_pci_block_read(struct bcma_device *core, void *buffer, 
     70                              size_t count, u16 offset, u8 reg_width) 
     71{ 
     72        void __iomem *addr = core->bus->mmio + offset; 
     73        if (core->bus->mapped_core != core) 
     74                bcma_host_pci_switch_core(core); 
     75        switch (reg_width) { 
     76        case sizeof(u8): 
     77                ioread8_rep(addr, buffer, count); 
     78                break; 
     79        case sizeof(u16): 
     80                WARN_ON(count & 1); 
     81                ioread16_rep(addr, buffer, count >> 1); 
     82                break; 
     83        case sizeof(u32): 
     84                WARN_ON(count & 3); 
     85                ioread32_rep(addr, buffer, count >> 2); 
     86                break; 
     87        default: 
     88                WARN_ON(1); 
     89        } 
     90} 
     91 
     92void bcma_host_pci_block_write(struct bcma_device *core, const void *buffer, 
     93                               size_t count, u16 offset, u8 reg_width) 
     94{ 
     95        void __iomem *addr = core->bus->mmio + offset; 
     96        if (core->bus->mapped_core != core) 
     97                bcma_host_pci_switch_core(core); 
     98        switch (reg_width) { 
     99        case sizeof(u8): 
     100                iowrite8_rep(addr, buffer, count); 
     101                break; 
     102        case sizeof(u16): 
     103                WARN_ON(count & 1); 
     104                iowrite16_rep(addr, buffer, count >> 1); 
     105                break; 
     106        case sizeof(u32): 
     107                WARN_ON(count & 3); 
     108                iowrite32_rep(addr, buffer, count >> 2); 
     109                break; 
     110        default: 
     111                WARN_ON(1); 
     112        } 
     113} 
     114#endif 
     115 
    68116static u32 bcma_host_pci_aread32(struct bcma_device *core, u16 offset) 
    69117{ 
    70118        if (core->bus->mapped_core != core) 
    const struct bcma_host_ops bcma_host_pci 
    87135        .write8         = bcma_host_pci_write8, 
    88136        .write16        = bcma_host_pci_write16, 
    89137        .write32        = bcma_host_pci_write32, 
     138#ifdef CONFIG_BCMA_BLOCKIO 
     139        .block_read     = bcma_host_pci_block_read, 
     140        .block_write    = bcma_host_pci_block_write, 
     141#endif 
    90142        .aread32        = bcma_host_pci_aread32, 
    91143        .awrite32       = bcma_host_pci_awrite32, 
    92144}; 
    static DEFINE_PCI_DEVICE_TABLE(bcma_pci_ 
    175227        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) }, 
    176228        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331) }, 
    177229        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4353) }, 
     230        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4357) }, 
    178231        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4727) }, 
    179232        { 0, }, 
    180233}; 
  • drivers/bcma/main.c

    a b static int bcma_register_cores(struct bc 
    8989                switch (bus->hosttype) { 
    9090                case BCMA_HOSTTYPE_PCI: 
    9191                        core->dev.parent = &bus->host_pci->dev; 
     92                        core->dma_dev = &bus->host_pci->dev; 
     93                        core->irq = bus->host_pci->irq; 
    9294                        break; 
    9395                case BCMA_HOSTTYPE_NONE: 
    9496                case BCMA_HOSTTYPE_SDIO: 
    int bcma_bus_register(struct bcma_bus *b 
    144146                bcma_core_pci_init(&bus->drv_pci); 
    145147        } 
    146148 
     149        /* Try to get SPROM */ 
     150        err = bcma_sprom_get(bus); 
     151        if (err) { 
     152                pr_err("Failed to get SPROM: %d\n", err); 
     153                return -ENOENT; 
     154        } 
     155 
    147156        /* Register found cores */ 
    148157        bcma_register_cores(bus); 
    149158 
    int bcma_bus_register(struct bcma_bus *b 
    151160 
    152161        return 0; 
    153162} 
    154 EXPORT_SYMBOL_GPL(bcma_bus_register); 
    155163 
    156164void bcma_bus_unregister(struct bcma_bus *bus) 
    157165{ 
    158166        bcma_unregister_cores(bus); 
    159167} 
    160 EXPORT_SYMBOL_GPL(bcma_bus_unregister); 
    161168 
    162169int __bcma_driver_register(struct bcma_driver *drv, struct module *owner) 
    163170{ 
  • new file drivers/bcma/sprom.c

    - +  
     1/* 
     2 * Broadcom specific AMBA 
     3 * SPROM reading 
     4 * 
     5 * Licensed under the GNU/GPL. See COPYING for details. 
     6 */ 
     7 
     8#include "bcma_private.h" 
     9 
     10#include <linux/bcma/bcma.h> 
     11#include <linux/bcma/bcma_regs.h> 
     12#include <linux/pci.h> 
     13#include <linux/io.h> 
     14#include <linux/dma-mapping.h> 
     15#include <linux/slab.h> 
     16 
     17#define SPOFF(offset)   ((offset) / sizeof(u16)) 
     18 
     19/************************************************** 
     20 * R/W ops. 
     21 **************************************************/ 
     22 
     23static void bcma_sprom_read(struct bcma_bus *bus, u16 *sprom) 
     24{ 
     25        int i; 
     26        for (i = 0; i < SSB_SPROMSIZE_WORDS_R4; i++) 
     27                sprom[i] = bcma_read16(bus->drv_cc.core, 
     28                                       BCMA_CC_SPROM + (i * 2)); 
     29} 
     30 
     31/************************************************** 
     32 * Validation. 
     33 **************************************************/ 
     34 
     35static inline u8 bcma_crc8(u8 crc, u8 data) 
     36{ 
     37        /* Polynomial:   x^8 + x^7 + x^6 + x^4 + x^2 + 1   */ 
     38        static const u8 t[] = { 
     39                0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B, 
     40                0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21, 
     41                0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF, 
     42                0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5, 
     43                0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14, 
     44                0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E, 
     45                0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80, 
     46                0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA, 
     47                0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95, 
     48                0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF, 
     49                0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01, 
     50                0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B, 
     51                0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA, 
     52                0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0, 
     53                0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E, 
     54                0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34, 
     55                0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0, 
     56                0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A, 
     57                0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54, 
     58                0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E, 
     59                0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF, 
     60                0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5, 
     61                0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B, 
     62                0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61, 
     63                0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E, 
     64                0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74, 
     65                0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA, 
     66                0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0, 
     67                0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41, 
     68                0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B, 
     69                0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5, 
     70                0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F, 
     71        }; 
     72        return t[crc ^ data]; 
     73} 
     74 
     75static u8 bcma_sprom_crc(const u16 *sprom) 
     76{ 
     77        int word; 
     78        u8 crc = 0xFF; 
     79 
     80        for (word = 0; word < SSB_SPROMSIZE_WORDS_R4 - 1; word++) { 
     81                crc = bcma_crc8(crc, sprom[word] & 0x00FF); 
     82                crc = bcma_crc8(crc, (sprom[word] & 0xFF00) >> 8); 
     83        } 
     84        crc = bcma_crc8(crc, sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & 0x00FF); 
     85        crc ^= 0xFF; 
     86 
     87        return crc; 
     88} 
     89 
     90static int bcma_sprom_check_crc(const u16 *sprom) 
     91{ 
     92        u8 crc; 
     93        u8 expected_crc; 
     94        u16 tmp; 
     95 
     96        crc = bcma_sprom_crc(sprom); 
     97        tmp = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_CRC; 
     98        expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT; 
     99        if (crc != expected_crc) 
     100                return -EPROTO; 
     101 
     102        return 0; 
     103} 
     104 
     105static int bcma_sprom_valid(const u16 *sprom) 
     106{ 
     107        u16 revision; 
     108        int err; 
     109 
     110        err = bcma_sprom_check_crc(sprom); 
     111        if (err) 
     112                return err; 
     113 
     114        revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_REV; 
     115        if (revision != 8) { 
     116                pr_err("Unsupported SPROM revision: %d\n", revision); 
     117                return -ENOENT; 
     118        } 
     119 
     120        return 0; 
     121} 
     122 
     123/************************************************** 
     124 * SPROM extraction. 
     125 **************************************************/ 
     126 
     127static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom) 
     128{ 
     129        u16 v; 
     130        int i; 
     131 
     132        for (i = 0; i < 3; i++) { 
     133                v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i]; 
     134                *(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v); 
     135        } 
     136} 
     137 
     138int bcma_sprom_get(struct bcma_bus *bus) 
     139{ 
     140        u16 *sprom; 
     141        int err = 0; 
     142 
     143        if (!bus->drv_cc.core) 
     144                return -EOPNOTSUPP; 
     145 
     146        sprom = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
     147                        GFP_KERNEL); 
     148        if (!sprom) 
     149                return -ENOMEM; 
     150 
     151        bcma_sprom_read(bus, sprom); 
     152 
     153        err = bcma_sprom_valid(sprom); 
     154        if (err) 
     155                goto out; 
     156 
     157        bcma_sprom_extract_r8(bus, sprom); 
     158 
     159out: 
     160        kfree(sprom); 
     161        return err; 
     162} 
  • include/linux/bcma/bcma.h

    a b  
    66 
    77#include <linux/bcma/bcma_driver_chipcommon.h> 
    88#include <linux/bcma/bcma_driver_pci.h> 
     9#include <linux/ssb/ssb.h> /* SPROM sharing */ 
    910 
    1011#include "bcma_regs.h" 
    1112 
    struct bcma_host_ops { 
    3132        void (*write8)(struct bcma_device *core, u16 offset, u8 value); 
    3233        void (*write16)(struct bcma_device *core, u16 offset, u16 value); 
    3334        void (*write32)(struct bcma_device *core, u16 offset, u32 value); 
     35#ifdef CONFIG_BCMA_BLOCKIO 
     36        void (*block_read)(struct bcma_device *core, void *buffer, 
     37                           size_t count, u16 offset, u8 reg_width); 
     38        void (*block_write)(struct bcma_device *core, const void *buffer, 
     39                            size_t count, u16 offset, u8 reg_width); 
     40#endif 
    3441        /* Agent ops */ 
    3542        u32 (*aread32)(struct bcma_device *core, u16 offset); 
    3643        void (*awrite32)(struct bcma_device *core, u16 offset, u32 value); 
    struct bcma_device { 
    117124        struct bcma_device_id id; 
    118125 
    119126        struct device dev; 
     127        struct device *dma_dev; 
     128        unsigned int irq; 
    120129        bool dev_registered; 
    121130 
    122131        u8 core_index; 
    struct bcma_bus { 
    179188 
    180189        struct bcma_drv_cc drv_cc; 
    181190        struct bcma_drv_pci drv_pci; 
     191 
     192        /* We decided to share SPROM struct with SSB as long as we do not need 
     193         * any hacks for BCMA. This simplifies drivers code. */ 
     194        struct ssb_sprom sprom; 
    182195}; 
    183196 
    184197extern inline u32 bcma_read8(struct bcma_device *core, u16 offset) 
    void bcma_write32(struct bcma_device *co 
    208221{ 
    209222        core->bus->ops->write32(core, offset, value); 
    210223} 
     224#ifdef CONFIG_BCMA_BLOCKIO 
     225extern inline void bcma_block_read(struct bcma_device *core, void *buffer, 
     226                                   size_t count, u16 offset, u8 reg_width) 
     227{ 
     228        core->bus->ops->block_read(core, buffer, count, offset, reg_width); 
     229} 
     230extern inline void bcma_block_write(struct bcma_device *core, const void *buffer, 
     231                                    size_t count, u16 offset, u8 reg_width) 
     232{ 
     233        core->bus->ops->block_write(core, buffer, count, offset, reg_width); 
     234} 
     235#endif 
    211236extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset) 
    212237{ 
    213238        return core->bus->ops->aread32(core, offset); 
    void bcma_awrite32(struct bcma_device *c 
    219244} 
    220245 
    221246extern bool bcma_core_is_enabled(struct bcma_device *core); 
     247extern void bcma_core_disable(struct bcma_device *core, u32 flags); 
    222248extern int bcma_core_enable(struct bcma_device *core, u32 flags); 
    223249 
    224250#endif /* LINUX_BCMA_H_ */ 
  • include/linux/bcma/bcma_driver_chipcommon.h

    a b  
    244244#define BCMA_CC_REGCTL_DATA             0x065C 
    245245#define BCMA_CC_PLLCTL_ADDR             0x0660 
    246246#define BCMA_CC_PLLCTL_DATA             0x0664 
     247#define BCMA_CC_SPROM                   0x0830 /* SPROM beginning */ 
    247248 
    248249/* Data for the PMU, if available. 
    249250 * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU) 
  • include/linux/bcma/bcma_driver_pci.h

    a b struct bcma_drv_pci { 
    8585#define pcicore_write32(pc, offset, val)        bcma_write32((pc)->core, offset, val) 
    8686 
    8787extern void bcma_core_pci_init(struct bcma_drv_pci *pc); 
     88extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, 
     89                                 struct bcma_device *core, bool enable); 
    8890 
    8991#endif /* LINUX_BCMA_DRIVER_PCI_H_ */ 
Note: See TracBrowser for help on using the repository browser.