source: trunk/target/linux/generic/patches-2.6.37/020-ssb_update.patch @ 30781

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

[kernel/2.6.37] refresh patches

File size: 62.0 KB
  • drivers/ssb/main.c

    a b  
    33 * Subsystem core 
    44 * 
    55 * Copyright 2005, Broadcom Corporation 
    6  * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
     
    1212 
    1313#include <linux/delay.h> 
    1414#include <linux/io.h> 
     15#include <linux/module.h> 
    1516#include <linux/ssb/ssb.h> 
    1617#include <linux/ssb/ssb_regs.h> 
    1718#include <linux/ssb/ssb_driver_gige.h> 
    static int ssb_device_uevent(struct devi 
    383384                             ssb_dev->id.revision); 
    384385} 
    385386 
     387#define ssb_config_attr(attrib, field, format_string) \ 
     388static ssize_t \ 
     389attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 
     390{ \ 
     391        return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \ 
     392} 
     393 
     394ssb_config_attr(core_num, core_index, "%u\n") 
     395ssb_config_attr(coreid, id.coreid, "0x%04x\n") 
     396ssb_config_attr(vendor, id.vendor, "0x%04x\n") 
     397ssb_config_attr(revision, id.revision, "%u\n") 
     398ssb_config_attr(irq, irq, "%u\n") 
     399static ssize_t 
     400name_show(struct device *dev, struct device_attribute *attr, char *buf) 
     401{ 
     402        return sprintf(buf, "%s\n", 
     403                       ssb_core_name(dev_to_ssb_dev(dev)->id.coreid)); 
     404} 
     405 
     406static struct device_attribute ssb_device_attrs[] = { 
     407        __ATTR_RO(name), 
     408        __ATTR_RO(core_num), 
     409        __ATTR_RO(coreid), 
     410        __ATTR_RO(vendor), 
     411        __ATTR_RO(revision), 
     412        __ATTR_RO(irq), 
     413        __ATTR_NULL, 
     414}; 
     415 
    386416static struct bus_type ssb_bustype = { 
    387417        .name           = "ssb", 
    388418        .match          = ssb_bus_match, 
    static struct bus_type ssb_bustype = { 
    392422        .suspend        = ssb_device_suspend, 
    393423        .resume         = ssb_device_resume, 
    394424        .uevent         = ssb_device_uevent, 
     425        .dev_attrs      = ssb_device_attrs, 
    395426}; 
    396427 
    397428static void ssb_buses_lock(void) 
    error: 
    527558} 
    528559 
    529560/* Needs ssb_buses_lock() */ 
    530 static int ssb_attach_queued_buses(void) 
     561static int __devinit ssb_attach_queued_buses(void) 
    531562{ 
    532563        struct ssb_bus *bus, *n; 
    533564        int err = 0; 
    out: 
    738769        return err; 
    739770} 
    740771 
    741 static int ssb_bus_register(struct ssb_bus *bus, 
    742                             ssb_invariants_func_t get_invariants, 
    743                             unsigned long baseaddr) 
     772static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     773                                      ssb_invariants_func_t get_invariants, 
     774                                      unsigned long baseaddr) 
    744775{ 
    745776        int err; 
    746777 
    err_disable_xtal: 
    821852} 
    822853 
    823854#ifdef CONFIG_SSB_PCIHOST 
    824 int ssb_bus_pcibus_register(struct ssb_bus *bus, 
    825                             struct pci_dev *host_pci) 
     855int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     856                                      struct pci_dev *host_pci) 
    826857{ 
    827858        int err; 
    828859 
    EXPORT_SYMBOL(ssb_bus_pcibus_register); 
    845876#endif /* CONFIG_SSB_PCIHOST */ 
    846877 
    847878#ifdef CONFIG_SSB_PCMCIAHOST 
    848 int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
    849                               struct pcmcia_device *pcmcia_dev, 
    850                               unsigned long baseaddr) 
     879int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     880                                        struct pcmcia_device *pcmcia_dev, 
     881                                        unsigned long baseaddr) 
    851882{ 
    852883        int err; 
    853884 
    EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
    867898#endif /* CONFIG_SSB_PCMCIAHOST */ 
    868899 
    869900#ifdef CONFIG_SSB_SDIOHOST 
    870 int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
    871                              unsigned int quirks) 
     901int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     902                                       struct sdio_func *func, 
     903                                       unsigned int quirks) 
    872904{ 
    873905        int err; 
    874906 
    int ssb_bus_sdiobus_register(struct ssb_ 
    888920EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
    889921#endif /* CONFIG_SSB_PCMCIAHOST */ 
    890922 
    891 int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    892                             unsigned long baseaddr, 
    893                             ssb_invariants_func_t get_invariants) 
     923int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     924                                      unsigned long baseaddr, 
     925                                      ssb_invariants_func_t get_invariants) 
    894926{ 
    895927        int err; 
    896928 
    u32 ssb_calc_clock_rate(u32 plltype, u32 
    9711003        switch (plltype) { 
    9721004        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
    9731005                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
    974                         return SSB_CHIPCO_CLK_T6_M0; 
    975                 return SSB_CHIPCO_CLK_T6_M1; 
     1006                        return SSB_CHIPCO_CLK_T6_M1; 
     1007                return SSB_CHIPCO_CLK_T6_M0; 
    9761008        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
    9771009        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
    9781010        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
    static u32 ssb_tmslow_reject_bitmask(str 
    10871119{ 
    10881120        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
    10891121 
    1090         /* The REJECT bit changed position in TMSLOW between 
    1091          * Backplane revisions. */ 
     1122        /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
    10921123        switch (rev) { 
    10931124        case SSB_IDLOW_SSBREV_22: 
    1094                 return SSB_TMSLOW_REJECT_22; 
     1125        case SSB_IDLOW_SSBREV_24: 
     1126        case SSB_IDLOW_SSBREV_26: 
     1127                return SSB_TMSLOW_REJECT; 
    10951128        case SSB_IDLOW_SSBREV_23: 
    10961129                return SSB_TMSLOW_REJECT_23; 
    1097         case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
    1098         case SSB_IDLOW_SSBREV_25:     /* same here */ 
    1099         case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1130        case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
    11001131        case SSB_IDLOW_SSBREV_27:     /* same here */ 
    1101                 return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1132                return SSB_TMSLOW_REJECT;       /* this is a guess */ 
    11021133        default: 
    11031134                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
    11041135                WARN_ON(1); 
    11051136        } 
    1106         return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1137        return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
    11071138} 
    11081139 
    11091140int ssb_device_is_enabled(struct ssb_device *dev) 
    void ssb_device_enable(struct ssb_device 
    11621193} 
    11631194EXPORT_SYMBOL(ssb_device_enable); 
    11641195 
    1165 /* Wait for a bit in a register to get set or unset. 
     1196/* Wait for bitmask in a register to get set or cleared. 
    11661197 * timeout is in units of ten-microseconds */ 
    1167 static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
    1168                         int timeout, int set) 
     1198static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     1199                         int timeout, int set) 
    11691200{ 
    11701201        int i; 
    11711202        u32 val; 
    static int ssb_wait_bit(struct ssb_devic 
    11731204        for (i = 0; i < timeout; i++) { 
    11741205                val = ssb_read32(dev, reg); 
    11751206                if (set) { 
    1176                         if (val & bitmask) 
     1207                        if ((val & bitmask) == bitmask) 
    11771208                                return 0; 
    11781209                } else { 
    11791210                        if (!(val & bitmask)) 
    static int ssb_wait_bit(struct ssb_devic 
    11901221 
    11911222void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
    11921223{ 
    1193         u32 reject; 
     1224        u32 reject, val; 
    11941225 
    11951226        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
    11961227                return; 
    11971228 
    11981229        reject = ssb_tmslow_reject_bitmask(dev); 
    1199         ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
    1200         ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
    1201         ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
    1202         ssb_write32(dev, SSB_TMSLOW, 
    1203                     SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
    1204                     reject | SSB_TMSLOW_RESET | 
    1205                     core_specific_flags); 
    1206         ssb_flush_tmslow(dev); 
     1230 
     1231        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) { 
     1232                ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     1233                ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1); 
     1234                ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     1235 
     1236                if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     1237                        val = ssb_read32(dev, SSB_IMSTATE); 
     1238                        val |= SSB_IMSTATE_REJECT; 
     1239                        ssb_write32(dev, SSB_IMSTATE, val); 
     1240                        ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000, 
     1241                                      0); 
     1242                } 
     1243 
     1244                ssb_write32(dev, SSB_TMSLOW, 
     1245                        SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     1246                        reject | SSB_TMSLOW_RESET | 
     1247                        core_specific_flags); 
     1248                ssb_flush_tmslow(dev); 
     1249 
     1250                if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     1251                        val = ssb_read32(dev, SSB_IMSTATE); 
     1252                        val &= ~SSB_IMSTATE_REJECT; 
     1253                        ssb_write32(dev, SSB_IMSTATE, val); 
     1254                } 
     1255        } 
    12071256 
    12081257        ssb_write32(dev, SSB_TMSLOW, 
    12091258                    reject | SSB_TMSLOW_RESET | 
    void ssb_device_disable(struct ssb_devic 
    12121261} 
    12131262EXPORT_SYMBOL(ssb_device_disable); 
    12141263 
     1264/* Some chipsets need routing known for PCIe and 64-bit DMA */ 
     1265static bool ssb_dma_translation_special_bit(struct ssb_device *dev) 
     1266{ 
     1267        u16 chip_id = dev->bus->chip_id; 
     1268 
     1269        if (dev->id.coreid == SSB_DEV_80211) { 
     1270                return (chip_id == 0x4322 || chip_id == 43221 || 
     1271                        chip_id == 43231 || chip_id == 43222); 
     1272        } 
     1273 
     1274        return 0; 
     1275} 
     1276 
    12151277u32 ssb_dma_translation(struct ssb_device *dev) 
    12161278{ 
    12171279        switch (dev->bus->bustype) { 
    12181280        case SSB_BUSTYPE_SSB: 
    12191281                return 0; 
    12201282        case SSB_BUSTYPE_PCI: 
    1221                 return SSB_PCI_DMA; 
     1283                if (pci_is_pcie(dev->bus->host_pci) && 
     1284                    ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) { 
     1285                        return SSB_PCIE_DMA_H32; 
     1286                } else { 
     1287                        if (ssb_dma_translation_special_bit(dev)) 
     1288                                return SSB_PCIE_DMA_H32; 
     1289                        else 
     1290                                return SSB_PCI_DMA; 
     1291                } 
    12221292        default: 
    12231293                __ssb_dma_not_implemented(dev); 
    12241294        } 
    EXPORT_SYMBOL(ssb_bus_may_powerdown); 
    12611331 
    12621332int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
    12631333{ 
    1264         struct ssb_chipcommon *cc; 
    12651334        int err; 
    12661335        enum ssb_clkmode mode; 
    12671336 
    12681337        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
    12691338        if (err) 
    12701339                goto error; 
    1271         cc = &bus->chipco; 
    1272         mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
    1273         ssb_chipco_set_clockmode(cc, mode); 
    12741340 
    12751341#ifdef CONFIG_SSB_DEBUG 
    12761342        bus->powered_up = 1; 
    12771343#endif 
     1344 
     1345        mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1346        ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1347 
    12781348        return 0; 
    12791349error: 
    12801350        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
    error: 
    12821352} 
    12831353EXPORT_SYMBOL(ssb_bus_powerup); 
    12841354 
     1355static void ssb_broadcast_value(struct ssb_device *dev, 
     1356                                u32 address, u32 data) 
     1357{ 
     1358#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1359        /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1360        BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1361        BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1362#endif 
     1363 
     1364        ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     1365        ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     1366        ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     1367        ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     1368} 
     1369 
     1370void ssb_commit_settings(struct ssb_bus *bus) 
     1371{ 
     1372        struct ssb_device *dev; 
     1373 
     1374#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1375        dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1376#else 
     1377        dev = bus->chipco.dev; 
     1378#endif 
     1379        if (WARN_ON(!dev)) 
     1380                return; 
     1381        /* This forces an update of the cached registers. */ 
     1382        ssb_broadcast_value(dev, 0xFD8, 0); 
     1383} 
     1384EXPORT_SYMBOL(ssb_commit_settings); 
     1385 
    12851386u32 ssb_admatch_base(u32 adm) 
    12861387{ 
    12871388        u32 base = 0; 
  • drivers/ssb/pci.c

    a b  
    11/* 
    22 * Sonics Silicon Backplane PCI-Hostbus related functions. 
    33 * 
    4  * Copyright (C) 2005-2006 Michael Buesch <mb@bu3sch.de> 
     4 * Copyright (C) 2005-2006 Michael Buesch <m@bues.ch> 
    55 * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de> 
    66 * Copyright (C) 2005 Stefano Brivio <st3@riseup.net> 
    77 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org> 
    static void sprom_extract_r123(struct ss 
    406406        out->antenna_gain.ghz5.a3 = gain; 
    407407} 
    408408 
     409/* Revs 4 5 and 8 have partially shared layout */ 
     410static void sprom_extract_r458(struct ssb_sprom *out, const u16 *in) 
     411{ 
     412        SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01, 
     413             SSB_SPROM4_TXPID2G0, SSB_SPROM4_TXPID2G0_SHIFT); 
     414        SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01, 
     415             SSB_SPROM4_TXPID2G1, SSB_SPROM4_TXPID2G1_SHIFT); 
     416        SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23, 
     417             SSB_SPROM4_TXPID2G2, SSB_SPROM4_TXPID2G2_SHIFT); 
     418        SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23, 
     419             SSB_SPROM4_TXPID2G3, SSB_SPROM4_TXPID2G3_SHIFT); 
     420 
     421        SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01, 
     422             SSB_SPROM4_TXPID5GL0, SSB_SPROM4_TXPID5GL0_SHIFT); 
     423        SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01, 
     424             SSB_SPROM4_TXPID5GL1, SSB_SPROM4_TXPID5GL1_SHIFT); 
     425        SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23, 
     426             SSB_SPROM4_TXPID5GL2, SSB_SPROM4_TXPID5GL2_SHIFT); 
     427        SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23, 
     428             SSB_SPROM4_TXPID5GL3, SSB_SPROM4_TXPID5GL3_SHIFT); 
     429 
     430        SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01, 
     431             SSB_SPROM4_TXPID5G0, SSB_SPROM4_TXPID5G0_SHIFT); 
     432        SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01, 
     433             SSB_SPROM4_TXPID5G1, SSB_SPROM4_TXPID5G1_SHIFT); 
     434        SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23, 
     435             SSB_SPROM4_TXPID5G2, SSB_SPROM4_TXPID5G2_SHIFT); 
     436        SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23, 
     437             SSB_SPROM4_TXPID5G3, SSB_SPROM4_TXPID5G3_SHIFT); 
     438 
     439        SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01, 
     440             SSB_SPROM4_TXPID5GH0, SSB_SPROM4_TXPID5GH0_SHIFT); 
     441        SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01, 
     442             SSB_SPROM4_TXPID5GH1, SSB_SPROM4_TXPID5GH1_SHIFT); 
     443        SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23, 
     444             SSB_SPROM4_TXPID5GH2, SSB_SPROM4_TXPID5GH2_SHIFT); 
     445        SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23, 
     446             SSB_SPROM4_TXPID5GH3, SSB_SPROM4_TXPID5GH3_SHIFT); 
     447} 
     448 
    409449static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in) 
    410450{ 
    411451        int i; 
    static void sprom_extract_r45(struct ssb 
    428468                SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0); 
    429469                SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0); 
    430470                SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0); 
     471                SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0); 
     472                SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0); 
    431473        } else { 
    432474                SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0); 
    433475                SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0); 
    434476                SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0); 
     477                SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0); 
     478                SPEX(boardflags2_hi, SSB_SPROM5_BFL2HI, 0xFFFF, 0); 
    435479        } 
    436480        SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A, 
    437481             SSB_SPROM4_ANTAVAIL_A_SHIFT); 
    static void sprom_extract_r45(struct ssb 
    471515        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
    472516               sizeof(out->antenna_gain.ghz5)); 
    473517 
     518        sprom_extract_r458(out, in); 
     519 
    474520        /* TODO - get remaining rev 4 stuff needed */ 
    475521} 
    476522 
    477523static void sprom_extract_r8(struct ssb_sprom *out, const u16 *in) 
    478524{ 
    479525        int i; 
    480         u16 v; 
     526        u16 v, o; 
     527        u16 pwr_info_offset[] = { 
     528                SSB_SROM8_PWR_INFO_CORE0, SSB_SROM8_PWR_INFO_CORE1, 
     529                SSB_SROM8_PWR_INFO_CORE2, SSB_SROM8_PWR_INFO_CORE3 
     530        }; 
     531        BUILD_BUG_ON(ARRAY_SIZE(pwr_info_offset) != 
     532                        ARRAY_SIZE(out->core_pwr_info)); 
    481533 
    482534        /* extract the MAC address */ 
    483535        for (i = 0; i < 3; i++) { 
    static void sprom_extract_r8(struct ssb_ 
    561613        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
    562614               sizeof(out->antenna_gain.ghz5)); 
    563615 
     616        /* Extract cores power info info */ 
     617        for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) { 
     618                o = pwr_info_offset[i]; 
     619                SPEX(core_pwr_info[i].itssi_2g, o + SSB_SROM8_2G_MAXP_ITSSI, 
     620                        SSB_SPROM8_2G_ITSSI, SSB_SPROM8_2G_ITSSI_SHIFT); 
     621                SPEX(core_pwr_info[i].maxpwr_2g, o + SSB_SROM8_2G_MAXP_ITSSI, 
     622                        SSB_SPROM8_2G_MAXP, 0); 
     623 
     624                SPEX(core_pwr_info[i].pa_2g[0], o + SSB_SROM8_2G_PA_0, ~0, 0); 
     625                SPEX(core_pwr_info[i].pa_2g[1], o + SSB_SROM8_2G_PA_1, ~0, 0); 
     626                SPEX(core_pwr_info[i].pa_2g[2], o + SSB_SROM8_2G_PA_2, ~0, 0); 
     627 
     628                SPEX(core_pwr_info[i].itssi_5g, o + SSB_SROM8_5G_MAXP_ITSSI, 
     629                        SSB_SPROM8_5G_ITSSI, SSB_SPROM8_5G_ITSSI_SHIFT); 
     630                SPEX(core_pwr_info[i].maxpwr_5g, o + SSB_SROM8_5G_MAXP_ITSSI, 
     631                        SSB_SPROM8_5G_MAXP, 0); 
     632                SPEX(core_pwr_info[i].maxpwr_5gh, o + SSB_SPROM8_5GHL_MAXP, 
     633                        SSB_SPROM8_5GH_MAXP, 0); 
     634                SPEX(core_pwr_info[i].maxpwr_5gl, o + SSB_SPROM8_5GHL_MAXP, 
     635                        SSB_SPROM8_5GL_MAXP, SSB_SPROM8_5GL_MAXP_SHIFT); 
     636 
     637                SPEX(core_pwr_info[i].pa_5gl[0], o + SSB_SROM8_5GL_PA_0, ~0, 0); 
     638                SPEX(core_pwr_info[i].pa_5gl[1], o + SSB_SROM8_5GL_PA_1, ~0, 0); 
     639                SPEX(core_pwr_info[i].pa_5gl[2], o + SSB_SROM8_5GL_PA_2, ~0, 0); 
     640                SPEX(core_pwr_info[i].pa_5g[0], o + SSB_SROM8_5G_PA_0, ~0, 0); 
     641                SPEX(core_pwr_info[i].pa_5g[1], o + SSB_SROM8_5G_PA_1, ~0, 0); 
     642                SPEX(core_pwr_info[i].pa_5g[2], o + SSB_SROM8_5G_PA_2, ~0, 0); 
     643                SPEX(core_pwr_info[i].pa_5gh[0], o + SSB_SROM8_5GH_PA_0, ~0, 0); 
     644                SPEX(core_pwr_info[i].pa_5gh[1], o + SSB_SROM8_5GH_PA_1, ~0, 0); 
     645                SPEX(core_pwr_info[i].pa_5gh[2], o + SSB_SROM8_5GH_PA_2, ~0, 0); 
     646        } 
     647 
     648        /* Extract FEM info */ 
     649        SPEX(fem.ghz2.tssipos, SSB_SPROM8_FEM2G, 
     650                SSB_SROM8_FEM_TSSIPOS, SSB_SROM8_FEM_TSSIPOS_SHIFT); 
     651        SPEX(fem.ghz2.extpa_gain, SSB_SPROM8_FEM2G, 
     652                SSB_SROM8_FEM_EXTPA_GAIN, SSB_SROM8_FEM_EXTPA_GAIN_SHIFT); 
     653        SPEX(fem.ghz2.pdet_range, SSB_SPROM8_FEM2G, 
     654                SSB_SROM8_FEM_PDET_RANGE, SSB_SROM8_FEM_PDET_RANGE_SHIFT); 
     655        SPEX(fem.ghz2.tr_iso, SSB_SPROM8_FEM2G, 
     656                SSB_SROM8_FEM_TR_ISO, SSB_SROM8_FEM_TR_ISO_SHIFT); 
     657        SPEX(fem.ghz2.antswlut, SSB_SPROM8_FEM2G, 
     658                SSB_SROM8_FEM_ANTSWLUT, SSB_SROM8_FEM_ANTSWLUT_SHIFT); 
     659 
     660        SPEX(fem.ghz5.tssipos, SSB_SPROM8_FEM5G, 
     661                SSB_SROM8_FEM_TSSIPOS, SSB_SROM8_FEM_TSSIPOS_SHIFT); 
     662        SPEX(fem.ghz5.extpa_gain, SSB_SPROM8_FEM5G, 
     663                SSB_SROM8_FEM_EXTPA_GAIN, SSB_SROM8_FEM_EXTPA_GAIN_SHIFT); 
     664        SPEX(fem.ghz5.pdet_range, SSB_SPROM8_FEM5G, 
     665                SSB_SROM8_FEM_PDET_RANGE, SSB_SROM8_FEM_PDET_RANGE_SHIFT); 
     666        SPEX(fem.ghz5.tr_iso, SSB_SPROM8_FEM5G, 
     667                SSB_SROM8_FEM_TR_ISO, SSB_SROM8_FEM_TR_ISO_SHIFT); 
     668        SPEX(fem.ghz5.antswlut, SSB_SPROM8_FEM5G, 
     669                SSB_SROM8_FEM_ANTSWLUT, SSB_SROM8_FEM_ANTSWLUT_SHIFT); 
     670 
     671        sprom_extract_r458(out, in); 
     672 
    564673        /* TODO - get remaining rev 8 stuff needed */ 
    565674} 
    566675 
    static int sprom_extract(struct ssb_bus 
    573682        ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision); 
    574683        memset(out->et0mac, 0xFF, 6);           /* preset et0 and et1 mac */ 
    575684        memset(out->et1mac, 0xFF, 6); 
     685 
    576686        if ((bus->chip_id & 0xFF00) == 0x4400) { 
    577687                /* Workaround: The BCM44XX chip has a stupid revision 
    578688                 * number stored in the SPROM. 
    579689                 * Always extract r1. */ 
    580690                out->revision = 1; 
     691                ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision); 
     692        } 
     693 
     694        switch (out->revision) { 
     695        case 1: 
     696        case 2: 
     697        case 3: 
    581698                sprom_extract_r123(out, in); 
    582         } else if (bus->chip_id == 0x4321) { 
    583                 /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */ 
    584                 out->revision = 4; 
     699                break; 
     700        case 4: 
     701        case 5: 
    585702                sprom_extract_r45(out, in); 
    586         } else { 
    587                 switch (out->revision) { 
    588                 case 1: 
    589                 case 2: 
    590                 case 3: 
    591                         sprom_extract_r123(out, in); 
    592                         break; 
    593                 case 4: 
    594                 case 5: 
    595                         sprom_extract_r45(out, in); 
    596                         break; 
    597                 case 8: 
    598                         sprom_extract_r8(out, in); 
    599                         break; 
    600                 default: 
    601                         ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    602                                    "  revision %d detected. Will extract" 
    603                                    " v1\n", out->revision); 
    604                         out->revision = 1; 
    605                         sprom_extract_r123(out, in); 
    606                 } 
     703                break; 
     704        case 8: 
     705                sprom_extract_r8(out, in); 
     706                break; 
     707        default: 
     708                ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     709                           " revision %d detected. Will extract" 
     710                           " v1\n", out->revision); 
     711                out->revision = 1; 
     712                sprom_extract_r123(out, in); 
    607713        } 
    608714 
    609715        if (out->boardflags_lo == 0xFFFF) 
    static int sprom_extract(struct ssb_bus 
    617723static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    618724                             struct ssb_sprom *sprom) 
    619725{ 
    620         const struct ssb_sprom *fallback; 
    621         int err = -ENOMEM; 
     726        int err; 
    622727        u16 *buf; 
    623728 
    624729        if (!ssb_is_sprom_available(bus)) { 
    625730                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
    626731                return -ENODEV; 
    627732        } 
    628         if (bus->chipco.dev) {  /* can be unavailible! */ 
     733        if (bus->chipco.dev) {  /* can be unavailable! */ 
    629734                /* 
    630735                 * get SPROM offset: SSB_SPROM_BASE1 except for 
    631736                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
    static int ssb_pci_sprom_get(struct ssb_ 
    645750 
    646751        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
    647752        if (!buf) 
    648                 goto out; 
     753                return -ENOMEM; 
    649754        bus->sprom_size = SSB_SPROMSIZE_WORDS_R123; 
    650755        sprom_do_read(bus, buf); 
    651756        err = sprom_check_crc(buf, bus->sprom_size); 
    static int ssb_pci_sprom_get(struct ssb_ 
    655760                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    656761                              GFP_KERNEL); 
    657762                if (!buf) 
    658                         goto out; 
     763                        return -ENOMEM; 
    659764                bus->sprom_size = SSB_SPROMSIZE_WORDS_R4; 
    660765                sprom_do_read(bus, buf); 
    661766                err = sprom_check_crc(buf, bus->sprom_size); 
    662767                if (err) { 
    663768                        /* All CRC attempts failed. 
    664769                         * Maybe there is no SPROM on the device? 
    665                          * If we have a fallback, use that. */ 
    666                         fallback = ssb_get_fallback_sprom(); 
    667                         if (fallback) { 
    668                                 memcpy(sprom, fallback, sizeof(*sprom)); 
     770                         * Now we ask the arch code if there is some sprom 
     771                         * available for this device in some other storage */ 
     772                        err = ssb_fill_sprom_with_fallback(bus, sprom); 
     773                        if (err) { 
     774                                ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     775                                           " fallback SPROM failed (err %d)\n", 
     776                                           err); 
     777                        } else { 
     778                                ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     779                                            " revision %d provided by" 
     780                                            " platform.\n", sprom->revision); 
    669781                                err = 0; 
    670782                                goto out_free; 
    671783                        } 
    static int ssb_pci_sprom_get(struct ssb_ 
    677789 
    678790out_free: 
    679791        kfree(buf); 
    680 out: 
    681792        return err; 
    682793} 
    683794 
    684795static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
    685796                                  struct ssb_boardinfo *bi) 
    686797{ 
    687         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
    688                              &bi->vendor); 
    689         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
    690                              &bi->type); 
    691         pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
    692                              &bi->rev); 
     798        bi->vendor = bus->host_pci->subsystem_vendor; 
     799        bi->type = bus->host_pci->subsystem_device; 
     800        bi->rev = bus->host_pci->revision; 
    693801} 
    694802 
    695803int ssb_pci_get_invariants(struct ssb_bus *bus, 
  • drivers/ssb/pcihost_wrapper.c

    a b  
    66 * Copyright (c) 2005 Stefano Brivio <st3@riseup.net> 
    77 * Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org> 
    88 * Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch> 
    9  * Copyright (c) 2005-2007 Michael Buesch <mbuesch@freenet.de> 
     9 * Copyright (c) 2005-2007 Michael Buesch <m@bues.ch> 
    1010 * 
    1111 * Licensed under the GNU/GPL. See COPYING for details. 
    1212 */ 
    static int ssb_pcihost_resume(struct pci 
    5353# define ssb_pcihost_resume     NULL 
    5454#endif /* CONFIG_PM */ 
    5555 
    56 static int ssb_pcihost_probe(struct pci_dev *dev, 
    57                              const struct pci_device_id *id) 
     56static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     57                                       const struct pci_device_id *id) 
    5858{ 
    5959        struct ssb_bus *ssb; 
    6060        int err = -ENOMEM; 
    6161        const char *name; 
     62        u32 val; 
    6263 
    6364        ssb = kzalloc(sizeof(*ssb), GFP_KERNEL); 
    6465        if (!ssb) 
    static int ssb_pcihost_probe(struct pci_ 
    7475                goto err_pci_disable; 
    7576        pci_set_master(dev); 
    7677 
     78        /* Disable the RETRY_TIMEOUT register (0x41) to keep 
     79         * PCI Tx retries from interfering with C3 CPU state */ 
     80        pci_read_config_dword(dev, 0x40, &val); 
     81        if ((val & 0x0000ff00) != 0) 
     82                pci_write_config_dword(dev, 0x40, val & 0xffff00ff); 
     83 
    7784        err = ssb_bus_pcibus_register(ssb, dev); 
    7885        if (err) 
    7986                goto err_pci_release_regions; 
    static void ssb_pcihost_remove(struct pc 
    103110        pci_set_drvdata(dev, NULL); 
    104111} 
    105112 
    106 int ssb_pcihost_register(struct pci_driver *driver) 
     113int __devinit ssb_pcihost_register(struct pci_driver *driver) 
    107114{ 
    108115        driver->probe = ssb_pcihost_probe; 
    109116        driver->remove = ssb_pcihost_remove; 
  • drivers/ssb/scan.c

    a b  
    22 * Sonics Silicon Backplane 
    33 * Bus scanning 
    44 * 
    5  * Copyright (C) 2005-2007 Michael Buesch <mb@bu3sch.de> 
     5 * Copyright (C) 2005-2007 Michael Buesch <m@bues.ch> 
    66 * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de> 
    77 * Copyright (C) 2005 Stefano Brivio <st3@riseup.net> 
    88 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org> 
    static int we_support_multiple_80211_cor 
    258258#ifdef CONFIG_SSB_PCIHOST 
    259259        if (bus->bustype == SSB_BUSTYPE_PCI) { 
    260260                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
    261                     bus->host_pci->device == 0x4324) 
     261                    ((bus->host_pci->device == 0x4313) || 
     262                     (bus->host_pci->device == 0x431A) || 
     263                     (bus->host_pci->device == 0x4321) || 
     264                     (bus->host_pci->device == 0x4324))) 
    262265                        return 1; 
    263266        } 
    264267#endif /* CONFIG_SSB_PCIHOST */ 
    int ssb_bus_scan(struct ssb_bus *bus, 
    307310        } else { 
    308311                if (bus->bustype == SSB_BUSTYPE_PCI) { 
    309312                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
    310                         pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
    311                                              &bus->chip_rev); 
     313                        bus->chip_rev = bus->host_pci->revision; 
    312314                        bus->chip_package = 0; 
    313315                } else { 
    314316                        bus->chip_id = 0x4710; 
    int ssb_bus_scan(struct ssb_bus *bus, 
    405407                                /* Ignore PCI cores on PCI-E cards. 
    406408                                 * Ignore PCI-E cores on PCI cards. */ 
    407409                                if (dev->id.coreid == SSB_DEV_PCI) { 
    408                                         if (bus->host_pci->is_pcie) 
     410                                        if (pci_is_pcie(bus->host_pci)) 
    409411                                                continue; 
    410412                                } else { 
    411                                         if (!bus->host_pci->is_pcie) 
     413                                        if (!pci_is_pcie(bus->host_pci)) 
    412414                                                continue; 
    413415                                } 
    414416                        } 
    int ssb_bus_scan(struct ssb_bus *bus, 
    420422                        bus->pcicore.dev = dev; 
    421423#endif /* CONFIG_SSB_DRIVER_PCICORE */ 
    422424                        break; 
     425                case SSB_DEV_ETHERNET: 
     426                        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     427                                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     428                                    (bus->host_pci->device & 0xFF00) == 0x4300) { 
     429                                        /* This is a dangling ethernet core on a 
     430                                         * wireless device. Ignore it. */ 
     431                                        continue; 
     432                                } 
     433                        } 
     434                        break; 
    423435                default: 
    424436                        break; 
    425437                } 
  • include/linux/ssb/ssb.h

    a b struct pcmcia_device; 
    1616struct ssb_bus; 
    1717struct ssb_driver; 
    1818 
     19struct ssb_sprom_core_pwr_info { 
     20        u8 itssi_2g, itssi_5g; 
     21        u8 maxpwr_2g, maxpwr_5gl, maxpwr_5g, maxpwr_5gh; 
     22        u16 pa_2g[3], pa_5gl[3], pa_5g[3], pa_5gh[3]; 
     23}; 
     24 
    1925struct ssb_sprom { 
    2026        u8 revision; 
    2127        u8 il0mac[6];           /* MAC address for 802.11b/g */ 
    struct ssb_sprom { 
    2531        u8 et1phyaddr;          /* MII address for enet1 */ 
    2632        u8 et0mdcport;          /* MDIO for enet0 */ 
    2733        u8 et1mdcport;          /* MDIO for enet1 */ 
    28         u8 board_rev;           /* Board revision number from SPROM. */ 
     34        u16 board_rev;          /* Board revision number from SPROM. */ 
    2935        u8 country_code;        /* Country Code */ 
     36        u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */ 
     37        u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */ 
    3038        u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
    3139        u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
    3240        u16 pa0b0; 
    struct ssb_sprom { 
    5563        u8 tri5gl;              /* 5.2GHz TX isolation */ 
    5664        u8 tri5g;               /* 5.3GHz TX isolation */ 
    5765        u8 tri5gh;              /* 5.8GHz TX isolation */ 
     66        u8 txpid2g[4];          /* 2GHz TX power index */ 
     67        u8 txpid5gl[4];         /* 4.9 - 5.1GHz TX power index */ 
     68        u8 txpid5g[4];          /* 5.1 - 5.5GHz TX power index */ 
     69        u8 txpid5gh[4];         /* 5.5 - ...GHz TX power index */ 
    5870        u8 rxpo2g;              /* 2GHz RX power offset */ 
    5971        u8 rxpo5g;              /* 5GHz RX power offset */ 
    6072        u8 rssisav2g;           /* 2GHz RSSI params */ 
    struct ssb_sprom { 
    7688        u16 boardflags2_hi;     /* Board flags (bits 48-63) */ 
    7789        /* TODO store board flags in a single u64 */ 
    7890 
     91        struct ssb_sprom_core_pwr_info core_pwr_info[4]; 
     92 
    7993        /* Antenna gain values for up to 4 antennas 
    8094         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    8195         * loss in the connectors is bigger than the gain. */ 
    struct ssb_sprom { 
    88102                } ghz5;         /* 5GHz band */ 
    89103        } antenna_gain; 
    90104 
     105        struct { 
     106                struct { 
     107                        u8 tssipos, extpa_gain, pdet_range, tr_iso, antswlut; 
     108                } ghz2; 
     109                struct { 
     110                        u8 tssipos, extpa_gain, pdet_range, tr_iso, antswlut; 
     111                } ghz5; 
     112        } fem; 
     113 
    91114        /* TODO - add any parameters needed from rev 2, 3, 4, 5 or 8 SPROMs */ 
    92115}; 
    93116 
    struct ssb_sprom { 
    95118struct ssb_boardinfo { 
    96119        u16 vendor; 
    97120        u16 type; 
    98         u16 rev; 
     121        u8 rev; 
    99122}; 
    100123 
    101124 
    struct ssb_driver { 
    225248#define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv) 
    226249 
    227250extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner); 
    228 static inline int ssb_driver_register(struct ssb_driver *drv) 
    229 { 
    230         return __ssb_driver_register(drv, THIS_MODULE); 
    231 } 
     251#define ssb_driver_register(drv) \ 
     252        __ssb_driver_register(drv, THIS_MODULE) 
     253 
    232254extern void ssb_driver_unregister(struct ssb_driver *drv); 
    233255 
    234256 
    struct ssb_bus { 
    304326 
    305327        /* ID information about the Chip. */ 
    306328        u16 chip_id; 
    307         u16 chip_rev; 
     329        u8 chip_rev; 
    308330        u16 sprom_offset; 
    309331        u16 sprom_size;         /* number of words in sprom */ 
    310332        u8 chip_package; 
    extern bool ssb_is_sprom_available(struc 
    400422 
    401423/* Set a fallback SPROM. 
    402424 * See kdoc at the function definition for complete documentation. */ 
    403 extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     425extern int ssb_arch_register_fallback_sprom( 
     426                int (*sprom_callback)(struct ssb_bus *bus, 
     427                struct ssb_sprom *out)); 
    404428 
    405429/* Suspend a SSB bus. 
    406430 * Call this from the parent bus suspend routine. */ 
    extern int ssb_bus_may_powerdown(struct 
    514538 * Otherwise static always-on powercontrol will be used. */ 
    515539extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
    516540 
     541extern void ssb_commit_settings(struct ssb_bus *bus); 
    517542 
    518543/* Various helper functions */ 
    519544extern u32 ssb_admatch_base(u32 adm); 
  • include/linux/ssb/ssb_regs.h

    a b  
    8585#define  SSB_IMSTATE_AP_RSV     0x00000030 /* Reserved */ 
    8686#define  SSB_IMSTATE_IBE        0x00020000 /* In Band Error */ 
    8787#define  SSB_IMSTATE_TO         0x00040000 /* Timeout */ 
     88#define  SSB_IMSTATE_BUSY       0x01800000 /* Busy (Backplane rev >= 2.3 only) */ 
     89#define  SSB_IMSTATE_REJECT     0x02000000 /* Reject (Backplane rev >= 2.3 only) */ 
    8890#define SSB_INTVEC              0x0F94     /* SB Interrupt Mask */ 
    8991#define  SSB_INTVEC_PCI         0x00000001 /* Enable interrupts for PCI */ 
    9092#define  SSB_INTVEC_ENET0       0x00000002 /* Enable interrupts for enet 0 */ 
     
    9597#define  SSB_INTVEC_ENET1       0x00000040 /* Enable interrupts for enet 1 */ 
    9698#define SSB_TMSLOW              0x0F98     /* SB Target State Low */ 
    9799#define  SSB_TMSLOW_RESET       0x00000001 /* Reset */ 
    98 #define  SSB_TMSLOW_REJECT_22   0x00000002 /* Reject (Backplane rev 2.2) */ 
     100#define  SSB_TMSLOW_REJECT      0x00000002 /* Reject (Standard Backplane) */ 
    99101#define  SSB_TMSLOW_REJECT_23   0x00000004 /* Reject (Backplane rev 2.3) */ 
    100 #define  SSB_TMSLOW_PHYCLK      0x00000010 /* MAC PHY Clock Control Enable */ 
    101102#define  SSB_TMSLOW_CLOCK       0x00010000 /* Clock Enable */ 
    102103#define  SSB_TMSLOW_FGC         0x00020000 /* Force Gated Clocks On */ 
    103104#define  SSB_TMSLOW_PE          0x40000000 /* Power Management Enable */ 
     
    268269/* SPROM Revision 4 */ 
    269270#define SSB_SPROM4_BFLLO                0x0044  /* Boardflags (low 16 bits) */ 
    270271#define SSB_SPROM4_BFLHI                0x0046  /* Board Flags Hi */ 
     272#define SSB_SPROM4_BFL2LO               0x0048  /* Board flags 2 (low 16 bits) */ 
     273#define SSB_SPROM4_BFL2HI               0x004A  /* Board flags 2 Hi */ 
    271274#define SSB_SPROM4_IL0MAC               0x004C  /* 6 byte MAC address for a/b/g/n */ 
    272275#define SSB_SPROM4_CCODE                0x0052  /* Country Code (2 bytes) */ 
    273276#define SSB_SPROM4_GPIOA                0x0056  /* Gen. Purpose IO # 0 and 1 */ 
     
    299302#define  SSB_SPROM4_AGAIN2_SHIFT        0 
    300303#define  SSB_SPROM4_AGAIN3              0xFF00  /* Antenna 3 */ 
    301304#define  SSB_SPROM4_AGAIN3_SHIFT        8 
     305#define SSB_SPROM4_TXPID2G01            0x0062  /* TX Power Index 2GHz */ 
     306#define  SSB_SPROM4_TXPID2G0            0x00FF 
     307#define  SSB_SPROM4_TXPID2G0_SHIFT      0 
     308#define  SSB_SPROM4_TXPID2G1            0xFF00 
     309#define  SSB_SPROM4_TXPID2G1_SHIFT      8 
     310#define SSB_SPROM4_TXPID2G23            0x0064  /* TX Power Index 2GHz */ 
     311#define  SSB_SPROM4_TXPID2G2            0x00FF 
     312#define  SSB_SPROM4_TXPID2G2_SHIFT      0 
     313#define  SSB_SPROM4_TXPID2G3            0xFF00 
     314#define  SSB_SPROM4_TXPID2G3_SHIFT      8 
     315#define SSB_SPROM4_TXPID5G01            0x0066  /* TX Power Index 5GHz middle subband */ 
     316#define  SSB_SPROM4_TXPID5G0            0x00FF 
     317#define  SSB_SPROM4_TXPID5G0_SHIFT      0 
     318#define  SSB_SPROM4_TXPID5G1            0xFF00 
     319#define  SSB_SPROM4_TXPID5G1_SHIFT      8 
     320#define SSB_SPROM4_TXPID5G23            0x0068  /* TX Power Index 5GHz middle subband */ 
     321#define  SSB_SPROM4_TXPID5G2            0x00FF 
     322#define  SSB_SPROM4_TXPID5G2_SHIFT      0 
     323#define  SSB_SPROM4_TXPID5G3            0xFF00 
     324#define  SSB_SPROM4_TXPID5G3_SHIFT      8 
     325#define SSB_SPROM4_TXPID5GL01           0x006A  /* TX Power Index 5GHz low subband */ 
     326#define  SSB_SPROM4_TXPID5GL0           0x00FF 
     327#define  SSB_SPROM4_TXPID5GL0_SHIFT     0 
     328#define  SSB_SPROM4_TXPID5GL1           0xFF00 
     329#define  SSB_SPROM4_TXPID5GL1_SHIFT     8 
     330#define SSB_SPROM4_TXPID5GL23           0x006C  /* TX Power Index 5GHz low subband */ 
     331#define  SSB_SPROM4_TXPID5GL2           0x00FF 
     332#define  SSB_SPROM4_TXPID5GL2_SHIFT     0 
     333#define  SSB_SPROM4_TXPID5GL3           0xFF00 
     334#define  SSB_SPROM4_TXPID5GL3_SHIFT     8 
     335#define SSB_SPROM4_TXPID5GH01           0x006E  /* TX Power Index 5GHz high subband */ 
     336#define  SSB_SPROM4_TXPID5GH0           0x00FF 
     337#define  SSB_SPROM4_TXPID5GH0_SHIFT     0 
     338#define  SSB_SPROM4_TXPID5GH1           0xFF00 
     339#define  SSB_SPROM4_TXPID5GH1_SHIFT     8 
     340#define SSB_SPROM4_TXPID5GH23           0x0070  /* TX Power Index 5GHz high subband */ 
     341#define  SSB_SPROM4_TXPID5GH2           0x00FF 
     342#define  SSB_SPROM4_TXPID5GH2_SHIFT     0 
     343#define  SSB_SPROM4_TXPID5GH3           0xFF00 
     344#define  SSB_SPROM4_TXPID5GH3_SHIFT     8 
    302345#define SSB_SPROM4_MAXP_BG              0x0080  /* Max Power BG in path 1 */ 
    303346#define  SSB_SPROM4_MAXP_BG_MASK        0x00FF  /* Mask for Max Power BG */ 
    304347#define  SSB_SPROM4_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
     
    318361#define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */ 
    319362#define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */ 
    320363#define SSB_SPROM5_BFLHI                0x004C  /* Board Flags Hi */ 
     364#define SSB_SPROM5_BFL2LO               0x004E  /* Board flags 2 (low 16 bits) */ 
     365#define SSB_SPROM5_BFL2HI               0x0050  /* Board flags 2 Hi */ 
    321366#define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */ 
    322367#define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */ 
    323368#define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */ 
     
    387432#define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */ 
    388433#define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */ 
    389434#define  SSB_SPROM8_RXPO5G_SHIFT        8 
     435#define SSB_SPROM8_FEM2G                0x00AE 
     436#define SSB_SPROM8_FEM5G                0x00B0 
     437#define  SSB_SROM8_FEM_TSSIPOS          0x0001 
     438#define  SSB_SROM8_FEM_TSSIPOS_SHIFT    0 
     439#define  SSB_SROM8_FEM_EXTPA_GAIN       0x0006 
     440#define  SSB_SROM8_FEM_EXTPA_GAIN_SHIFT 1 
     441#define  SSB_SROM8_FEM_PDET_RANGE       0x00F8 
     442#define  SSB_SROM8_FEM_PDET_RANGE_SHIFT 3 
     443#define  SSB_SROM8_FEM_TR_ISO           0x0700 
     444#define  SSB_SROM8_FEM_TR_ISO_SHIFT     8 
     445#define  SSB_SROM8_FEM_ANTSWLUT         0xF800 
     446#define  SSB_SROM8_FEM_ANTSWLUT_SHIFT   11 
     447#define SSB_SPROM8_THERMAL              0x00B2 
     448#define SSB_SPROM8_MPWR_RAWTS           0x00B4 
     449#define SSB_SPROM8_TS_SLP_OPT_CORRX     0x00B6 
     450#define SSB_SPROM8_FOC_HWIQ_IQSWP       0x00B8 
     451#define SSB_SPROM8_PHYCAL_TEMPDELTA     0x00BA 
     452 
     453/* There are 4 blocks with power info sharing the same layout */ 
     454#define SSB_SROM8_PWR_INFO_CORE0        0x00C0 
     455#define SSB_SROM8_PWR_INFO_CORE1        0x00E0 
     456#define SSB_SROM8_PWR_INFO_CORE2        0x0100 
     457#define SSB_SROM8_PWR_INFO_CORE3        0x0120 
     458 
     459#define SSB_SROM8_2G_MAXP_ITSSI         0x00 
     460#define  SSB_SPROM8_2G_MAXP             0x00FF 
     461#define  SSB_SPROM8_2G_ITSSI            0xFF00 
     462#define  SSB_SPROM8_2G_ITSSI_SHIFT      8 
     463#define SSB_SROM8_2G_PA_0               0x02    /* 2GHz power amp settings */ 
     464#define SSB_SROM8_2G_PA_1               0x04 
     465#define SSB_SROM8_2G_PA_2               0x06 
     466#define SSB_SROM8_5G_MAXP_ITSSI         0x08    /* 5GHz ITSSI and 5.3GHz Max Power */ 
     467#define  SSB_SPROM8_5G_MAXP             0x00FF 
     468#define  SSB_SPROM8_5G_ITSSI            0xFF00 
     469#define  SSB_SPROM8_5G_ITSSI_SHIFT      8 
     470#define SSB_SPROM8_5GHL_MAXP            0x0A    /* 5.2GHz and 5.8GHz Max Power */ 
     471#define  SSB_SPROM8_5GH_MAXP            0x00FF 
     472#define  SSB_SPROM8_5GL_MAXP            0xFF00 
     473#define  SSB_SPROM8_5GL_MAXP_SHIFT      8 
     474#define SSB_SROM8_5G_PA_0               0x0C    /* 5.3GHz power amp settings */ 
     475#define SSB_SROM8_5G_PA_1               0x0E 
     476#define SSB_SROM8_5G_PA_2               0x10 
     477#define SSB_SROM8_5GL_PA_0              0x12    /* 5.2GHz power amp settings */ 
     478#define SSB_SROM8_5GL_PA_1              0x14 
     479#define SSB_SROM8_5GL_PA_2              0x16 
     480#define SSB_SROM8_5GH_PA_0              0x18    /* 5.8GHz power amp settings */ 
     481#define SSB_SROM8_5GH_PA_1              0x1A 
     482#define SSB_SROM8_5GH_PA_2              0x1C 
     483 
     484/* TODO: Make it deprecated */ 
    390485#define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */ 
    391486#define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */ 
    392487#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
     
    411506#define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */ 
    412507#define SSB_SPROM8_PA1HIB1              0x00DA 
    413508#define SSB_SPROM8_PA1HIB2              0x00DC 
     509 
    414510#define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */ 
    415511#define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */ 
    416512#define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */ 
    417513#define SSB_SPROM8_OFDM5GLPO            0x014A  /* 5.2GHz OFDM power offset */ 
    418514#define SSB_SPROM8_OFDM5GHPO            0x014E  /* 5.8GHz OFDM power offset */ 
    419515 
     516/* Values for boardflags_lo read from SPROM */ 
     517#define SSB_BFL_BTCOEXIST               0x0001  /* implements Bluetooth coexistance */ 
     518#define SSB_BFL_PACTRL                  0x0002  /* GPIO 9 controlling the PA */ 
     519#define SSB_BFL_AIRLINEMODE             0x0004  /* implements GPIO 13 radio disable indication */ 
     520#define SSB_BFL_RSSI                    0x0008  /* software calculates nrssi slope. */ 
     521#define SSB_BFL_ENETSPI                 0x0010  /* has ephy roboswitch spi */ 
     522#define SSB_BFL_XTAL_NOSLOW             0x0020  /* no slow clock available */ 
     523#define SSB_BFL_CCKHIPWR                0x0040  /* can do high power CCK transmission */ 
     524#define SSB_BFL_ENETADM                 0x0080  /* has ADMtek switch */ 
     525#define SSB_BFL_ENETVLAN                0x0100  /* can do vlan */ 
     526#define SSB_BFL_AFTERBURNER             0x0200  /* supports Afterburner mode */ 
     527#define SSB_BFL_NOPCI                   0x0400  /* board leaves PCI floating */ 
     528#define SSB_BFL_FEM                     0x0800  /* supports the Front End Module */ 
     529#define SSB_BFL_EXTLNA                  0x1000  /* has an external LNA */ 
     530#define SSB_BFL_HGPA                    0x2000  /* had high gain PA */ 
     531#define SSB_BFL_BTCMOD                  0x4000  /* BFL_BTCOEXIST is given in alternate GPIOs */ 
     532#define SSB_BFL_ALTIQ                   0x8000  /* alternate I/Q settings */ 
     533 
     534/* Values for boardflags_hi read from SPROM */ 
     535#define SSB_BFH_NOPA                    0x0001  /* has no PA */ 
     536#define SSB_BFH_RSSIINV                 0x0002  /* RSSI uses positive slope (not TSSI) */ 
     537#define SSB_BFH_PAREF                   0x0004  /* uses the PARef LDO */ 
     538#define SSB_BFH_3TSWITCH                0x0008  /* uses a triple throw switch shared with bluetooth */ 
     539#define SSB_BFH_PHASESHIFT              0x0010  /* can support phase shifter */ 
     540#define SSB_BFH_BUCKBOOST               0x0020  /* has buck/booster */ 
     541#define SSB_BFH_FEM_BT                  0x0040  /* has FEM and switch to share antenna with bluetooth */ 
     542 
     543/* Values for boardflags2_lo read from SPROM */ 
     544#define SSB_BFL2_RXBB_INT_REG_DIS       0x0001  /* external RX BB regulator present */ 
     545#define SSB_BFL2_APLL_WAR               0x0002  /* alternative A-band PLL settings implemented */ 
     546#define SSB_BFL2_TXPWRCTRL_EN           0x0004  /* permits enabling TX Power Control */ 
     547#define SSB_BFL2_2X4_DIV                0x0008  /* 2x4 diversity switch */ 
     548#define SSB_BFL2_5G_PWRGAIN             0x0010  /* supports 5G band power gain */ 
     549#define SSB_BFL2_PCIEWAR_OVR            0x0020  /* overrides ASPM and Clkreq settings */ 
     550#define SSB_BFL2_CAESERS_BRD            0x0040  /* is Caesers board (unused) */ 
     551#define SSB_BFL2_BTC3WIRE               0x0080  /* used 3-wire bluetooth coexist */ 
     552#define SSB_BFL2_SKWRKFEM_BRD           0x0100  /* 4321mcm93 uses Skyworks FEM */ 
     553#define SSB_BFL2_SPUR_WAR               0x0200  /* has a workaround for clock-harmonic spurs */ 
     554#define SSB_BFL2_GPLL_WAR               0x0400  /* altenative G-band PLL settings implemented */ 
     555 
    420556/* Values for SSB_SPROM1_BINF_CCODE */ 
    421557enum { 
    422558        SSB_SPROM1CCODE_WORLD = 0, 
  • drivers/ssb/driver_chipcommon.c

    a b  
    33 * Broadcom ChipCommon core driver 
    44 * 
    55 * Copyright 2005, Broadcom Corporation 
    6  * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
    void ssb_chipco_set_clockmode(struct ssb 
    4646        if (!ccdev) 
    4747                return; 
    4848        bus = ccdev->bus; 
     49 
     50        /* We support SLOW only on 6..9 */ 
     51        if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW) 
     52                mode = SSB_CLKMODE_DYNAMIC; 
     53 
     54        if (cc->capabilities & SSB_CHIPCO_CAP_PMU) 
     55                return; /* PMU controls clockmode, separated function needed */ 
     56        SSB_WARN_ON(ccdev->id.revision >= 20); 
     57 
    4958        /* chipcommon cores prior to rev6 don't support dynamic clock control */ 
    5059        if (ccdev->id.revision < 6) 
    5160                return; 
    52         /* chipcommon cores rev10 are a whole new ball game */ 
     61 
     62        /* ChipCommon cores rev10+ need testing */ 
    5363        if (ccdev->id.revision >= 10) 
    5464                return; 
     65 
    5566        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
    5667                return; 
    5768 
    5869        switch (mode) { 
    59         case SSB_CLKMODE_SLOW: 
     70        case SSB_CLKMODE_SLOW: /* For revs 6..9 only */ 
    6071                tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
    6172                tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
    6273                chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
    6374                break; 
    6475        case SSB_CLKMODE_FAST: 
    65                 ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
    66                 tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
    67                 tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
    68                 tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
    69                 chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     76                if (ccdev->id.revision < 10) { 
     77                        ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     78                        tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     79                        tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     80                        tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     81                        chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     82                } else { 
     83                        chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     84                                (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) | 
     85                                 SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     86                        /* udelay(150); TODO: not available in early init */ 
     87                } 
    7088                break; 
    7189        case SSB_CLKMODE_DYNAMIC: 
    72                 tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
    73                 tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
    74                 tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
    75                 tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
    76                 if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
    77                         tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
    78                 chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
    79  
    80                 /* for dynamic control, we have to release our xtal_pu "force on" */ 
    81                 if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
    82                         ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     90                if (ccdev->id.revision < 10) { 
     91                        tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     92                        tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     93                        tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     94                        tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     95                        if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != 
     96                            SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     97                                tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     98                        chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     99 
     100                        /* For dynamic control, we have to release our xtal_pu 
     101                         * "force on" */ 
     102                        if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     103                                ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     104                } else { 
     105                        chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     106                                (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) & 
     107                                 ~SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     108                } 
    83109                break; 
    84110        default: 
    85111                SSB_WARN_ON(1); 
    void ssb_chipcommon_init(struct ssb_chip 
    260286        if (cc->dev->id.revision >= 11) 
    261287                cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    262288        ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     289 
     290        if (cc->dev->id.revision >= 20) { 
     291                chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0); 
     292                chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0); 
     293        } 
     294 
    263295        ssb_pmu_init(cc); 
    264296        chipco_powercontrol_init(cc); 
    265297        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
  • drivers/ssb/driver_chipcommon_pmu.c

    a b  
    22 * Sonics Silicon Backplane 
    33 * Broadcom ChipCommon Power Management Unit driver 
    44 * 
    5  * Copyright 2009, Michael Buesch <mb@bu3sch.de> 
     5 * Copyright 2009, Michael Buesch <m@bues.ch> 
    66 * Copyright 2007, Broadcom Corporation 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    static void ssb_pmu_resources_init(struc 
    417417        u32 min_msk = 0, max_msk = 0; 
    418418        unsigned int i; 
    419419        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
    420         unsigned int updown_tab_size; 
     420        unsigned int updown_tab_size = 0; 
    421421        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
    422         unsigned int depend_tab_size; 
     422        unsigned int depend_tab_size = 0; 
    423423 
    424424        switch (bus->chip_id) { 
    425425        case 0x4312: 
     426                 min_msk = 0xCBB; 
     427                 break; 
    426428        case 0x4322: 
    427429                /* We keep the default settings: 
    428430                 * min_msk = 0xCBB 
  • drivers/ssb/driver_gige.c

    a b  
    33 * Broadcom Gigabit Ethernet core driver 
    44 * 
    55 * Copyright 2008, Broadcom Corporation 
    6  * Copyright 2008, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2008, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
    void gige_pcicfg_write32(struct ssb_gige 
    106106        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
    107107} 
    108108 
    109 static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
    110                                     int reg, int size, u32 *val) 
     109static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus, 
     110                                              unsigned int devfn, int reg, 
     111                                              int size, u32 *val) 
    111112{ 
    112113        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
    113114        unsigned long flags; 
    static int ssb_gige_pci_read_config(stru 
    136137        return PCIBIOS_SUCCESSFUL; 
    137138} 
    138139 
    139 static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
    140                                      int reg, int size, u32 val) 
     140static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus, 
     141                                               unsigned int devfn, int reg, 
     142                                               int size, u32 val) 
    141143{ 
    142144        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
    143145        unsigned long flags; 
    static int ssb_gige_pci_write_config(str 
    166168        return PCIBIOS_SUCCESSFUL; 
    167169} 
    168170 
    169 static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id) 
     171static int __devinit ssb_gige_probe(struct ssb_device *sdev, 
     172                                    const struct ssb_device_id *id) 
    170173{ 
    171174        struct ssb_gige *dev; 
    172175        u32 base, tmslow, tmshigh; 
  • drivers/ssb/driver_pcicore.c

    a b  
    33 * Broadcom PCI-core driver 
    44 * 
    55 * Copyright 2005, Broadcom Corporation 
    6  * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
     
    1515 
    1616#include "ssb_private.h" 
    1717 
     18static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address); 
     19static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data); 
     20static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address); 
     21static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     22                                u8 address, u16 data); 
    1823 
    1924static inline 
    2025u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset) 
    int ssb_pcicore_pcibios_map_irq(const st 
    309314        return ssb_mips_irq(extpci_core->dev) + 2; 
    310315} 
    311316 
    312 static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     317static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
    313318{ 
    314319        u32 val; 
    315320 
    static void ssb_pcicore_init_hostmode(st 
    374379        register_pci_controller(&ssb_pcicore_controller); 
    375380} 
    376381 
    377 static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     382static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
    378383{ 
    379384        struct ssb_bus *bus = pc->dev->bus; 
    380385        u16 chipid_top; 
    static int pcicore_is_in_hostmode(struct 
    403408} 
    404409#endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
    405410 
     411/************************************************** 
     412 * Workarounds. 
     413 **************************************************/ 
     414 
     415static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc) 
     416{ 
     417        u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0)); 
     418        if (((tmp & 0xF000) >> 12) != pc->dev->core_index) { 
     419                tmp &= ~0xF000; 
     420                tmp |= (pc->dev->core_index << 12); 
     421                pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp); 
     422        } 
     423} 
     424 
     425static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc) 
     426{ 
     427        return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80; 
     428} 
     429 
     430static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc) 
     431{ 
     432        const u8 serdes_pll_device = 0x1D; 
     433        const u8 serdes_rx_device = 0x1F; 
     434        u16 tmp; 
     435 
     436        ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */, 
     437                            ssb_pcicore_polarity_workaround(pc)); 
     438        tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */); 
     439        if (tmp & 0x4000) 
     440                ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000); 
     441} 
     442 
     443static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc) 
     444{ 
     445        struct ssb_device *pdev = pc->dev; 
     446        struct ssb_bus *bus = pdev->bus; 
     447        u32 tmp; 
     448 
     449        tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     450        tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     451        tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     452        pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     453 
     454        if (pdev->id.revision < 5) { 
     455                tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     456                tmp &= ~SSB_IMCFGLO_SERTO; 
     457                tmp |= 2; 
     458                tmp &= ~SSB_IMCFGLO_REQTO; 
     459                tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     460                ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     461                ssb_commit_settings(bus); 
     462        } else if (pdev->id.revision >= 11) { 
     463                tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     464                tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     465                pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     466        } 
     467} 
     468 
     469static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc) 
     470{ 
     471        u32 tmp; 
     472        u8 rev = pc->dev->id.revision; 
     473 
     474        if (rev == 0 || rev == 1) { 
     475                /* TLP Workaround register. */ 
     476                tmp = ssb_pcie_read(pc, 0x4); 
     477                tmp |= 0x8; 
     478                ssb_pcie_write(pc, 0x4, tmp); 
     479        } 
     480        if (rev == 1) { 
     481                /* DLLP Link Control register. */ 
     482                tmp = ssb_pcie_read(pc, 0x100); 
     483                tmp |= 0x40; 
     484                ssb_pcie_write(pc, 0x100, tmp); 
     485        } 
     486 
     487        if (rev == 0) { 
     488                const u8 serdes_rx_device = 0x1F; 
     489 
     490                ssb_pcie_mdio_write(pc, serdes_rx_device, 
     491                                        2 /* Timer */, 0x8128); 
     492                ssb_pcie_mdio_write(pc, serdes_rx_device, 
     493                                        6 /* CDR */, 0x0100); 
     494                ssb_pcie_mdio_write(pc, serdes_rx_device, 
     495                                        7 /* CDR BW */, 0x1466); 
     496        } else if (rev == 3 || rev == 4 || rev == 5) { 
     497                /* TODO: DLLP Power Management Threshold */ 
     498                ssb_pcicore_serdes_workaround(pc); 
     499                /* TODO: ASPM */ 
     500        } else if (rev == 7) { 
     501                /* TODO: No PLL down */ 
     502        } 
     503 
     504        if (rev >= 6) { 
     505                /* Miscellaneous Configuration Fixup */ 
     506                tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5)); 
     507                if (!(tmp & 0x8000)) 
     508                        pcicore_write16(pc, SSB_PCICORE_SPROM(5), 
     509                                        tmp | 0x8000); 
     510        } 
     511} 
    406512 
    407513/************************************************** 
    408514 * Generic and Clientmode operation code. 
    409515 **************************************************/ 
    410516 
    411 static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     517static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
    412518{ 
     519        struct ssb_device *pdev = pc->dev; 
     520        struct ssb_bus *bus = pdev->bus; 
     521 
     522        if (bus->bustype == SSB_BUSTYPE_PCI) 
     523                ssb_pcicore_fix_sprom_core_index(pc); 
     524 
    413525        /* Disable PCI interrupts. */ 
    414         ssb_write32(pc->dev, SSB_INTVEC, 0); 
     526        ssb_write32(pdev, SSB_INTVEC, 0); 
     527 
     528        /* Additional PCIe always once-executed workarounds */ 
     529        if (pc->dev->id.coreid == SSB_DEV_PCIE) { 
     530                ssb_pcicore_serdes_workaround(pc); 
     531                /* TODO: ASPM */ 
     532                /* TODO: Clock Request Update */ 
     533        } 
    415534} 
    416535 
    417 void ssb_pcicore_init(struct ssb_pcicore *pc) 
     536void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
    418537{ 
    419538        struct ssb_device *dev = pc->dev; 
    420         struct ssb_bus *bus; 
    421539 
    422540        if (!dev) 
    423541                return; 
    424         bus = dev->bus; 
    425542        if (!ssb_device_is_enabled(dev)) 
    426543                ssb_device_enable(dev, 0); 
    427544 
    static void ssb_pcie_write(struct ssb_pc 
    446563        pcicore_write32(pc, 0x134, data); 
    447564} 
    448565 
    449 static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
    450                                 u8 address, u16 data) 
     566static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
     567{ 
     568        const u16 mdio_control = 0x128; 
     569        const u16 mdio_data = 0x12C; 
     570        u32 v; 
     571        int i; 
     572 
     573        v = (1 << 30); /* Start of Transaction */ 
     574        v |= (1 << 28); /* Write Transaction */ 
     575        v |= (1 << 17); /* Turnaround */ 
     576        v |= (0x1F << 18); 
     577        v |= (phy << 4); 
     578        pcicore_write32(pc, mdio_data, v); 
     579 
     580        udelay(10); 
     581        for (i = 0; i < 200; i++) { 
     582                v = pcicore_read32(pc, mdio_control); 
     583                if (v & 0x100 /* Trans complete */) 
     584                        break; 
     585                msleep(1); 
     586        } 
     587} 
     588 
     589static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address) 
    451590{ 
    452591        const u16 mdio_control = 0x128; 
    453592        const u16 mdio_data = 0x12C; 
     593        int max_retries = 10; 
     594        u16 ret = 0; 
    454595        u32 v; 
    455596        int i; 
    456597 
    static void ssb_pcie_mdio_write(struct s 
    458599        v |= 0x2; /* MDIO Clock Divisor */ 
    459600        pcicore_write32(pc, mdio_control, v); 
    460601 
     602        if (pc->dev->id.revision >= 10) { 
     603                max_retries = 200; 
     604                ssb_pcie_mdio_set_phy(pc, device); 
     605        } 
     606 
    461607        v = (1 << 30); /* Start of Transaction */ 
    462         v |= (1 << 28); /* Write Transaction */ 
     608        v |= (1 << 29); /* Read Transaction */ 
    463609        v |= (1 << 17); /* Turnaround */ 
    464         v |= (u32)device << 22; 
     610        if (pc->dev->id.revision < 10) 
     611                v |= (u32)device << 22; 
    465612        v |= (u32)address << 18; 
    466         v |= data; 
    467613        pcicore_write32(pc, mdio_data, v); 
    468614        /* Wait for the device to complete the transaction */ 
    469615        udelay(10); 
    470         for (i = 0; i < 10; i++) { 
     616        for (i = 0; i < max_retries; i++) { 
    471617                v = pcicore_read32(pc, mdio_control); 
    472                 if (v & 0x100 /* Trans complete */) 
     618                if (v & 0x100 /* Trans complete */) { 
     619                        udelay(10); 
     620                        ret = pcicore_read32(pc, mdio_data); 
    473621                        break; 
     622                } 
    474623                msleep(1); 
    475624        } 
    476625        pcicore_write32(pc, mdio_control, 0); 
     626        return ret; 
    477627} 
    478628 
    479 static void ssb_broadcast_value(struct ssb_device *dev, 
    480                                 u32 address, u32 data) 
     629static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     630                                u8 address, u16 data) 
    481631{ 
    482         /* This is used for both, PCI and ChipCommon core, so be careful. */ 
    483         BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
    484         BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     632        const u16 mdio_control = 0x128; 
     633        const u16 mdio_data = 0x12C; 
     634        int max_retries = 10; 
     635        u32 v; 
     636        int i; 
    485637 
    486         ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
    487         ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
    488         ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
    489         ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
    490 } 
     638        v = 0x80; /* Enable Preamble Sequence */ 
     639        v |= 0x2; /* MDIO Clock Divisor */ 
     640        pcicore_write32(pc, mdio_control, v); 
    491641 
    492 static void ssb_commit_settings(struct ssb_bus *bus) 
    493 { 
    494         struct ssb_device *dev; 
     642        if (pc->dev->id.revision >= 10) { 
     643                max_retries = 200; 
     644                ssb_pcie_mdio_set_phy(pc, device); 
     645        } 
    495646 
    496         dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
    497         if (WARN_ON(!dev)) 
    498                 return; 
    499         /* This forces an update of the cached registers. */ 
    500         ssb_broadcast_value(dev, 0xFD8, 0); 
     647        v = (1 << 30); /* Start of Transaction */ 
     648        v |= (1 << 28); /* Write Transaction */ 
     649        v |= (1 << 17); /* Turnaround */ 
     650        if (pc->dev->id.revision < 10) 
     651                v |= (u32)device << 22; 
     652        v |= (u32)address << 18; 
     653        v |= data; 
     654        pcicore_write32(pc, mdio_data, v); 
     655        /* Wait for the device to complete the transaction */ 
     656        udelay(10); 
     657        for (i = 0; i < max_retries; i++) { 
     658                v = pcicore_read32(pc, mdio_control); 
     659                if (v & 0x100 /* Trans complete */) 
     660                        break; 
     661                msleep(1); 
     662        } 
     663        pcicore_write32(pc, mdio_control, 0); 
    501664} 
    502665 
    503666int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
    int ssb_pcicore_dev_irqvecs_enable(struc 
    550713        if (pc->setup_done) 
    551714                goto out; 
    552715        if (pdev->id.coreid == SSB_DEV_PCI) { 
    553                 tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
    554                 tmp |= SSB_PCICORE_SBTOPCI_PREF; 
    555                 tmp |= SSB_PCICORE_SBTOPCI_BURST; 
    556                 pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
    557  
    558                 if (pdev->id.revision < 5) { 
    559                         tmp = ssb_read32(pdev, SSB_IMCFGLO); 
    560                         tmp &= ~SSB_IMCFGLO_SERTO; 
    561                         tmp |= 2; 
    562                         tmp &= ~SSB_IMCFGLO_REQTO; 
    563                         tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
    564                         ssb_write32(pdev, SSB_IMCFGLO, tmp); 
    565                         ssb_commit_settings(bus); 
    566                 } else if (pdev->id.revision >= 11) { 
    567                         tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
    568                         tmp |= SSB_PCICORE_SBTOPCI_MRM; 
    569                         pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
    570                 } 
     716                ssb_pcicore_pci_setup_workarounds(pc); 
    571717        } else { 
    572718                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
    573                 //TODO: Better make defines for all these magic PCIE values. 
    574                 if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
    575                         /* TLP Workaround register. */ 
    576                         tmp = ssb_pcie_read(pc, 0x4); 
    577                         tmp |= 0x8; 
    578                         ssb_pcie_write(pc, 0x4, tmp); 
    579                 } 
    580                 if (pdev->id.revision == 0) { 
    581                         const u8 serdes_rx_device = 0x1F; 
    582  
    583                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    584                                             2 /* Timer */, 0x8128); 
    585                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    586                                             6 /* CDR */, 0x0100); 
    587                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    588                                             7 /* CDR BW */, 0x1466); 
    589                 } else if (pdev->id.revision == 1) { 
    590                         /* DLLP Link Control register. */ 
    591                         tmp = ssb_pcie_read(pc, 0x100); 
    592                         tmp |= 0x40; 
    593                         ssb_pcie_write(pc, 0x100, tmp); 
    594                 } 
     719                ssb_pcicore_pcie_setup_workarounds(pc); 
    595720        } 
    596721        pc->setup_done = 1; 
    597722out: 
  • drivers/ssb/sprom.c

    a b  
    22 * Sonics Silicon Backplane 
    33 * Common SPROM support routines 
    44 * 
    5  * Copyright (C) 2005-2008 Michael Buesch <mb@bu3sch.de> 
     5 * Copyright (C) 2005-2008 Michael Buesch <m@bues.ch> 
    66 * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de> 
    77 * Copyright (C) 2005 Stefano Brivio <st3@riseup.net> 
    88 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org> 
     
    1717#include <linux/slab.h> 
    1818 
    1919 
    20 static const struct ssb_sprom *fallback_sprom; 
     20static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
    2121 
    2222 
    2323static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
    out: 
    145145} 
    146146 
    147147/** 
    148  * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
     148 * ssb_arch_register_fallback_sprom - Registers a method providing a 
     149 * fallback SPROM if no SPROM is found. 
    149150 * 
    150  * @sprom: The SPROM data structure to register. 
     151 * @sprom_callback: The callback function. 
    151152 * 
    152  * With this function the architecture implementation may register a fallback 
    153  * SPROM data structure. The fallback is only used for PCI based SSB devices, 
    154  * where no valid SPROM can be found in the shadow registers. 
     153 * With this function the architecture implementation may register a 
     154 * callback handler which fills the SPROM data structure. The fallback is 
     155 * only used for PCI based SSB devices, where no valid SPROM can be found 
     156 * in the shadow registers. 
     157 * 
     158 * This function is useful for weird architectures that have a half-assed 
     159 * SSB device hardwired to their PCI bus. 
     160 * 
     161 * Note that it does only work with PCI attached SSB devices. PCMCIA 
     162 * devices currently don't use this fallback. 
     163 * Architectures must provide the SPROM for native SSB devices anyway, so 
     164 * the fallback also isn't used for native devices. 
    155165 * 
    156  * This function is useful for weird architectures that have a half-assed SSB device 
    157  * hardwired to their PCI bus. 
    158  * 
    159  * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
    160  * don't use this fallback. 
    161  * Architectures must provide the SPROM for native SSB devices anyway, 
    162  * so the fallback also isn't used for native devices. 
    163  * 
    164  * This function is available for architecture code, only. So it is not exported. 
     166 * This function is available for architecture code, only. So it is not 
     167 * exported. 
    165168 */ 
    166 int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 
     169int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus, 
     170                                     struct ssb_sprom *out)) 
    167171{ 
    168         if (fallback_sprom) 
     172        if (get_fallback_sprom) 
    169173                return -EEXIST; 
    170         fallback_sprom = sprom; 
     174        get_fallback_sprom = sprom_callback; 
    171175 
    172176        return 0; 
    173177} 
    174178 
    175 const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     179int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
    176180{ 
    177         return fallback_sprom; 
     181        if (!get_fallback_sprom) 
     182                return -ENOENT; 
     183 
     184        return get_fallback_sprom(bus, out); 
    178185} 
    179186 
    180187/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
    bool ssb_is_sprom_available(struct ssb_b 
    185192        /* this routine differs from specs as we do not access SPROM directly 
    186193           on PCMCIA */ 
    187194        if (bus->bustype == SSB_BUSTYPE_PCI && 
    188             bus->chipco.dev &&  /* can be unavailible! */ 
     195            bus->chipco.dev &&  /* can be unavailable! */ 
    189196            bus->chipco.dev->id.revision >= 31) 
    190197                return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
    191198 
  • drivers/ssb/ssb_private.h

    a b ssize_t ssb_attr_sprom_store(struct ssb_ 
    171171                             const char *buf, size_t count, 
    172172                             int (*sprom_check_crc)(const u16 *sprom, size_t size), 
    173173                             int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)); 
    174 extern const struct ssb_sprom *ssb_get_fallback_sprom(void); 
     174extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, 
     175                                        struct ssb_sprom *out); 
    175176 
    176177 
    177178/* core.c */ 
  • include/linux/ssb/ssb_driver_chipcommon.h

    a b  
    88 * gpio interface, extbus, and support for serial and parallel flashes. 
    99 * 
    1010 * Copyright 2005, Broadcom Corporation 
    11  * Copyright 2006, Michael Buesch <mb@bu3sch.de> 
     11 * Copyright 2006, Michael Buesch <m@bues.ch> 
    1212 * 
    1313 * Licensed under the GPL version 2. See COPYING for details. 
    1414 */ 
     
    123123#define SSB_CHIPCO_FLASHDATA            0x0048 
    124124#define SSB_CHIPCO_BCAST_ADDR           0x0050 
    125125#define SSB_CHIPCO_BCAST_DATA           0x0054 
     126#define SSB_CHIPCO_GPIOPULLUP           0x0058          /* Rev >= 20 only */ 
     127#define SSB_CHIPCO_GPIOPULLDOWN         0x005C          /* Rev >= 20 only */ 
    126128#define SSB_CHIPCO_GPIOIN               0x0060 
    127129#define SSB_CHIPCO_GPIOOUT              0x0064 
    128130#define SSB_CHIPCO_GPIOOUTEN            0x0068 
     
    131133#define SSB_CHIPCO_GPIOIRQ              0x0074 
    132134#define SSB_CHIPCO_WATCHDOG             0x0080 
    133135#define SSB_CHIPCO_GPIOTIMER            0x0088          /* LED powersave (corerev >= 16) */ 
     136#define  SSB_CHIPCO_GPIOTIMER_OFFTIME   0x0000FFFF 
     137#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT     0 
     138#define  SSB_CHIPCO_GPIOTIMER_ONTIME    0xFFFF0000 
    134139#define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT      16 
    135140#define SSB_CHIPCO_GPIOTOUTM            0x008C          /* LED powersave (corerev >= 16) */ 
    136141#define SSB_CHIPCO_CLOCK_N              0x0090 
     
    189194#define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */ 
    190195#define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ  0x00000010 /* HT available request */ 
    191196#define  SSB_CHIPCO_CLKCTLST_HWCROFF    0x00000020 /* Force HW clock request off */ 
    192 #define  SSB_CHIPCO_CLKCTLST_HAVEHT     0x00010000 /* HT available */ 
    193 #define  SSB_CHIPCO_CLKCTLST_HAVEALP    0x00020000 /* APL available */ 
     197#define  SSB_CHIPCO_CLKCTLST_HAVEALP    0x00010000 /* ALP available */ 
     198#define  SSB_CHIPCO_CLKCTLST_HAVEHT     0x00020000 /* HT available */ 
     199#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT      0x00010000 /* 4328a0 has reversed bits */ 
     200#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP     0x00020000 /* 4328a0 has reversed bits */ 
    194201#define SSB_CHIPCO_HW_WORKAROUND        0x01E4 /* Hardware workaround (rev >= 20) */ 
    195202#define SSB_CHIPCO_UART0_DATA           0x0300 
    196203#define SSB_CHIPCO_UART0_IMR            0x0304 
  • drivers/ssb/b43_pci_bridge.c

    a b  
    55 * because of its small size we include it in the SSB core 
    66 * instead of creating a standalone module. 
    77 * 
    8  * Copyright 2007  Michael Buesch <mb@bu3sch.de> 
     8 * Copyright 2007  Michael Buesch <m@bues.ch> 
    99 * 
    1010 * Licensed under the GNU/GPL. See COPYING for details. 
    1111 */ 
    1212 
    1313#include <linux/pci.h> 
     14#include <linux/module.h> 
    1415#include <linux/ssb/ssb.h> 
    1516 
    1617#include "ssb_private.h" 
  • drivers/ssb/driver_extif.c

    a b  
    33 * Broadcom EXTIF core driver 
    44 * 
    55 * Copyright 2005, Broadcom Corporation 
    6  * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 
    77 * Copyright 2006, 2007, Felix Fietkau <nbd@openwrt.org> 
    88 * Copyright 2007, Aurelien Jarno <aurelien@aurel32.net> 
    99 * 
  • drivers/ssb/driver_mipscore.c

    a b  
    33 * Broadcom MIPS core driver 
    44 * 
    55 * Copyright 2005, Broadcom Corporation 
    6  * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006, 2007, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
  • drivers/ssb/embedded.c

    a b  
    33 * Embedded systems support code 
    44 * 
    55 * Copyright 2005-2008, Broadcom Corporation 
    6  * Copyright 2006-2008, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2006-2008, Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
  • drivers/ssb/pcmcia.c

    a b  
    33 * PCMCIA-Hostbus related functions 
    44 * 
    55 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 
    6  * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2007-2008 Michael Buesch <m@bues.ch> 
    77 * 
    88 * Licensed under the GNU/GPL. See COPYING for details. 
    99 */ 
  • drivers/ssb/sdio.c

    a b  
    66 * 
    77 * Based on drivers/ssb/pcmcia.c 
    88 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 
    9  * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de> 
     9 * Copyright 2007-2008 Michael Buesch <m@bues.ch> 
    1010 * 
    1111 * Licensed under the GNU/GPL. See COPYING for details. 
    1212 * 
Note: See TracBrowser for help on using the repository browser.