source: trunk/target/linux/brcm47xx/patches-3.2/240-bcma-pcie-config-access.patch @ 31481

Last change on this file since 31481 was 31481, checked in by hauke, 4 years ago

brcm47xx: BCMA - Modified PCI CFG space access

The existing code (prior to the patch) does an "ioremap_nocache" on a
subset of a memory region that I think has already been mapped, and then
un-maps that smaller region when it is finished.

Thanks Nathan Hintz for the patch

File size: 2.7 KB
  • drivers/bcma/driver_pci_host.c

    a b static int bcma_extpci_read_config(struc 
    9999        if (dev == 0) { 
    100100                /* we support only two functions on device 0 */ 
    101101                if (func > 1) 
    102                         return -EINVAL; 
     102                        goto out; 
    103103 
    104104                /* accesses to config registers with offsets >= 256 
    105105                 * requires indirect access. 
    106106                 */ 
    107107                if (off >= PCI_CONFIG_SPACE_SIZE) { 
    108108                        addr = (func << 12); 
    109                         addr |= (off & 0x0FFF); 
     109                        addr |= (off & 0x0FFC); 
    110110                        val = bcma_pcie_read_config(pc, addr); 
    111111                } else { 
    112112                        addr = BCMA_CORE_PCI_PCICFG0; 
    113113                        addr |= (func << 8); 
    114                         addr |= (off & 0xfc); 
     114                        addr |= (off & 0xFC); 
    115115                        val = pcicore_read32(pc, addr); 
    116116                } 
    117117        } else { 
    static int bcma_extpci_read_config(struc 
    127127                        val = 0xffffffff; 
    128128                        goto unmap; 
    129129                } 
    130  
    131                 val = readl(mmio); 
    132130        } 
    133131        val >>= (8 * (off & 3)); 
    134132 
    static int bcma_extpci_write_config(stru 
    156154                                   const void *buf, int len) 
    157155{ 
    158156        int err = -EINVAL; 
    159         u32 addr = 0, val = 0; 
     157        u32 addr, val; 
    160158        void __iomem *mmio = 0; 
    161159        u16 chipid = pc->core->bus->chipinfo.id; 
    162160 
    static int bcma_extpci_write_config(stru 
    164162        if (unlikely(len != 1 && len != 2 && len != 4)) 
    165163                goto out; 
    166164        if (dev == 0) { 
     165                /* we support only two functions on device 0 */ 
     166                if (func > 1) 
     167                        goto out; 
     168 
    167169                /* accesses to config registers with offsets >= 256 
    168170                 * requires indirect access. 
    169171                 */ 
    170                 if (off < PCI_CONFIG_SPACE_SIZE) { 
    171                         addr = pc->core->addr + BCMA_CORE_PCI_PCICFG0; 
     172                if (off >= PCI_CONFIG_SPACE_SIZE) { 
     173                        addr = (func << 12); 
     174                        addr |= (off & 0x0FFC); 
     175                        val = bcma_pcie_read_config(pc, addr); 
     176                } else { 
     177                        addr = BCMA_CORE_PCI_PCICFG0; 
    172178                        addr |= (func << 8); 
    173                         addr |= (off & 0xfc); 
    174                         mmio = ioremap_nocache(addr, sizeof(val)); 
    175                         if (!mmio) 
    176                                 goto out; 
     179                        addr |= (off & 0xFC); 
     180                        val = pcicore_read32(pc, addr); 
    177181                } 
    178182        } else { 
    179183                addr = bcma_get_cfgspace_addr(pc, dev, func, off); 
    static int bcma_extpci_write_config(stru 
    192196 
    193197        switch (len) { 
    194198        case 1: 
    195                 val = readl(mmio); 
    196199                val &= ~(0xFF << (8 * (off & 3))); 
    197200                val |= *((const u8 *)buf) << (8 * (off & 3)); 
    198201                break; 
    199202        case 2: 
    200                 val = readl(mmio); 
    201203                val &= ~(0xFFFF << (8 * (off & 3))); 
    202204                val |= *((const u16 *)buf) << (8 * (off & 3)); 
    203205                break; 
    static int bcma_extpci_write_config(stru 
    205207                val = *((const u32 *)buf); 
    206208                break; 
    207209        } 
    208         if (dev == 0 && !addr) { 
     210        if (dev == 0) { 
    209211                /* accesses to config registers with offsets >= 256 
    210212                 * requires indirect access. 
    211213                 */ 
    212                 addr = (func << 12); 
    213                 addr |= (off & 0x0FFF); 
    214                 bcma_pcie_write_config(pc, addr, val); 
     214                if (off >= PCI_CONFIG_SPACE_SIZE) 
     215                        bcma_pcie_write_config(pc, addr, val); 
     216                else 
     217                        pcicore_write32(pc, addr, val); 
    215218        } else { 
    216219                writel(val, mmio); 
    217220 
Note: See TracBrowser for help on using the repository browser.