source: trunk/target/linux/generic/patches-2.6.38/020-ssb_update.patch @ 31191

Last change on this file since 31191 was 31191, checked in by florian, 4 years ago

[kernel/2.6.38] refresh patches

File size: 53.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> 
    error: 
    557558} 
    558559 
    559560/* Needs ssb_buses_lock() */ 
    560 static int ssb_attach_queued_buses(void) 
     561static int __devinit ssb_attach_queued_buses(void) 
    561562{ 
    562563        struct ssb_bus *bus, *n; 
    563564        int err = 0; 
    out: 
    768769        return err; 
    769770} 
    770771 
    771 static int ssb_bus_register(struct ssb_bus *bus, 
    772                             ssb_invariants_func_t get_invariants, 
    773                             unsigned long baseaddr) 
     772static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     773                                      ssb_invariants_func_t get_invariants, 
     774                                      unsigned long baseaddr) 
    774775{ 
    775776        int err; 
    776777 
    err_disable_xtal: 
    851852} 
    852853 
    853854#ifdef CONFIG_SSB_PCIHOST 
    854 int ssb_bus_pcibus_register(struct ssb_bus *bus, 
    855                             struct pci_dev *host_pci) 
     855int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     856                                      struct pci_dev *host_pci) 
    856857{ 
    857858        int err; 
    858859 
    EXPORT_SYMBOL(ssb_bus_pcibus_register); 
    875876#endif /* CONFIG_SSB_PCIHOST */ 
    876877 
    877878#ifdef CONFIG_SSB_PCMCIAHOST 
    878 int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
    879                               struct pcmcia_device *pcmcia_dev, 
    880                               unsigned long baseaddr) 
     879int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     880                                        struct pcmcia_device *pcmcia_dev, 
     881                                        unsigned long baseaddr) 
    881882{ 
    882883        int err; 
    883884 
    EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
    897898#endif /* CONFIG_SSB_PCMCIAHOST */ 
    898899 
    899900#ifdef CONFIG_SSB_SDIOHOST 
    900 int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
    901                              unsigned int quirks) 
     901int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     902                                       struct sdio_func *func, 
     903                                       unsigned int quirks) 
    902904{ 
    903905        int err; 
    904906 
    int ssb_bus_sdiobus_register(struct ssb_ 
    918920EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
    919921#endif /* CONFIG_SSB_PCMCIAHOST */ 
    920922 
    921 int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    922                             unsigned long baseaddr, 
    923                             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) 
    924926{ 
    925927        int err; 
    926928 
    u32 ssb_calc_clock_rate(u32 plltype, u32 
    10011003        switch (plltype) { 
    10021004        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
    10031005                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
    1004                         return SSB_CHIPCO_CLK_T6_M0; 
    1005                 return SSB_CHIPCO_CLK_T6_M1; 
     1006                        return SSB_CHIPCO_CLK_T6_M1; 
     1007                return SSB_CHIPCO_CLK_T6_M0; 
    10061008        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
    10071009        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
    10081010        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
    static u32 ssb_tmslow_reject_bitmask(str 
    11171119{ 
    11181120        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
    11191121 
    1120         /* The REJECT bit changed position in TMSLOW between 
    1121          * Backplane revisions. */ 
     1122        /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
    11221123        switch (rev) { 
    11231124        case SSB_IDLOW_SSBREV_22: 
    1124                 return SSB_TMSLOW_REJECT_22; 
     1125        case SSB_IDLOW_SSBREV_24: 
     1126        case SSB_IDLOW_SSBREV_26: 
     1127                return SSB_TMSLOW_REJECT; 
    11251128        case SSB_IDLOW_SSBREV_23: 
    11261129                return SSB_TMSLOW_REJECT_23; 
    1127         case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
    1128         case SSB_IDLOW_SSBREV_25:     /* same here */ 
    1129         case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1130        case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
    11301131        case SSB_IDLOW_SSBREV_27:     /* same here */ 
    1131                 return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1132                return SSB_TMSLOW_REJECT;       /* this is a guess */ 
    11321133        default: 
    11331134                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
    11341135                WARN_ON(1); 
    11351136        } 
    1136         return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1137        return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
    11371138} 
    11381139 
    11391140int ssb_device_is_enabled(struct ssb_device *dev) 
    void ssb_device_enable(struct ssb_device 
    11921193} 
    11931194EXPORT_SYMBOL(ssb_device_enable); 
    11941195 
    1195 /* Wait for a bit in a register to get set or unset. 
     1196/* Wait for bitmask in a register to get set or cleared. 
    11961197 * timeout is in units of ten-microseconds */ 
    1197 static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
    1198                         int timeout, int set) 
     1198static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     1199                         int timeout, int set) 
    11991200{ 
    12001201        int i; 
    12011202        u32 val; 
    static int ssb_wait_bit(struct ssb_devic 
    12031204        for (i = 0; i < timeout; i++) { 
    12041205                val = ssb_read32(dev, reg); 
    12051206                if (set) { 
    1206                         if (val & bitmask) 
     1207                        if ((val & bitmask) == bitmask) 
    12071208                                return 0; 
    12081209                } else { 
    12091210                        if (!(val & bitmask)) 
    static int ssb_wait_bit(struct ssb_devic 
    12201221 
    12211222void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
    12221223{ 
    1223         u32 reject; 
     1224        u32 reject, val; 
    12241225 
    12251226        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
    12261227                return; 
    12271228 
    12281229        reject = ssb_tmslow_reject_bitmask(dev); 
    1229         ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
    1230         ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
    1231         ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
    1232         ssb_write32(dev, SSB_TMSLOW, 
    1233                     SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
    1234                     reject | SSB_TMSLOW_RESET | 
    1235                     core_specific_flags); 
    1236         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        } 
    12371256 
    12381257        ssb_write32(dev, SSB_TMSLOW, 
    12391258                    reject | SSB_TMSLOW_RESET | 
    void ssb_device_disable(struct ssb_devic 
    12421261} 
    12431262EXPORT_SYMBOL(ssb_device_disable); 
    12441263 
     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 
    12451277u32 ssb_dma_translation(struct ssb_device *dev) 
    12461278{ 
    12471279        switch (dev->bus->bustype) { 
    12481280        case SSB_BUSTYPE_SSB: 
    12491281                return 0; 
    12501282        case SSB_BUSTYPE_PCI: 
    1251                 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                } 
    12521292        default: 
    12531293                __ssb_dma_not_implemented(dev); 
    12541294        } 
    EXPORT_SYMBOL(ssb_bus_may_powerdown); 
    12911331 
    12921332int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
    12931333{ 
    1294         struct ssb_chipcommon *cc; 
    12951334        int err; 
    12961335        enum ssb_clkmode mode; 
    12971336 
    12981337        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
    12991338        if (err) 
    13001339                goto error; 
    1301         cc = &bus->chipco; 
    1302         mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
    1303         ssb_chipco_set_clockmode(cc, mode); 
    13041340 
    13051341#ifdef CONFIG_SSB_DEBUG 
    13061342        bus->powered_up = 1; 
    13071343#endif 
     1344 
     1345        mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1346        ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1347 
    13081348        return 0; 
    13091349error: 
    13101350        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
    error: 
    13121352} 
    13131353EXPORT_SYMBOL(ssb_bus_powerup); 
    13141354 
     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 
    13151386u32 ssb_admatch_base(u32 adm) 
    13161387{ 
    13171388        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_r45(struct ssb 
    468468                SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0); 
    469469                SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0); 
    470470                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); 
    471473        } else { 
    472474                SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0); 
    473475                SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0); 
    474476                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); 
    475479        } 
    476480        SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A, 
    477481             SSB_SPROM4_ANTAVAIL_A_SHIFT); 
    static void sprom_extract_r45(struct ssb 
    519523static void sprom_extract_r8(struct ssb_sprom *out, const u16 *in) 
    520524{ 
    521525        int i; 
    522         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)); 
    523533 
    524534        /* extract the MAC address */ 
    525535        for (i = 0; i < 3; i++) { 
    static void sprom_extract_r8(struct ssb_ 
    603613        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
    604614               sizeof(out->antenna_gain.ghz5)); 
    605615 
     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 
    606671        sprom_extract_r458(out, in); 
    607672 
    608673        /* TODO - get remaining rev 8 stuff needed */ 
    static int sprom_extract(struct ssb_bus 
    641706                break; 
    642707        default: 
    643708                ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    644                            "  revision %d detected. Will extract" 
     709                           " revision %d detected. Will extract" 
    645710                           " v1\n", out->revision); 
    646711                out->revision = 1; 
    647712                sprom_extract_r123(out, in); 
    static int sprom_extract(struct ssb_bus 
    658723static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    659724                             struct ssb_sprom *sprom) 
    660725{ 
    661         const struct ssb_sprom *fallback; 
    662726        int err; 
    663727        u16 *buf; 
    664728 
    static int ssb_pci_sprom_get(struct ssb_ 
    666730                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
    667731                return -ENODEV; 
    668732        } 
    669         if (bus->chipco.dev) {  /* can be unavailible! */ 
     733        if (bus->chipco.dev) {  /* can be unavailable! */ 
    670734                /* 
    671735                 * get SPROM offset: SSB_SPROM_BASE1 except for 
    672736                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
    static int ssb_pci_sprom_get(struct ssb_ 
    703767                if (err) { 
    704768                        /* All CRC attempts failed. 
    705769                         * Maybe there is no SPROM on the device? 
    706                          * If we have a fallback, use that. */ 
    707                         fallback = ssb_get_fallback_sprom(); 
    708                         if (fallback) { 
    709                                 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); 
    710781                                err = 0; 
    711782                                goto out_free; 
    712783                        } 
    out_free: 
    724795static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
    725796                                  struct ssb_boardinfo *bi) 
    726797{ 
    727         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
    728                              &bi->vendor); 
    729         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
    730                              &bi->type); 
    731         pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
    732                              &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; 
    733801} 
    734802 
    735803int ssb_pci_get_invariants(struct ssb_bus *bus, 
  • 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 */ 
     
    358361#define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */ 
    359362#define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */ 
    360363#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 */ 
    361366#define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */ 
    362367#define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */ 
    363368#define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */ 
     
    427432#define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */ 
    428433#define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */ 
    429434#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 */ 
    430485#define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */ 
    431486#define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */ 
    432487#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
     
    451506#define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */ 
    452507#define SSB_SPROM8_PA1HIB1              0x00DA 
    453508#define SSB_SPROM8_PA1HIB2              0x00DC 
     509 
    454510#define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */ 
    455511#define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */ 
    456512#define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */ 
    457513#define SSB_SPROM8_OFDM5GLPO            0x014A  /* 5.2GHz OFDM power offset */ 
    458514#define SSB_SPROM8_OFDM5GHPO            0x014E  /* 5.8GHz OFDM power offset */ 
    459515 
     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 
    460556/* Values for SSB_SPROM1_BINF_CCODE */ 
    461557enum { 
    462558        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/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; 
    static void ssb_pcihost_remove(struct pc 
    110110        pci_set_drvdata(dev, NULL); 
    111111} 
    112112 
    113 int ssb_pcihost_register(struct pci_driver *driver) 
     113int __devinit ssb_pcihost_register(struct pci_driver *driver) 
    114114{ 
    115115        driver->probe = ssb_pcihost_probe; 
    116116        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; 
  • 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.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 { 
    8088        u16 boardflags2_hi;     /* Board flags (bits 48-63) */ 
    8189        /* TODO store board flags in a single u64 */ 
    8290 
     91        struct ssb_sprom_core_pwr_info core_pwr_info[4]; 
     92 
    8393        /* Antenna gain values for up to 4 antennas 
    8494         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    8595         * loss in the connectors is bigger than the gain. */ 
    struct ssb_sprom { 
    92102                } ghz5;         /* 5GHz band */ 
    93103        } antenna_gain; 
    94104 
     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 
    95114        /* TODO - add any parameters needed from rev 2, 3, 4, 5 or 8 SPROMs */ 
    96115}; 
    97116 
    struct ssb_sprom { 
    99118struct ssb_boardinfo { 
    100119        u16 vendor; 
    101120        u16 type; 
    102         u16 rev; 
     121        u8 rev; 
    103122}; 
    104123 
    105124 
    struct ssb_driver { 
    229248#define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv) 
    230249 
    231250extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner); 
    232 static inline int ssb_driver_register(struct ssb_driver *drv) 
    233 { 
    234         return __ssb_driver_register(drv, THIS_MODULE); 
    235 } 
     251#define ssb_driver_register(drv) \ 
     252        __ssb_driver_register(drv, THIS_MODULE) 
     253 
    236254extern void ssb_driver_unregister(struct ssb_driver *drv); 
    237255 
    238256 
    struct ssb_bus { 
    308326 
    309327        /* ID information about the Chip. */ 
    310328        u16 chip_id; 
    311         u16 chip_rev; 
     329        u8 chip_rev; 
    312330        u16 sprom_offset; 
    313331        u16 sprom_size;         /* number of words in sprom */ 
    314332        u8 chip_package; 
    extern bool ssb_is_sprom_available(struc 
    404422 
    405423/* Set a fallback SPROM. 
    406424 * See kdoc at the function definition for complete documentation. */ 
    407 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)); 
    408428 
    409429/* Suspend a SSB bus. 
    410430 * Call this from the parent bus suspend routine. */ 
    extern int ssb_bus_may_powerdown(struct 
    518538 * Otherwise static always-on powercontrol will be used. */ 
    519539extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
    520540 
     541extern void ssb_commit_settings(struct ssb_bus *bus); 
    521542 
    522543/* Various helper functions */ 
    523544extern u32 ssb_admatch_base(u32 adm); 
  • 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.