source: trunk/target/linux/generic/patches-2.6.32/975-ssb_update.patch @ 30777

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

[kernel/2.6.32] refresh patches

File size: 102.1 KB
  • 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); 
    static void chipco_powercontrol_init(str 
    209235        } 
    210236} 
    211237 
     238/* http://bcm-v4.sipsolutions.net/802.11/PmuFastPwrupDelay */ 
     239static u16 pmu_fast_powerup_delay(struct ssb_chipcommon *cc) 
     240{ 
     241        struct ssb_bus *bus = cc->dev->bus; 
     242 
     243        switch (bus->chip_id) { 
     244        case 0x4312: 
     245        case 0x4322: 
     246        case 0x4328: 
     247                return 7000; 
     248        case 0x4325: 
     249                /* TODO: */ 
     250        default: 
     251                return 15000; 
     252        } 
     253} 
     254 
     255/* http://bcm-v4.sipsolutions.net/802.11/ClkctlFastPwrupDelay */ 
    212256static void calc_fast_powerup_delay(struct ssb_chipcommon *cc) 
    213257{ 
    214258        struct ssb_bus *bus = cc->dev->bus; 
    static void calc_fast_powerup_delay(stru 
    218262 
    219263        if (bus->bustype != SSB_BUSTYPE_PCI) 
    220264                return; 
     265 
     266        if (cc->capabilities & SSB_CHIPCO_CAP_PMU) { 
     267                cc->fast_pwrup_delay = pmu_fast_powerup_delay(cc); 
     268                return; 
     269        } 
     270 
    221271        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
    222272                return; 
    223273 
    void ssb_chipcommon_init(struct ssb_chip 
    236286        if (cc->dev->id.revision >= 11) 
    237287                cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    238288        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 
    239295        ssb_pmu_init(cc); 
    240296        chipco_powercontrol_init(cc); 
    241297        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    u32 ssb_chipco_gpio_control(struct ssb_c 
    373429{ 
    374430        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
    375431} 
     432EXPORT_SYMBOL(ssb_chipco_gpio_control); 
    376433 
    377434u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value) 
    378435{ 
  • 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_pll_init(struct ssb_ 
    332332        case 0x5354: 
    333333                ssb_pmu0_pllinit_r0(cc, crystalfreq); 
    334334                break; 
     335        case 0x4322: 
     336                if (cc->pmu.rev == 2) { 
     337                        chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, 0x0000000A); 
     338                        chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, 0x380005C0); 
     339                } 
     340                break; 
    335341        default: 
    336342                ssb_printk(KERN_ERR PFX 
    337343                           "ERROR: PLL init unknown for device %04X\n", 
    static void ssb_pmu_resources_init(struc 
    411417        u32 min_msk = 0, max_msk = 0; 
    412418        unsigned int i; 
    413419        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
    414         unsigned int updown_tab_size; 
     420        unsigned int updown_tab_size = 0; 
    415421        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
    416         unsigned int depend_tab_size; 
     422        unsigned int depend_tab_size = 0; 
    417423 
    418424        switch (bus->chip_id) { 
    419425        case 0x4312: 
     426                 min_msk = 0xCBB; 
     427                 break; 
     428        case 0x4322: 
    420429                /* We keep the default settings: 
    421430                 * min_msk = 0xCBB 
    422431                 * max_msk = 0x7FFFF 
    static void ssb_pmu_resources_init(struc 
    495504                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
    496505} 
    497506 
     507/* http://bcm-v4.sipsolutions.net/802.11/SSB/PmuInit */ 
    498508void ssb_pmu_init(struct ssb_chipcommon *cc) 
    499509{ 
    500         struct ssb_bus *bus = cc->dev->bus; 
    501510        u32 pmucap; 
    502511 
    503512        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
    void ssb_pmu_init(struct ssb_chipcommon 
    509518        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
    510519                    cc->pmu.rev, pmucap); 
    511520 
    512         if (cc->pmu.rev >= 1) { 
    513                 if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) { 
    514                         chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
    515                                       ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
    516                 } else { 
    517                         chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
    518                                      SSB_CHIPCO_PMU_CTL_NOILPONW); 
    519                 } 
    520         } 
     521        if (cc->pmu.rev == 1) 
     522                chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     523                              ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     524        else 
     525                chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     526                             SSB_CHIPCO_PMU_CTL_NOILPONW); 
    521527        ssb_pmu_pll_init(cc); 
    522528        ssb_pmu_resources_init(cc); 
    523529} 
  • 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 */ 
     
    1212#include <linux/ssb/ssb_driver_gige.h> 
    1313#include <linux/pci.h> 
    1414#include <linux/pci_regs.h> 
     15#include <linux/slab.h> 
    1516 
    1617 
    1718/* 
    void gige_pcicfg_write32(struct ssb_gige 
    105106        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
    106107} 
    107108 
    108 static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
    109                                     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) 
    110112{ 
    111113        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
    112114        unsigned long flags; 
    static int ssb_gige_pci_read_config(stru 
    135137        return PCIBIOS_SUCCESSFUL; 
    136138} 
    137139 
    138 static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
    139                                      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) 
    140143{ 
    141144        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
    142145        unsigned long flags; 
    static int ssb_gige_pci_write_config(str 
    165168        return PCIBIOS_SUCCESSFUL; 
    166169} 
    167170 
    168 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) 
    169173{ 
    170174        struct ssb_gige *dev; 
    171175        u32 base, tmslow, tmshigh; 
  • 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 */ 
    void ssb_mipscore_init(struct ssb_mipsco 
    270270                                set_irq(dev, irq++); 
    271271                        } 
    272272                        break; 
    273                         /* fallthrough */ 
    274273                case SSB_DEV_PCI: 
    275274                case SSB_DEV_ETHERNET: 
    276275                case SSB_DEV_ETHERNET_GBIT: 
    void ssb_mipscore_init(struct ssb_mipsco 
    281280                                set_irq(dev, irq++); 
    282281                                break; 
    283282                        } 
     283                        /* fallthrough */ 
     284                case SSB_DEV_EXTIF: 
     285                        set_irq(dev, 0); 
     286                        break; 
    284287                } 
    285288        } 
    286289        ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n"); 
  • 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) 
    static struct pci_controller ssb_pcicore 
    246251        .pci_ops        = &ssb_pcicore_pciops, 
    247252        .io_resource    = &ssb_pcicore_io_resource, 
    248253        .mem_resource   = &ssb_pcicore_mem_resource, 
    249         .mem_offset     = 0x24000000, 
    250254}; 
    251255 
    252 static u32 ssb_pcicore_pcibus_iobase = 0x100; 
    253 static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA; 
    254  
    255256/* This function is called when doing a pci_enable_device(). 
    256257 * We must first check if the device is a device on the PCI-core bridge. */ 
    257258int ssb_pcicore_plat_dev_init(struct pci_dev *d) 
    258259{ 
    259         struct resource *res; 
    260         int pos, size; 
    261         u32 *base; 
    262  
    263260        if (d->bus->ops != &ssb_pcicore_pciops) { 
    264261                /* This is not a device on the PCI-core bridge. */ 
    265262                return -ENODEV; 
    int ssb_pcicore_plat_dev_init(struct pci 
    268265        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
    269266                   pci_name(d)); 
    270267 
    271         /* Fix up resource bases */ 
    272         for (pos = 0; pos < 6; pos++) { 
    273                 res = &d->resource[pos]; 
    274                 if (res->flags & IORESOURCE_IO) 
    275                         base = &ssb_pcicore_pcibus_iobase; 
    276                 else 
    277                         base = &ssb_pcicore_pcibus_membase; 
    278                 res->flags |= IORESOURCE_PCI_FIXED; 
    279                 if (res->end) { 
    280                         size = res->end - res->start + 1; 
    281                         if (*base & (size - 1)) 
    282                                 *base = (*base + size) & ~(size - 1); 
    283                         res->start = *base; 
    284                         res->end = res->start + size - 1; 
    285                         *base += size; 
    286                         pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start); 
    287                 } 
    288                 /* Fix up PCI bridge BAR0 only */ 
    289                 if (d->bus->number == 0 && PCI_SLOT(d->devfn) == 0) 
    290                         break; 
    291         } 
    292268        /* Fix up interrupt lines */ 
    293269        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
    294270        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
    int ssb_pcicore_pcibios_map_irq(const st 
    338314        return ssb_mips_irq(extpci_core->dev) + 2; 
    339315} 
    340316 
    341 static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     317static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
    342318{ 
    343319        u32 val; 
    344320 
    static void ssb_pcicore_init_hostmode(st 
    403379        register_pci_controller(&ssb_pcicore_controller); 
    404380} 
    405381 
    406 static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     382static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
    407383{ 
    408384        struct ssb_bus *bus = pc->dev->bus; 
    409385        u16 chipid_top; 
    static int pcicore_is_in_hostmode(struct 
    432408} 
    433409#endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
    434410 
     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} 
    435512 
    436513/************************************************** 
    437514 * Generic and Clientmode operation code. 
    438515 **************************************************/ 
    439516 
    440 static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     517static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
    441518{ 
     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 
    442525        /* Disable PCI interrupts. */ 
    443         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        } 
    444534} 
    445535 
    446 void ssb_pcicore_init(struct ssb_pcicore *pc) 
     536void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
    447537{ 
    448538        struct ssb_device *dev = pc->dev; 
    449         struct ssb_bus *bus; 
    450539 
    451540        if (!dev) 
    452541                return; 
    453         bus = dev->bus; 
    454542        if (!ssb_device_is_enabled(dev)) 
    455543                ssb_device_enable(dev, 0); 
    456544 
    static void ssb_pcie_write(struct ssb_pc 
    475563        pcicore_write32(pc, 0x134, data); 
    476564} 
    477565 
    478 static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
    479                                 u8 address, u16 data) 
     566static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
    480567{ 
    481568        const u16 mdio_control = 0x128; 
    482569        const u16 mdio_data = 0x12C; 
    483570        u32 v; 
    484571        int i; 
    485572 
     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) 
     590{ 
     591        const u16 mdio_control = 0x128; 
     592        const u16 mdio_data = 0x12C; 
     593        int max_retries = 10; 
     594        u16 ret = 0; 
     595        u32 v; 
     596        int i; 
     597 
    486598        v = 0x80; /* Enable Preamble Sequence */ 
    487599        v |= 0x2; /* MDIO Clock Divisor */ 
    488600        pcicore_write32(pc, mdio_control, v); 
    489601 
     602        if (pc->dev->id.revision >= 10) { 
     603                max_retries = 200; 
     604                ssb_pcie_mdio_set_phy(pc, device); 
     605        } 
     606 
    490607        v = (1 << 30); /* Start of Transaction */ 
    491         v |= (1 << 28); /* Write Transaction */ 
     608        v |= (1 << 29); /* Read Transaction */ 
    492609        v |= (1 << 17); /* Turnaround */ 
    493         v |= (u32)device << 22; 
     610        if (pc->dev->id.revision < 10) 
     611                v |= (u32)device << 22; 
    494612        v |= (u32)address << 18; 
    495         v |= data; 
    496613        pcicore_write32(pc, mdio_data, v); 
    497614        /* Wait for the device to complete the transaction */ 
    498615        udelay(10); 
    499         for (i = 0; i < 10; i++) { 
     616        for (i = 0; i < max_retries; i++) { 
    500617                v = pcicore_read32(pc, mdio_control); 
    501                 if (v & 0x100 /* Trans complete */) 
     618                if (v & 0x100 /* Trans complete */) { 
     619                        udelay(10); 
     620                        ret = pcicore_read32(pc, mdio_data); 
    502621                        break; 
     622                } 
    503623                msleep(1); 
    504624        } 
    505625        pcicore_write32(pc, mdio_control, 0); 
     626        return ret; 
    506627} 
    507628 
    508 static void ssb_broadcast_value(struct ssb_device *dev, 
    509                                 u32 address, u32 data) 
     629static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     630                                u8 address, u16 data) 
    510631{ 
    511         /* This is used for both, PCI and ChipCommon core, so be careful. */ 
    512         BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
    513         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; 
    514637 
    515         ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
    516         ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
    517         ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
    518         ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
    519 } 
     638        v = 0x80; /* Enable Preamble Sequence */ 
     639        v |= 0x2; /* MDIO Clock Divisor */ 
     640        pcicore_write32(pc, mdio_control, v); 
    520641 
    521 static void ssb_commit_settings(struct ssb_bus *bus) 
    522 { 
    523         struct ssb_device *dev; 
     642        if (pc->dev->id.revision >= 10) { 
     643                max_retries = 200; 
     644                ssb_pcie_mdio_set_phy(pc, device); 
     645        } 
    524646 
    525         dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
    526         if (WARN_ON(!dev)) 
    527                 return; 
    528         /* This forces an update of the cached registers. */ 
    529         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); 
    530664} 
    531665 
    532666int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
    int ssb_pcicore_dev_irqvecs_enable(struc 
    551685        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
    552686 
    553687        /* Enable interrupts for this device. */ 
    554         if (bus->host_pci && 
    555             ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) { 
     688        if ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE)) { 
    556689                u32 coremask; 
    557690 
    558691                /* Calculate the "coremask" for the device. */ 
    559692                coremask = (1 << dev->core_index); 
    560693 
     694                SSB_WARN_ON(bus->bustype != SSB_BUSTYPE_PCI); 
    561695                err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp); 
    562696                if (err) 
    563697                        goto out; 
    int ssb_pcicore_dev_irqvecs_enable(struc 
    579713        if (pc->setup_done) 
    580714                goto out; 
    581715        if (pdev->id.coreid == SSB_DEV_PCI) { 
    582                 tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
    583                 tmp |= SSB_PCICORE_SBTOPCI_PREF; 
    584                 tmp |= SSB_PCICORE_SBTOPCI_BURST; 
    585                 pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
    586  
    587                 if (pdev->id.revision < 5) { 
    588                         tmp = ssb_read32(pdev, SSB_IMCFGLO); 
    589                         tmp &= ~SSB_IMCFGLO_SERTO; 
    590                         tmp |= 2; 
    591                         tmp &= ~SSB_IMCFGLO_REQTO; 
    592                         tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
    593                         ssb_write32(pdev, SSB_IMCFGLO, tmp); 
    594                         ssb_commit_settings(bus); 
    595                 } else if (pdev->id.revision >= 11) { 
    596                         tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
    597                         tmp |= SSB_PCICORE_SBTOPCI_MRM; 
    598                         pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
    599                 } 
     716                ssb_pcicore_pci_setup_workarounds(pc); 
    600717        } else { 
    601718                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
    602                 //TODO: Better make defines for all these magic PCIE values. 
    603                 if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
    604                         /* TLP Workaround register. */ 
    605                         tmp = ssb_pcie_read(pc, 0x4); 
    606                         tmp |= 0x8; 
    607                         ssb_pcie_write(pc, 0x4, tmp); 
    608                 } 
    609                 if (pdev->id.revision == 0) { 
    610                         const u8 serdes_rx_device = 0x1F; 
    611  
    612                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    613                                             2 /* Timer */, 0x8128); 
    614                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    615                                             6 /* CDR */, 0x0100); 
    616                         ssb_pcie_mdio_write(pc, serdes_rx_device, 
    617                                             7 /* CDR BW */, 0x1466); 
    618                 } else if (pdev->id.revision == 1) { 
    619                         /* DLLP Link Control register. */ 
    620                         tmp = ssb_pcie_read(pc, 0x100); 
    621                         tmp |= 0x40; 
    622                         ssb_pcie_write(pc, 0x100, tmp); 
    623                 } 
     719                ssb_pcicore_pcie_setup_workarounds(pc); 
    624720        } 
    625721        pc->setup_done = 1; 
    626722out: 
  • 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> 
    1819#include <linux/dma-mapping.h> 
    1920#include <linux/pci.h> 
    2021#include <linux/mmc/sdio_func.h> 
     22#include <linux/slab.h> 
    2123 
    2224#include <pcmcia/cs_types.h> 
    2325#include <pcmcia/cs.h> 
    static void ssb_device_put(struct ssb_de 
    140142                put_device(dev->dev); 
    141143} 
    142144 
     145static inline struct ssb_driver *ssb_driver_get(struct ssb_driver *drv) 
     146{ 
     147        if (drv) 
     148                get_driver(&drv->drv); 
     149        return drv; 
     150} 
     151 
     152static inline void ssb_driver_put(struct ssb_driver *drv) 
     153{ 
     154        if (drv) 
     155                put_driver(&drv->drv); 
     156} 
     157 
    143158static int ssb_device_resume(struct device *dev) 
    144159{ 
    145160        struct ssb_device *ssb_dev = dev_to_ssb_dev(dev); 
    int ssb_bus_suspend(struct ssb_bus *bus) 
    210225EXPORT_SYMBOL(ssb_bus_suspend); 
    211226 
    212227#ifdef CONFIG_SSB_SPROM 
    213 int ssb_devices_freeze(struct ssb_bus *bus) 
     228/** ssb_devices_freeze - Freeze all devices on the bus. 
     229 * 
     230 * After freezing no device driver will be handling a device 
     231 * on this bus anymore. ssb_devices_thaw() must be called after 
     232 * a successful freeze to reactivate the devices. 
     233 * 
     234 * @bus: The bus. 
     235 * @ctx: Context structure. Pass this to ssb_devices_thaw(). 
     236 */ 
     237int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx) 
    214238{ 
    215         struct ssb_device *dev; 
    216         struct ssb_driver *drv; 
    217         int err = 0; 
    218         int i; 
    219         pm_message_t state = PMSG_FREEZE; 
     239        struct ssb_device *sdev; 
     240        struct ssb_driver *sdrv; 
     241        unsigned int i; 
     242 
     243        memset(ctx, 0, sizeof(*ctx)); 
     244        ctx->bus = bus; 
     245        SSB_WARN_ON(bus->nr_devices > ARRAY_SIZE(ctx->device_frozen)); 
    220246 
    221         /* First check that we are capable to freeze all devices. */ 
    222247        for (i = 0; i < bus->nr_devices; i++) { 
    223                 dev = &(bus->devices[i]); 
    224                 if (!dev->dev || 
    225                     !dev->dev->driver || 
    226                     !device_is_registered(dev->dev)) 
    227                         continue; 
    228                 drv = drv_to_ssb_drv(dev->dev->driver); 
    229                 if (!drv) 
     248                sdev = ssb_device_get(&bus->devices[i]); 
     249 
     250                if (!sdev->dev || !sdev->dev->driver || 
     251                    !device_is_registered(sdev->dev)) { 
     252                        ssb_device_put(sdev); 
    230253                        continue; 
    231                 if (!drv->suspend) { 
    232                         /* Nope, can't suspend this one. */ 
    233                         return -EOPNOTSUPP; 
    234254                } 
    235         } 
    236         /* Now suspend all devices */ 
    237         for (i = 0; i < bus->nr_devices; i++) { 
    238                 dev = &(bus->devices[i]); 
    239                 if (!dev->dev || 
    240                     !dev->dev->driver || 
    241                     !device_is_registered(dev->dev)) 
     255                sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
     256                if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
     257                        ssb_device_put(sdev); 
    242258                        continue; 
    243                 drv = drv_to_ssb_drv(dev->dev->driver); 
    244                 if (!drv) 
    245                         continue; 
    246                 err = drv->suspend(dev, state); 
    247                 if (err) { 
    248                         ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n", 
    249                                    dev_name(dev->dev)); 
    250                         goto err_unwind; 
    251259                } 
     260                sdrv->remove(sdev); 
     261                ctx->device_frozen[i] = 1; 
    252262        } 
    253263 
    254264        return 0; 
    255 err_unwind: 
    256         for (i--; i >= 0; i--) { 
    257                 dev = &(bus->devices[i]); 
    258                 if (!dev->dev || 
    259                     !dev->dev->driver || 
    260                     !device_is_registered(dev->dev)) 
    261                         continue; 
    262                 drv = drv_to_ssb_drv(dev->dev->driver); 
    263                 if (!drv) 
    264                         continue; 
    265                 if (drv->resume) 
    266                         drv->resume(dev); 
    267         } 
    268         return err; 
    269265} 
    270266 
    271 int ssb_devices_thaw(struct ssb_bus *bus) 
     267/** ssb_devices_thaw - Unfreeze all devices on the bus. 
     268 * 
     269 * This will re-attach the device drivers and re-init the devices. 
     270 * 
     271 * @ctx: The context structure from ssb_devices_freeze() 
     272 */ 
     273int ssb_devices_thaw(struct ssb_freeze_context *ctx) 
    272274{ 
    273         struct ssb_device *dev; 
    274         struct ssb_driver *drv; 
    275         int err; 
    276         int i; 
     275        struct ssb_bus *bus = ctx->bus; 
     276        struct ssb_device *sdev; 
     277        struct ssb_driver *sdrv; 
     278        unsigned int i; 
     279        int err, result = 0; 
    277280 
    278281        for (i = 0; i < bus->nr_devices; i++) { 
    279                 dev = &(bus->devices[i]); 
    280                 if (!dev->dev || 
    281                     !dev->dev->driver || 
    282                     !device_is_registered(dev->dev)) 
     282                if (!ctx->device_frozen[i]) 
    283283                        continue; 
    284                 drv = drv_to_ssb_drv(dev->dev->driver); 
    285                 if (!drv) 
     284                sdev = &bus->devices[i]; 
     285 
     286                if (SSB_WARN_ON(!sdev->dev || !sdev->dev->driver)) 
    286287                        continue; 
    287                 if (SSB_WARN_ON(!drv->resume)) 
     288                sdrv = drv_to_ssb_drv(sdev->dev->driver); 
     289                if (SSB_WARN_ON(!sdrv || !sdrv->probe)) 
    288290                        continue; 
    289                 err = drv->resume(dev); 
     291 
     292                err = sdrv->probe(sdev, &sdev->id); 
    290293                if (err) { 
    291294                        ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n", 
    292                                    dev_name(dev->dev)); 
     295                                   dev_name(sdev->dev)); 
     296                        result = err; 
    293297                } 
     298                ssb_driver_put(sdrv); 
     299                ssb_device_put(sdev); 
    294300        } 
    295301 
    296         return 0; 
     302        return result; 
    297303} 
    298304#endif /* CONFIG_SSB_SPROM */ 
    299305 
    static int ssb_device_uevent(struct devi 
    380386                             ssb_dev->id.revision); 
    381387} 
    382388 
     389#define ssb_config_attr(attrib, field, format_string) \ 
     390static ssize_t \ 
     391attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 
     392{ \ 
     393        return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \ 
     394} 
     395 
     396ssb_config_attr(core_num, core_index, "%u\n") 
     397ssb_config_attr(coreid, id.coreid, "0x%04x\n") 
     398ssb_config_attr(vendor, id.vendor, "0x%04x\n") 
     399ssb_config_attr(revision, id.revision, "%u\n") 
     400ssb_config_attr(irq, irq, "%u\n") 
     401static ssize_t 
     402name_show(struct device *dev, struct device_attribute *attr, char *buf) 
     403{ 
     404        return sprintf(buf, "%s\n", 
     405                       ssb_core_name(dev_to_ssb_dev(dev)->id.coreid)); 
     406} 
     407 
     408static struct device_attribute ssb_device_attrs[] = { 
     409        __ATTR_RO(name), 
     410        __ATTR_RO(core_num), 
     411        __ATTR_RO(coreid), 
     412        __ATTR_RO(vendor), 
     413        __ATTR_RO(revision), 
     414        __ATTR_RO(irq), 
     415        __ATTR_NULL, 
     416}; 
     417 
    383418static struct bus_type ssb_bustype = { 
    384419        .name           = "ssb", 
    385420        .match          = ssb_bus_match, 
    static struct bus_type ssb_bustype = { 
    389424        .suspend        = ssb_device_suspend, 
    390425        .resume         = ssb_device_resume, 
    391426        .uevent         = ssb_device_uevent, 
     427        .dev_attrs      = ssb_device_attrs, 
    392428}; 
    393429 
    394430static void ssb_buses_lock(void) 
    static int ssb_devices_register(struct s 
    481517#ifdef CONFIG_SSB_PCIHOST 
    482518                        sdev->irq = bus->host_pci->irq; 
    483519                        dev->parent = &bus->host_pci->dev; 
     520                        sdev->dma_dev = dev->parent; 
    484521#endif 
    485522                        break; 
    486523                case SSB_BUSTYPE_PCMCIA: 
    static int ssb_devices_register(struct s 
    490527#endif 
    491528                        break; 
    492529                case SSB_BUSTYPE_SDIO: 
    493 #ifdef CONFIG_SSB_SDIO 
    494                         sdev->irq = bus->host_sdio->dev.irq; 
     530#ifdef CONFIG_SSB_SDIOHOST 
    495531                        dev->parent = &bus->host_sdio->dev; 
    496532#endif 
    497533                        break; 
    498534                case SSB_BUSTYPE_SSB: 
    499535                        dev->dma_mask = &dev->coherent_dma_mask; 
     536                        sdev->dma_dev = dev; 
    500537                        break; 
    501538                } 
    502539 
    error: 
    523560} 
    524561 
    525562/* Needs ssb_buses_lock() */ 
    526 static int ssb_attach_queued_buses(void) 
     563static int __devinit ssb_attach_queued_buses(void) 
    527564{ 
    528565        struct ssb_bus *bus, *n; 
    529566        int err = 0; 
    out: 
    734771        return err; 
    735772} 
    736773 
    737 static int ssb_bus_register(struct ssb_bus *bus, 
    738                             ssb_invariants_func_t get_invariants, 
    739                             unsigned long baseaddr) 
     774static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     775                                      ssb_invariants_func_t get_invariants, 
     776                                      unsigned long baseaddr) 
    740777{ 
    741778        int err; 
    742779 
    err_disable_xtal: 
    817854} 
    818855 
    819856#ifdef CONFIG_SSB_PCIHOST 
    820 int ssb_bus_pcibus_register(struct ssb_bus *bus, 
    821                             struct pci_dev *host_pci) 
     857int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     858                                      struct pci_dev *host_pci) 
    822859{ 
    823860        int err; 
    824861 
    int ssb_bus_pcibus_register(struct ssb_b 
    830867        if (!err) { 
    831868                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
    832869                           "PCI device %s\n", dev_name(&host_pci->dev)); 
     870        } else { 
     871                ssb_printk(KERN_ERR PFX "Failed to register PCI version" 
     872                           " of SSB with error %d\n", err); 
    833873        } 
    834874 
    835875        return err; 
    EXPORT_SYMBOL(ssb_bus_pcibus_register); 
    838878#endif /* CONFIG_SSB_PCIHOST */ 
    839879 
    840880#ifdef CONFIG_SSB_PCMCIAHOST 
    841 int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
    842                               struct pcmcia_device *pcmcia_dev, 
    843                               unsigned long baseaddr) 
     881int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     882                                        struct pcmcia_device *pcmcia_dev, 
     883                                        unsigned long baseaddr) 
    844884{ 
    845885        int err; 
    846886 
    EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
    860900#endif /* CONFIG_SSB_PCMCIAHOST */ 
    861901 
    862902#ifdef CONFIG_SSB_SDIOHOST 
    863 int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
    864                              unsigned int quirks) 
     903int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     904                                       struct sdio_func *func, 
     905                                       unsigned int quirks) 
    865906{ 
    866907        int err; 
    867908 
    int ssb_bus_sdiobus_register(struct ssb_ 
    881922EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
    882923#endif /* CONFIG_SSB_PCMCIAHOST */ 
    883924 
    884 int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    885                             unsigned long baseaddr, 
    886                             ssb_invariants_func_t get_invariants) 
     925int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     926                                      unsigned long baseaddr, 
     927                                      ssb_invariants_func_t get_invariants) 
    887928{ 
    888929        int err; 
    889930 
    u32 ssb_calc_clock_rate(u32 plltype, u32 
    9641005        switch (plltype) { 
    9651006        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
    9661007                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
    967                         return SSB_CHIPCO_CLK_T6_M0; 
    968                 return SSB_CHIPCO_CLK_T6_M1; 
     1008                        return SSB_CHIPCO_CLK_T6_M1; 
     1009                return SSB_CHIPCO_CLK_T6_M0; 
    9691010        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
    9701011        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
    9711012        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
    static u32 ssb_tmslow_reject_bitmask(str 
    10801121{ 
    10811122        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
    10821123 
    1083         /* The REJECT bit changed position in TMSLOW between 
    1084          * Backplane revisions. */ 
     1124        /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
    10851125        switch (rev) { 
    10861126        case SSB_IDLOW_SSBREV_22: 
    1087                 return SSB_TMSLOW_REJECT_22; 
     1127        case SSB_IDLOW_SSBREV_24: 
     1128        case SSB_IDLOW_SSBREV_26: 
     1129                return SSB_TMSLOW_REJECT; 
    10881130        case SSB_IDLOW_SSBREV_23: 
    10891131                return SSB_TMSLOW_REJECT_23; 
    1090         case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
    1091         case SSB_IDLOW_SSBREV_25:     /* same here */ 
    1092         case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1132        case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
    10931133        case SSB_IDLOW_SSBREV_27:     /* same here */ 
    1094                 return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1134                return SSB_TMSLOW_REJECT;       /* this is a guess */ 
    10951135        default: 
    10961136                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
    10971137                WARN_ON(1); 
    10981138        } 
    1099         return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1139        return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
    11001140} 
    11011141 
    11021142int ssb_device_is_enabled(struct ssb_device *dev) 
    void ssb_device_enable(struct ssb_device 
    11551195} 
    11561196EXPORT_SYMBOL(ssb_device_enable); 
    11571197 
    1158 /* Wait for a bit in a register to get set or unset. 
     1198/* Wait for bitmask in a register to get set or cleared. 
    11591199 * timeout is in units of ten-microseconds */ 
    1160 static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
    1161                         int timeout, int set) 
     1200static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     1201                         int timeout, int set) 
    11621202{ 
    11631203        int i; 
    11641204        u32 val; 
    static int ssb_wait_bit(struct ssb_devic 
    11661206        for (i = 0; i < timeout; i++) { 
    11671207                val = ssb_read32(dev, reg); 
    11681208                if (set) { 
    1169                         if (val & bitmask) 
     1209                        if ((val & bitmask) == bitmask) 
    11701210                                return 0; 
    11711211                } else { 
    11721212                        if (!(val & bitmask)) 
    static int ssb_wait_bit(struct ssb_devic 
    11831223 
    11841224void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
    11851225{ 
    1186         u32 reject; 
     1226        u32 reject, val; 
    11871227 
    11881228        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
    11891229                return; 
    11901230 
    11911231        reject = ssb_tmslow_reject_bitmask(dev); 
    1192         ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
    1193         ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
    1194         ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
    1195         ssb_write32(dev, SSB_TMSLOW, 
    1196                     SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
    1197                     reject | SSB_TMSLOW_RESET | 
    1198                     core_specific_flags); 
    1199         ssb_flush_tmslow(dev); 
     1232 
     1233        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) { 
     1234                ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     1235                ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1); 
     1236                ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     1237 
     1238                if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     1239                        val = ssb_read32(dev, SSB_IMSTATE); 
     1240                        val |= SSB_IMSTATE_REJECT; 
     1241                        ssb_write32(dev, SSB_IMSTATE, val); 
     1242                        ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000, 
     1243                                      0); 
     1244                } 
     1245 
     1246                ssb_write32(dev, SSB_TMSLOW, 
     1247                        SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     1248                        reject | SSB_TMSLOW_RESET | 
     1249                        core_specific_flags); 
     1250                ssb_flush_tmslow(dev); 
     1251 
     1252                if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     1253                        val = ssb_read32(dev, SSB_IMSTATE); 
     1254                        val &= ~SSB_IMSTATE_REJECT; 
     1255                        ssb_write32(dev, SSB_IMSTATE, val); 
     1256                } 
     1257        } 
    12001258 
    12011259        ssb_write32(dev, SSB_TMSLOW, 
    12021260                    reject | SSB_TMSLOW_RESET | 
    void ssb_device_disable(struct ssb_devic 
    12051263} 
    12061264EXPORT_SYMBOL(ssb_device_disable); 
    12071265 
     1266/* Some chipsets need routing known for PCIe and 64-bit DMA */ 
     1267static bool ssb_dma_translation_special_bit(struct ssb_device *dev) 
     1268{ 
     1269        u16 chip_id = dev->bus->chip_id; 
     1270 
     1271        if (dev->id.coreid == SSB_DEV_80211) { 
     1272                return (chip_id == 0x4322 || chip_id == 43221 || 
     1273                        chip_id == 43231 || chip_id == 43222); 
     1274        } 
     1275 
     1276        return 0; 
     1277} 
     1278 
    12081279u32 ssb_dma_translation(struct ssb_device *dev) 
    12091280{ 
    12101281        switch (dev->bus->bustype) { 
    12111282        case SSB_BUSTYPE_SSB: 
    12121283                return 0; 
    12131284        case SSB_BUSTYPE_PCI: 
    1214                 return SSB_PCI_DMA; 
     1285                if (dev->bus->host_pci->is_pcie && 
     1286                    ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) { 
     1287                        return SSB_PCIE_DMA_H32; 
     1288                } else { 
     1289                        if (ssb_dma_translation_special_bit(dev)) 
     1290                                return SSB_PCIE_DMA_H32; 
     1291                        else 
     1292                                return SSB_PCI_DMA; 
     1293                } 
    12151294        default: 
    12161295                __ssb_dma_not_implemented(dev); 
    12171296        } 
    EXPORT_SYMBOL(ssb_bus_may_powerdown); 
    13281407 
    13291408int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
    13301409{ 
    1331         struct ssb_chipcommon *cc; 
    13321410        int err; 
    13331411        enum ssb_clkmode mode; 
    13341412 
    13351413        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
    13361414        if (err) 
    13371415                goto error; 
    1338         cc = &bus->chipco; 
    1339         mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
    1340         ssb_chipco_set_clockmode(cc, mode); 
    13411416 
    13421417#ifdef CONFIG_SSB_DEBUG 
    13431418        bus->powered_up = 1; 
    13441419#endif 
     1420 
     1421        mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1422        ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1423 
    13451424        return 0; 
    13461425error: 
    13471426        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
    error: 
    13491428} 
    13501429EXPORT_SYMBOL(ssb_bus_powerup); 
    13511430 
     1431static void ssb_broadcast_value(struct ssb_device *dev, 
     1432                                u32 address, u32 data) 
     1433{ 
     1434#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1435        /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1436        BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1437        BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1438#endif 
     1439 
     1440        ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     1441        ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     1442        ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     1443        ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     1444} 
     1445 
     1446void ssb_commit_settings(struct ssb_bus *bus) 
     1447{ 
     1448        struct ssb_device *dev; 
     1449 
     1450#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1451        dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1452#else 
     1453        dev = bus->chipco.dev; 
     1454#endif 
     1455        if (WARN_ON(!dev)) 
     1456                return; 
     1457        /* This forces an update of the cached registers. */ 
     1458        ssb_broadcast_value(dev, 0xFD8, 0); 
     1459} 
     1460EXPORT_SYMBOL(ssb_commit_settings); 
     1461 
    13521462u32 ssb_admatch_base(u32 adm) 
    13531463{ 
    13541464        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> 
     
    1717 
    1818#include <linux/ssb/ssb.h> 
    1919#include <linux/ssb/ssb_regs.h> 
     20#include <linux/slab.h> 
    2021#include <linux/pci.h> 
    2122#include <linux/delay.h> 
    2223 
    err_pci: 
    167168} 
    168169 
    169170/* Get the word-offset for a SSB_SPROM_XXX define. */ 
    170 #define SPOFF(offset)   (((offset) - SSB_SPROM_BASE1) / sizeof(u16)) 
     171#define SPOFF(offset)   ((offset) / sizeof(u16)) 
    171172/* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */ 
    172173#define SPEX16(_outvar, _offset, _mask, _shift) \ 
    173174        out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift)) 
    static void sprom_extract_r123(struct ss 
    405406        out->antenna_gain.ghz5.a3 = gain; 
    406407} 
    407408 
     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 
    408449static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in) 
    409450{ 
    410451        int i; 
    static void sprom_extract_r45(struct ssb 
    427468                SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0); 
    428469                SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0); 
    429470                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); 
    430473        } else { 
    431474                SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0); 
    432475                SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0); 
    433476                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); 
    434479        } 
    435480        SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A, 
    436481             SSB_SPROM4_ANTAVAIL_A_SHIFT); 
    static void sprom_extract_r45(struct ssb 
    470515        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
    471516               sizeof(out->antenna_gain.ghz5)); 
    472517 
     518        sprom_extract_r458(out, in); 
     519 
    473520        /* TODO - get remaining rev 4 stuff needed */ 
    474521} 
    475522 
    476523static void sprom_extract_r8(struct ssb_sprom *out, const u16 *in) 
    477524{ 
    478525        int i; 
    479         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)); 
    480533 
    481534        /* extract the MAC address */ 
    482535        for (i = 0; i < 3; i++) { 
    static void sprom_extract_r8(struct ssb_ 
    560613        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
    561614               sizeof(out->antenna_gain.ghz5)); 
    562615 
     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 
    563673        /* TODO - get remaining rev 8 stuff needed */ 
    564674} 
    565675 
    static int sprom_extract(struct ssb_bus 
    572682        ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision); 
    573683        memset(out->et0mac, 0xFF, 6);           /* preset et0 and et1 mac */ 
    574684        memset(out->et1mac, 0xFF, 6); 
     685 
    575686        if ((bus->chip_id & 0xFF00) == 0x4400) { 
    576687                /* Workaround: The BCM44XX chip has a stupid revision 
    577688                 * number stored in the SPROM. 
    578689                 * Always extract r1. */ 
    579690                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: 
    580698                sprom_extract_r123(out, in); 
    581         } else if (bus->chip_id == 0x4321) { 
    582                 /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */ 
    583                 out->revision = 4; 
     699                break; 
     700        case 4: 
     701        case 5: 
    584702                sprom_extract_r45(out, in); 
    585         } else { 
    586                 switch (out->revision) { 
    587                 case 1: 
    588                 case 2: 
    589                 case 3: 
    590                         sprom_extract_r123(out, in); 
    591                         break; 
    592                 case 4: 
    593                 case 5: 
    594                         sprom_extract_r45(out, in); 
    595                         break; 
    596                 case 8: 
    597                         sprom_extract_r8(out, in); 
    598                         break; 
    599                 default: 
    600                         ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    601                                    "  revision %d detected. Will extract" 
    602                                    " v1\n", out->revision); 
    603                         out->revision = 1; 
    604                         sprom_extract_r123(out, in); 
    605                 } 
     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); 
    606713        } 
    607714 
    608715        if (out->boardflags_lo == 0xFFFF) 
    static int sprom_extract(struct ssb_bus 
    616723static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    617724                             struct ssb_sprom *sprom) 
    618725{ 
    619         const struct ssb_sprom *fallback; 
    620         int err = -ENOMEM; 
     726        int err; 
    621727        u16 *buf; 
    622728 
    623729        if (!ssb_is_sprom_available(bus)) { 
    624730                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
    625731                return -ENODEV; 
    626732        } 
    627         if (bus->chipco.dev) {  /* can be unavailible! */ 
     733        if (bus->chipco.dev) {  /* can be unavailable! */ 
    628734                /* 
    629735                 * get SPROM offset: SSB_SPROM_BASE1 except for 
    630736                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
    static int ssb_pci_sprom_get(struct ssb_ 
    644750 
    645751        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
    646752        if (!buf) 
    647                 goto out; 
     753                return -ENOMEM; 
    648754        bus->sprom_size = SSB_SPROMSIZE_WORDS_R123; 
    649755        sprom_do_read(bus, buf); 
    650756        err = sprom_check_crc(buf, bus->sprom_size); 
    static int ssb_pci_sprom_get(struct ssb_ 
    654760                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    655761                              GFP_KERNEL); 
    656762                if (!buf) 
    657                         goto out; 
     763                        return -ENOMEM; 
    658764                bus->sprom_size = SSB_SPROMSIZE_WORDS_R4; 
    659765                sprom_do_read(bus, buf); 
    660766                err = sprom_check_crc(buf, bus->sprom_size); 
    661767                if (err) { 
    662768                        /* All CRC attempts failed. 
    663769                         * Maybe there is no SPROM on the device? 
    664                          * If we have a fallback, use that. */ 
    665                         fallback = ssb_get_fallback_sprom(); 
    666                         if (fallback) { 
    667                                 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); 
    668781                                err = 0; 
    669782                                goto out_free; 
    670783                        } 
    static int ssb_pci_sprom_get(struct ssb_ 
    676789 
    677790out_free: 
    678791        kfree(buf); 
    679 out: 
    680792        return err; 
    681793} 
    682794 
    683795static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
    684796                                  struct ssb_boardinfo *bi) 
    685797{ 
    686         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
    687                              &bi->vendor); 
    688         pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
    689                              &bi->type); 
    690         pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
    691                              &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; 
    692801} 
    693802 
    694803int 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 */ 
    1313 
    1414#include <linux/pci.h> 
     15#include <linux/slab.h> 
    1516#include <linux/ssb/ssb.h> 
    1617 
    1718 
    static int ssb_pcihost_resume(struct pci 
    5253# define ssb_pcihost_resume     NULL 
    5354#endif /* CONFIG_PM */ 
    5455 
    55 static int ssb_pcihost_probe(struct pci_dev *dev, 
    56                              const struct pci_device_id *id) 
     56static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     57                                       const struct pci_device_id *id) 
    5758{ 
    5859        struct ssb_bus *ssb; 
    5960        int err = -ENOMEM; 
    6061        const char *name; 
     62        u32 val; 
    6163 
    6264        ssb = kzalloc(sizeof(*ssb), GFP_KERNEL); 
    6365        if (!ssb) 
    static int ssb_pcihost_probe(struct pci_ 
    7375                goto err_pci_disable; 
    7476        pci_set_master(dev); 
    7577 
     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 
    7684        err = ssb_bus_pcibus_register(ssb, dev); 
    7785        if (err) 
    7886                goto err_pci_release_regions; 
    static void ssb_pcihost_remove(struct pc 
    102110        pci_set_drvdata(dev, NULL); 
    103111} 
    104112 
    105 int ssb_pcihost_register(struct pci_driver *driver) 
     113int __devinit ssb_pcihost_register(struct pci_driver *driver) 
    106114{ 
    107115        driver->probe = ssb_pcihost_probe; 
    108116        driver->remove = ssb_pcihost_remove; 
  • 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 */ 
    static int ssb_pcmcia_sprom_check_crc(co 
    617617        }                                               \ 
    618618  } while (0) 
    619619 
    620 int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 
    621                               struct ssb_init_invariants *iv) 
     620static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev, 
     621                        tuple_t *tuple, 
     622                        void *priv) 
     623{ 
     624        struct ssb_sprom *sprom = priv; 
     625 
     626        if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID) 
     627                return -EINVAL; 
     628        if (tuple->TupleDataLen != ETH_ALEN + 2) 
     629                return -EINVAL; 
     630        if (tuple->TupleData[1] != ETH_ALEN) 
     631                return -EINVAL; 
     632        memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN); 
     633        return 0; 
     634}; 
     635 
     636static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev, 
     637                                        tuple_t *tuple, 
     638                                        void *priv) 
    622639{ 
    623         tuple_t tuple; 
    624         int res; 
    625         unsigned char buf[32]; 
     640        struct ssb_init_invariants *iv = priv; 
    626641        struct ssb_sprom *sprom = &iv->sprom; 
    627642        struct ssb_boardinfo *bi = &iv->boardinfo; 
    628643        const char *error_description; 
    629644 
     645        GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1"); 
     646        switch (tuple->TupleData[0]) { 
     647        case SSB_PCMCIA_CIS_ID: 
     648                GOTO_ERROR_ON((tuple->TupleDataLen != 5) && 
     649                              (tuple->TupleDataLen != 7), 
     650                              "id tpl size"); 
     651                bi->vendor = tuple->TupleData[1] | 
     652                        ((u16)tuple->TupleData[2] << 8); 
     653                break; 
     654        case SSB_PCMCIA_CIS_BOARDREV: 
     655                GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     656                        "boardrev tpl size"); 
     657                sprom->board_rev = tuple->TupleData[1]; 
     658                break; 
     659        case SSB_PCMCIA_CIS_PA: 
     660                GOTO_ERROR_ON((tuple->TupleDataLen != 9) && 
     661                        (tuple->TupleDataLen != 10), 
     662                        "pa tpl size"); 
     663                sprom->pa0b0 = tuple->TupleData[1] | 
     664                        ((u16)tuple->TupleData[2] << 8); 
     665                sprom->pa0b1 = tuple->TupleData[3] | 
     666                        ((u16)tuple->TupleData[4] << 8); 
     667                sprom->pa0b2 = tuple->TupleData[5] | 
     668                        ((u16)tuple->TupleData[6] << 8); 
     669                sprom->itssi_a = tuple->TupleData[7]; 
     670                sprom->itssi_bg = tuple->TupleData[7]; 
     671                sprom->maxpwr_a = tuple->TupleData[8]; 
     672                sprom->maxpwr_bg = tuple->TupleData[8]; 
     673                break; 
     674        case SSB_PCMCIA_CIS_OEMNAME: 
     675                /* We ignore this. */ 
     676                break; 
     677        case SSB_PCMCIA_CIS_CCODE: 
     678                GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     679                        "ccode tpl size"); 
     680                sprom->country_code = tuple->TupleData[1]; 
     681                break; 
     682        case SSB_PCMCIA_CIS_ANTENNA: 
     683                GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     684                        "ant tpl size"); 
     685                sprom->ant_available_a = tuple->TupleData[1]; 
     686                sprom->ant_available_bg = tuple->TupleData[1]; 
     687                break; 
     688        case SSB_PCMCIA_CIS_ANTGAIN: 
     689                GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     690                        "antg tpl size"); 
     691                sprom->antenna_gain.ghz24.a0 = tuple->TupleData[1]; 
     692                sprom->antenna_gain.ghz24.a1 = tuple->TupleData[1]; 
     693                sprom->antenna_gain.ghz24.a2 = tuple->TupleData[1]; 
     694                sprom->antenna_gain.ghz24.a3 = tuple->TupleData[1]; 
     695                sprom->antenna_gain.ghz5.a0 = tuple->TupleData[1]; 
     696                sprom->antenna_gain.ghz5.a1 = tuple->TupleData[1]; 
     697                sprom->antenna_gain.ghz5.a2 = tuple->TupleData[1]; 
     698                sprom->antenna_gain.ghz5.a3 = tuple->TupleData[1]; 
     699                break; 
     700        case SSB_PCMCIA_CIS_BFLAGS: 
     701                GOTO_ERROR_ON((tuple->TupleDataLen != 3) && 
     702                        (tuple->TupleDataLen != 5), 
     703                        "bfl tpl size"); 
     704                sprom->boardflags_lo = tuple->TupleData[1] | 
     705                        ((u16)tuple->TupleData[2] << 8); 
     706                break; 
     707        case SSB_PCMCIA_CIS_LEDS: 
     708                GOTO_ERROR_ON(tuple->TupleDataLen != 5, 
     709                        "leds tpl size"); 
     710                sprom->gpio0 = tuple->TupleData[1]; 
     711                sprom->gpio1 = tuple->TupleData[2]; 
     712                sprom->gpio2 = tuple->TupleData[3]; 
     713                sprom->gpio3 = tuple->TupleData[4]; 
     714                break; 
     715        } 
     716        return -ENOSPC; /* continue with next entry */ 
     717 
     718error: 
     719        ssb_printk(KERN_ERR PFX 
     720                   "PCMCIA: Failed to fetch device invariants: %s\n", 
     721                   error_description); 
     722        return -ENODEV; 
     723} 
     724 
     725 
     726int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 
     727                              struct ssb_init_invariants *iv) 
     728{ 
     729        struct ssb_sprom *sprom = &iv->sprom; 
     730        int res; 
     731 
    630732        memset(sprom, 0xFF, sizeof(*sprom)); 
    631733        sprom->revision = 1; 
    632734        sprom->boardflags_lo = 0; 
    633735        sprom->boardflags_hi = 0; 
    634736 
    635737        /* First fetch the MAC address. */ 
    636         memset(&tuple, 0, sizeof(tuple)); 
    637         tuple.DesiredTuple = CISTPL_FUNCE; 
    638         tuple.TupleData = buf; 
    639         tuple.TupleDataMax = sizeof(buf); 
    640         res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 
    641         GOTO_ERROR_ON(res != 0, "MAC first tpl"); 
    642         res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
    643         GOTO_ERROR_ON(res != 0, "MAC first tpl data"); 
    644         while (1) { 
    645                 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1"); 
    646                 if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID) 
    647                         break; 
    648                 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 
    649                 GOTO_ERROR_ON(res != 0, "MAC next tpl"); 
    650                 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
    651                 GOTO_ERROR_ON(res != 0, "MAC next tpl data"); 
     738        res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE, 
     739                                ssb_pcmcia_get_mac, sprom); 
     740        if (res != 0) { 
     741                ssb_printk(KERN_ERR PFX 
     742                        "PCMCIA: Failed to fetch MAC address\n"); 
     743                return -ENODEV; 
    652744        } 
    653         GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size"); 
    654         memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN); 
    655745 
    656746        /* Fetch the vendor specific tuples. */ 
    657         memset(&tuple, 0, sizeof(tuple)); 
    658         tuple.DesiredTuple = SSB_PCMCIA_CIS; 
    659         tuple.TupleData = buf; 
    660         tuple.TupleDataMax = sizeof(buf); 
    661         res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 
    662         GOTO_ERROR_ON(res != 0, "VEN first tpl"); 
    663         res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
    664         GOTO_ERROR_ON(res != 0, "VEN first tpl data"); 
    665         while (1) { 
    666                 GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1"); 
    667                 switch (tuple.TupleData[0]) { 
    668                 case SSB_PCMCIA_CIS_ID: 
    669                         GOTO_ERROR_ON((tuple.TupleDataLen != 5) && 
    670                                       (tuple.TupleDataLen != 7), 
    671                                       "id tpl size"); 
    672                         bi->vendor = tuple.TupleData[1] | 
    673                                ((u16)tuple.TupleData[2] << 8); 
    674                         break; 
    675                 case SSB_PCMCIA_CIS_BOARDREV: 
    676                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    677                                       "boardrev tpl size"); 
    678                         sprom->board_rev = tuple.TupleData[1]; 
    679                         break; 
    680                 case SSB_PCMCIA_CIS_PA: 
    681                         GOTO_ERROR_ON((tuple.TupleDataLen != 9) && 
    682                                       (tuple.TupleDataLen != 10), 
    683                                       "pa tpl size"); 
    684                         sprom->pa0b0 = tuple.TupleData[1] | 
    685                                  ((u16)tuple.TupleData[2] << 8); 
    686                         sprom->pa0b1 = tuple.TupleData[3] | 
    687                                  ((u16)tuple.TupleData[4] << 8); 
    688                         sprom->pa0b2 = tuple.TupleData[5] | 
    689                                  ((u16)tuple.TupleData[6] << 8); 
    690                         sprom->itssi_a = tuple.TupleData[7]; 
    691                         sprom->itssi_bg = tuple.TupleData[7]; 
    692                         sprom->maxpwr_a = tuple.TupleData[8]; 
    693                         sprom->maxpwr_bg = tuple.TupleData[8]; 
    694                         break; 
    695                 case SSB_PCMCIA_CIS_OEMNAME: 
    696                         /* We ignore this. */ 
    697                         break; 
    698                 case SSB_PCMCIA_CIS_CCODE: 
    699                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    700                                       "ccode tpl size"); 
    701                         sprom->country_code = tuple.TupleData[1]; 
    702                         break; 
    703                 case SSB_PCMCIA_CIS_ANTENNA: 
    704                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    705                                       "ant tpl size"); 
    706                         sprom->ant_available_a = tuple.TupleData[1]; 
    707                         sprom->ant_available_bg = tuple.TupleData[1]; 
    708                         break; 
    709                 case SSB_PCMCIA_CIS_ANTGAIN: 
    710                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    711                                       "antg tpl size"); 
    712                         sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1]; 
    713                         sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1]; 
    714                         sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1]; 
    715                         sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1]; 
    716                         sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1]; 
    717                         sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1]; 
    718                         sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1]; 
    719                         sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1]; 
    720                         break; 
    721                 case SSB_PCMCIA_CIS_BFLAGS: 
    722                         GOTO_ERROR_ON((tuple.TupleDataLen != 3) && 
    723                                       (tuple.TupleDataLen != 5), 
    724                                       "bfl tpl size"); 
    725                         sprom->boardflags_lo = tuple.TupleData[1] | 
    726                                          ((u16)tuple.TupleData[2] << 8); 
    727                         break; 
    728                 case SSB_PCMCIA_CIS_LEDS: 
    729                         GOTO_ERROR_ON(tuple.TupleDataLen != 5, 
    730                                       "leds tpl size"); 
    731                         sprom->gpio0 = tuple.TupleData[1]; 
    732                         sprom->gpio1 = tuple.TupleData[2]; 
    733                         sprom->gpio2 = tuple.TupleData[3]; 
    734                         sprom->gpio3 = tuple.TupleData[4]; 
    735                         break; 
    736                 } 
    737                 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 
    738                 if (res == -ENOSPC) 
    739                         break; 
    740                 GOTO_ERROR_ON(res != 0, "VEN next tpl"); 
    741                 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
    742                 GOTO_ERROR_ON(res != 0, "VEN next tpl data"); 
    743         } 
     747        res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, 
     748                                ssb_pcmcia_do_get_invariants, iv); 
     749        if ((res == 0) || (res == -ENOSPC)) 
     750                return 0; 
    744751 
    745         return 0; 
    746 error: 
    747752        ssb_printk(KERN_ERR PFX 
    748                    "PCMCIA: Failed to fetch device invariants: %s\n", 
    749                    error_description); 
     753                        "PCMCIA: Failed to fetch device invariants\n"); 
    750754        return -ENODEV; 
    751755} 
    752756 
  • 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 
    260260#ifdef CONFIG_SSB_PCIHOST 
    261261        if (bus->bustype == SSB_BUSTYPE_PCI) { 
    262262                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
    263                     bus->host_pci->device == 0x4324) 
     263                    ((bus->host_pci->device == 0x4313) || 
     264                     (bus->host_pci->device == 0x431A) || 
     265                     (bus->host_pci->device == 0x4321) || 
     266                     (bus->host_pci->device == 0x4324))) 
    264267                        return 1; 
    265268        } 
    266269#endif /* CONFIG_SSB_PCIHOST */ 
    int ssb_bus_scan(struct ssb_bus *bus, 
    309312        } else { 
    310313                if (bus->bustype == SSB_BUSTYPE_PCI) { 
    311314                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
    312                         pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
    313                                              &bus->chip_rev); 
     315                        bus->chip_rev = bus->host_pci->revision; 
    314316                        bus->chip_package = 0; 
    315317                } else { 
    316318                        bus->chip_id = 0x4710; 
    int ssb_bus_scan(struct ssb_bus *bus, 
    354356                dev->bus = bus; 
    355357                dev->ops = bus->ops; 
    356358 
    357                 ssb_dprintk(KERN_INFO PFX 
     359                printk(KERN_DEBUG PFX 
    358360                            "Core %d found: %s " 
    359361                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    360362                            i, ssb_core_name(dev->id.coreid), 
    int ssb_bus_scan(struct ssb_bus *bus, 
    422424                        bus->pcicore.dev = dev; 
    423425#endif /* CONFIG_SSB_DRIVER_PCICORE */ 
    424426                        break; 
     427                case SSB_DEV_ETHERNET: 
     428                        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     429                                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     430                                    (bus->host_pci->device & 0xFF00) == 0x4300) { 
     431                                        /* This is a dangling ethernet core on a 
     432                                         * wireless device. Ignore it. */ 
     433                                        continue; 
     434                                } 
     435                        } 
     436                        break; 
    425437                default: 
    426438                        break; 
    427439                } 
  • 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> 
     
    1414#include "ssb_private.h" 
    1515 
    1616#include <linux/ctype.h> 
     17#include <linux/slab.h> 
    1718 
    1819 
    19 static const struct ssb_sprom *fallback_sprom; 
     20static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
    2021 
    2122 
    2223static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
    ssize_t ssb_attr_sprom_store(struct ssb_ 
    102103        u16 *sprom; 
    103104        int res = 0, err = -ENOMEM; 
    104105        size_t sprom_size_words = bus->sprom_size; 
     106        struct ssb_freeze_context freeze; 
    105107 
    106108        sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 
    107109        if (!sprom) 
    ssize_t ssb_attr_sprom_store(struct ssb_ 
    123125        err = -ERESTARTSYS; 
    124126        if (mutex_lock_interruptible(&bus->sprom_mutex)) 
    125127                goto out_kfree; 
    126         err = ssb_devices_freeze(bus); 
    127         if (err == -EOPNOTSUPP) { 
    128                 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
    129                            "No suspend support. Is CONFIG_PM enabled?\n"); 
    130                 goto out_unlock; 
    131         } 
     128        err = ssb_devices_freeze(bus, &freeze); 
    132129        if (err) { 
    133130                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
    134131                goto out_unlock; 
    135132        } 
    136133        res = sprom_write(bus, sprom); 
    137         err = ssb_devices_thaw(bus); 
     134        err = ssb_devices_thaw(&freeze); 
    138135        if (err) 
    139136                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    140137out_unlock: 
    out: 
    148145} 
    149146 
    150147/** 
    151  * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
    152  * 
    153  * @sprom: The SPROM data structure to register. 
     148 * ssb_arch_register_fallback_sprom - Registers a method providing a 
     149 * fallback SPROM if no SPROM is found. 
    154150 * 
    155  * With this function the architecture implementation may register a fallback 
    156  * SPROM data structure. The fallback is only used for PCI based SSB devices, 
    157  * where no valid SPROM can be found in the shadow registers. 
     151 * @sprom_callback: The callback function. 
    158152 * 
    159  * This function is useful for weird architectures that have a half-assed SSB device 
    160  * hardwired to their PCI bus. 
     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. 
    161165 * 
    162  * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
    163  * don't use this fallback. 
    164  * Architectures must provide the SPROM for native SSB devices anyway, 
    165  * so the fallback also isn't used for native devices. 
    166  * 
    167  * 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. 
    168168 */ 
    169 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)) 
    170171{ 
    171         if (fallback_sprom) 
     172        if (get_fallback_sprom) 
    172173                return -EEXIST; 
    173         fallback_sprom = sprom; 
     174        get_fallback_sprom = sprom_callback; 
    174175 
    175176        return 0; 
    176177} 
    177178 
    178 const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     179int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
    179180{ 
    180         return fallback_sprom; 
     181        if (!get_fallback_sprom) 
     182                return -ENOENT; 
     183 
     184        return get_fallback_sprom(bus, out); 
    181185} 
    182186 
    183187/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
    bool ssb_is_sprom_available(struct ssb_b 
    188192        /* this routine differs from specs as we do not access SPROM directly 
    189193           on PCMCIA */ 
    190194        if (bus->bustype == SSB_BUSTYPE_PCI && 
    191             bus->chipco.dev &&  /* can be unavailible! */ 
     195            bus->chipco.dev &&  /* can be unavailable! */ 
    192196            bus->chipco.dev->id.revision >= 31) 
    193197                return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
    194198 
  • 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 */ 
    178179extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
    179 extern int ssb_devices_freeze(struct ssb_bus *bus); 
    180 extern int ssb_devices_thaw(struct ssb_bus *bus); 
    181180extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
    182181int ssb_for_each_bus_call(unsigned long data, 
    183182                          int (*func)(struct ssb_bus *bus, unsigned long data)); 
    184183extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev); 
    185184 
     185struct ssb_freeze_context { 
     186        /* Pointer to the bus */ 
     187        struct ssb_bus *bus; 
     188        /* Boolean list to indicate whether a device is frozen on this bus. */ 
     189        bool device_frozen[SSB_MAX_NR_CORES]; 
     190}; 
     191extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx); 
     192extern int ssb_devices_thaw(struct ssb_freeze_context *ctx); 
     193 
     194 
    186195 
    187196/* b43_pci_bridge.c */ 
    188197#ifdef CONFIG_SSB_B43_PCI_BRIDGE 
    189198extern int __init b43_pci_ssb_bridge_init(void); 
    190199extern void __exit b43_pci_ssb_bridge_exit(void); 
    191 #else /* CONFIG_SSB_B43_PCI_BRIDGR */ 
     200#else /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    192201static inline int b43_pci_ssb_bridge_init(void) 
    193202{ 
    194203        return 0; 
    static inline int b43_pci_ssb_bridge_ini 
    196205static inline void b43_pci_ssb_bridge_exit(void) 
    197206{ 
    198207} 
    199 #endif /* CONFIG_SSB_PCIHOST */ 
     208#endif /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    200209 
    201210#endif /* LINUX_SSB_PRIVATE_H_ */ 
  • 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_device { 
    167190         * is an optimization. */ 
    168191        const struct ssb_bus_ops *ops; 
    169192 
    170         struct device *dev; 
     193        struct device *dev, *dma_dev; 
    171194 
    172195        struct ssb_bus *bus; 
    173196        struct ssb_device_id id; 
    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 { 
    269291 
    270292        const struct ssb_bus_ops *ops; 
    271293 
    272         /* The core in the basic address register window. (PCI bus only) */ 
     294        /* The core currently mapped into the MMIO window. 
     295         * Not valid on all host-buses. So don't use outside of SSB. */ 
    273296        struct ssb_device *mapped_device; 
    274297        union { 
    275298                /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
    struct ssb_bus { 
    281304         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    282305        spinlock_t bar_lock; 
    283306 
    284         /* The bus this backplane is running on. */ 
     307        /* The host-bus this backplane is running on. */ 
    285308        enum ssb_bustype bustype; 
    286         /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
    287         struct pci_dev *host_pci; 
    288         /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
    289         struct pcmcia_device *host_pcmcia; 
    290         /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
    291         struct sdio_func *host_sdio; 
     309        /* Pointers to the host-bus. Check bustype before using any of these pointers. */ 
     310        union { 
     311                /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
     312                struct pci_dev *host_pci; 
     313                /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
     314                struct pcmcia_device *host_pcmcia; 
     315                /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
     316                struct sdio_func *host_sdio; 
     317        }; 
    292318 
    293319        /* See enum ssb_quirks */ 
    294320        unsigned int quirks; 
    struct ssb_bus { 
    300326 
    301327        /* ID information about the Chip. */ 
    302328        u16 chip_id; 
    303         u16 chip_rev; 
     329        u8 chip_rev; 
    304330        u16 sprom_offset; 
    305331        u16 sprom_size;         /* number of words in sprom */ 
    306332        u8 chip_package; 
    extern bool ssb_is_sprom_available(struc 
    396422 
    397423/* Set a fallback SPROM. 
    398424 * See kdoc at the function definition for complete documentation. */ 
    399 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)); 
    400428 
    401429/* Suspend a SSB bus. 
    402430 * Call this from the parent bus suspend routine. */ 
    extern int ssb_bus_may_powerdown(struct 
    667695 * Otherwise static always-on powercontrol will be used. */ 
    668696extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
    669697 
     698extern void ssb_commit_settings(struct ssb_bus *bus); 
    670699 
    671700/* Various helper functions */ 
    672701extern 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) */ 
    100102#define  SSB_TMSLOW_CLOCK       0x00010000 /* Clock Enable */ 
    101103#define  SSB_TMSLOW_FGC         0x00020000 /* Force Gated Clocks On */ 
     
    172174#define SSB_SPROMSIZE_BYTES_R4          (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16)) 
    173175#define SSB_SPROM_BASE1                 0x1000 
    174176#define SSB_SPROM_BASE31                0x0800 
    175 #define SSB_SPROM_REVISION              0x107E 
     177#define SSB_SPROM_REVISION              0x007E 
    176178#define  SSB_SPROM_REVISION_REV         0x00FF  /* SPROM Revision number */ 
    177179#define  SSB_SPROM_REVISION_CRC         0xFF00  /* SPROM CRC8 value */ 
    178180#define  SSB_SPROM_REVISION_CRC_SHIFT   8 
    179181 
    180182/* SPROM Revision 1 */ 
    181 #define SSB_SPROM1_SPID                 0x1004  /* Subsystem Product ID for PCI */ 
    182 #define SSB_SPROM1_SVID                 0x1006  /* Subsystem Vendor ID for PCI */ 
    183 #define SSB_SPROM1_PID                  0x1008  /* Product ID for PCI */ 
    184 #define SSB_SPROM1_IL0MAC               0x1048  /* 6 bytes MAC address for 802.11b/g */ 
    185 #define SSB_SPROM1_ET0MAC               0x104E  /* 6 bytes MAC address for Ethernet */ 
    186 #define SSB_SPROM1_ET1MAC               0x1054  /* 6 bytes MAC address for 802.11a */ 
    187 #define SSB_SPROM1_ETHPHY               0x105A  /* Ethernet PHY settings */ 
     183#define SSB_SPROM1_SPID                 0x0004  /* Subsystem Product ID for PCI */ 
     184#define SSB_SPROM1_SVID                 0x0006  /* Subsystem Vendor ID for PCI */ 
     185#define SSB_SPROM1_PID                  0x0008  /* Product ID for PCI */ 
     186#define SSB_SPROM1_IL0MAC               0x0048  /* 6 bytes MAC address for 802.11b/g */ 
     187#define SSB_SPROM1_ET0MAC               0x004E  /* 6 bytes MAC address for Ethernet */ 
     188#define SSB_SPROM1_ET1MAC               0x0054  /* 6 bytes MAC address for 802.11a */ 
     189#define SSB_SPROM1_ETHPHY               0x005A  /* Ethernet PHY settings */ 
    188190#define  SSB_SPROM1_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */ 
    189191#define  SSB_SPROM1_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */ 
    190192#define  SSB_SPROM1_ETHPHY_ET1A_SHIFT   5 
    191193#define  SSB_SPROM1_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */ 
    192194#define  SSB_SPROM1_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */ 
    193 #define SSB_SPROM1_BINF                 0x105C  /* Board info */ 
     195#define SSB_SPROM1_BINF                 0x005C  /* Board info */ 
    194196#define  SSB_SPROM1_BINF_BREV           0x00FF  /* Board Revision */ 
    195197#define  SSB_SPROM1_BINF_CCODE          0x0F00  /* Country Code */ 
    196198#define  SSB_SPROM1_BINF_CCODE_SHIFT    8 
     
    198200#define  SSB_SPROM1_BINF_ANTBG_SHIFT    12 
    199201#define  SSB_SPROM1_BINF_ANTA           0xC000  /* Available A-PHY antennas */ 
    200202#define  SSB_SPROM1_BINF_ANTA_SHIFT     14 
    201 #define SSB_SPROM1_PA0B0                0x105E 
    202 #define SSB_SPROM1_PA0B1                0x1060 
    203 #define SSB_SPROM1_PA0B2                0x1062 
    204 #define SSB_SPROM1_GPIOA                0x1064  /* General Purpose IO pins 0 and 1 */ 
     203#define SSB_SPROM1_PA0B0                0x005E 
     204#define SSB_SPROM1_PA0B1                0x0060 
     205#define SSB_SPROM1_PA0B2                0x0062 
     206#define SSB_SPROM1_GPIOA                0x0064  /* General Purpose IO pins 0 and 1 */ 
    205207#define  SSB_SPROM1_GPIOA_P0            0x00FF  /* Pin 0 */ 
    206208#define  SSB_SPROM1_GPIOA_P1            0xFF00  /* Pin 1 */ 
    207209#define  SSB_SPROM1_GPIOA_P1_SHIFT      8 
    208 #define SSB_SPROM1_GPIOB                0x1066  /* General Purpuse IO pins 2 and 3 */ 
     210#define SSB_SPROM1_GPIOB                0x0066  /* General Purpuse IO pins 2 and 3 */ 
    209211#define  SSB_SPROM1_GPIOB_P2            0x00FF  /* Pin 2 */ 
    210212#define  SSB_SPROM1_GPIOB_P3            0xFF00  /* Pin 3 */ 
    211213#define  SSB_SPROM1_GPIOB_P3_SHIFT      8 
    212 #define SSB_SPROM1_MAXPWR               0x1068  /* Power Amplifier Max Power */ 
     214#define SSB_SPROM1_MAXPWR               0x0068  /* Power Amplifier Max Power */ 
    213215#define  SSB_SPROM1_MAXPWR_BG           0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */ 
    214216#define  SSB_SPROM1_MAXPWR_A            0xFF00  /* A-PHY (in dBm Q5.2) */ 
    215217#define  SSB_SPROM1_MAXPWR_A_SHIFT      8 
    216 #define SSB_SPROM1_PA1B0                0x106A 
    217 #define SSB_SPROM1_PA1B1                0x106C 
    218 #define SSB_SPROM1_PA1B2                0x106E 
    219 #define SSB_SPROM1_ITSSI                0x1070  /* Idle TSSI Target */ 
     218#define SSB_SPROM1_PA1B0                0x006A 
     219#define SSB_SPROM1_PA1B1                0x006C 
     220#define SSB_SPROM1_PA1B2                0x006E 
     221#define SSB_SPROM1_ITSSI                0x0070  /* Idle TSSI Target */ 
    220222#define  SSB_SPROM1_ITSSI_BG            0x00FF  /* B-PHY and G-PHY*/ 
    221223#define  SSB_SPROM1_ITSSI_A             0xFF00  /* A-PHY */ 
    222224#define  SSB_SPROM1_ITSSI_A_SHIFT       8 
    223 #define SSB_SPROM1_BFLLO                0x1072  /* Boardflags (low 16 bits) */ 
    224 #define SSB_SPROM1_AGAIN                0x1074  /* Antenna Gain (in dBm Q5.2) */ 
     225#define SSB_SPROM1_BFLLO                0x0072  /* Boardflags (low 16 bits) */ 
     226#define SSB_SPROM1_AGAIN                0x0074  /* Antenna Gain (in dBm Q5.2) */ 
    225227#define  SSB_SPROM1_AGAIN_BG            0x00FF  /* B-PHY and G-PHY */ 
    226228#define  SSB_SPROM1_AGAIN_BG_SHIFT      0 
    227229#define  SSB_SPROM1_AGAIN_A             0xFF00  /* A-PHY */ 
    228230#define  SSB_SPROM1_AGAIN_A_SHIFT       8 
    229231 
    230232/* SPROM Revision 2 (inherits from rev 1) */ 
    231 #define SSB_SPROM2_BFLHI                0x1038  /* Boardflags (high 16 bits) */ 
    232 #define SSB_SPROM2_MAXP_A               0x103A  /* A-PHY Max Power */ 
     233#define SSB_SPROM2_BFLHI                0x0038  /* Boardflags (high 16 bits) */ 
     234#define SSB_SPROM2_MAXP_A               0x003A  /* A-PHY Max Power */ 
    233235#define  SSB_SPROM2_MAXP_A_HI           0x00FF  /* Max Power High */ 
    234236#define  SSB_SPROM2_MAXP_A_LO           0xFF00  /* Max Power Low */ 
    235237#define  SSB_SPROM2_MAXP_A_LO_SHIFT     8 
    236 #define SSB_SPROM2_PA1LOB0              0x103C  /* A-PHY PowerAmplifier Low Settings */ 
    237 #define SSB_SPROM2_PA1LOB1              0x103E  /* A-PHY PowerAmplifier Low Settings */ 
    238 #define SSB_SPROM2_PA1LOB2              0x1040  /* A-PHY PowerAmplifier Low Settings */ 
    239 #define SSB_SPROM2_PA1HIB0              0x1042  /* A-PHY PowerAmplifier High Settings */ 
    240 #define SSB_SPROM2_PA1HIB1              0x1044  /* A-PHY PowerAmplifier High Settings */ 
    241 #define SSB_SPROM2_PA1HIB2              0x1046  /* A-PHY PowerAmplifier High Settings */ 
    242 #define SSB_SPROM2_OPO                  0x1078  /* OFDM Power Offset from CCK Level */ 
     238#define SSB_SPROM2_PA1LOB0              0x003C  /* A-PHY PowerAmplifier Low Settings */ 
     239#define SSB_SPROM2_PA1LOB1              0x003E  /* A-PHY PowerAmplifier Low Settings */ 
     240#define SSB_SPROM2_PA1LOB2              0x0040  /* A-PHY PowerAmplifier Low Settings */ 
     241#define SSB_SPROM2_PA1HIB0              0x0042  /* A-PHY PowerAmplifier High Settings */ 
     242#define SSB_SPROM2_PA1HIB1              0x0044  /* A-PHY PowerAmplifier High Settings */ 
     243#define SSB_SPROM2_PA1HIB2              0x0046  /* A-PHY PowerAmplifier High Settings */ 
     244#define SSB_SPROM2_OPO                  0x0078  /* OFDM Power Offset from CCK Level */ 
    243245#define  SSB_SPROM2_OPO_VALUE           0x00FF 
    244246#define  SSB_SPROM2_OPO_UNUSED          0xFF00 
    245 #define SSB_SPROM2_CCODE                0x107C  /* Two char Country Code */ 
     247#define SSB_SPROM2_CCODE                0x007C  /* Two char Country Code */ 
    246248 
    247249/* SPROM Revision 3 (inherits most data from rev 2) */ 
    248 #define SSB_SPROM3_IL0MAC               0x104A  /* 6 bytes MAC address for 802.11b/g */ 
    249 #define SSB_SPROM3_OFDMAPO              0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
    250 #define SSB_SPROM3_OFDMALPO             0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
    251 #define SSB_SPROM3_OFDMAHPO             0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
    252 #define SSB_SPROM3_GPIOLDC              0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
     250#define SSB_SPROM3_OFDMAPO              0x002C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
     251#define SSB_SPROM3_OFDMALPO             0x0030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
     252#define SSB_SPROM3_OFDMAHPO             0x0034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
     253#define SSB_SPROM3_GPIOLDC              0x0042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
    253254#define  SSB_SPROM3_GPIOLDC_OFF         0x0000FF00      /* Off Count */ 
    254255#define  SSB_SPROM3_GPIOLDC_OFF_SHIFT   8 
    255256#define  SSB_SPROM3_GPIOLDC_ON          0x00FF0000      /* On Count */ 
    256257#define  SSB_SPROM3_GPIOLDC_ON_SHIFT    16 
    257 #define SSB_SPROM3_CCKPO                0x1078  /* CCK Power Offset */ 
     258#define SSB_SPROM3_IL0MAC               0x004A  /* 6 bytes MAC address for 802.11b/g */ 
     259#define SSB_SPROM3_CCKPO                0x0078  /* CCK Power Offset */ 
    258260#define  SSB_SPROM3_CCKPO_1M            0x000F  /* 1M Rate PO */ 
    259261#define  SSB_SPROM3_CCKPO_2M            0x00F0  /* 2M Rate PO */ 
    260262#define  SSB_SPROM3_CCKPO_2M_SHIFT      4 
     
    265267#define  SSB_SPROM3_OFDMGPO             0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */ 
    266268 
    267269/* SPROM Revision 4 */ 
    268 #define SSB_SPROM4_IL0MAC               0x104C  /* 6 byte MAC address for a/b/g/n */ 
    269 #define SSB_SPROM4_ETHPHY               0x105A  /* Ethernet PHY settings ?? */ 
     270#define SSB_SPROM4_BFLLO                0x0044  /* Boardflags (low 16 bits) */ 
     271#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 */ 
     274#define SSB_SPROM4_IL0MAC               0x004C  /* 6 byte MAC address for a/b/g/n */ 
     275#define SSB_SPROM4_CCODE                0x0052  /* Country Code (2 bytes) */ 
     276#define SSB_SPROM4_GPIOA                0x0056  /* Gen. Purpose IO # 0 and 1 */ 
     277#define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */ 
     278#define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */ 
     279#define  SSB_SPROM4_GPIOA_P1_SHIFT      8 
     280#define SSB_SPROM4_GPIOB                0x0058  /* Gen. Purpose IO # 2 and 3 */ 
     281#define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */ 
     282#define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */ 
     283#define  SSB_SPROM4_GPIOB_P3_SHIFT      8 
     284#define SSB_SPROM4_ETHPHY               0x005A  /* Ethernet PHY settings ?? */ 
    270285#define  SSB_SPROM4_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */ 
    271286#define  SSB_SPROM4_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */ 
    272287#define  SSB_SPROM4_ETHPHY_ET1A_SHIFT   5 
    273288#define  SSB_SPROM4_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */ 
    274289#define  SSB_SPROM4_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */ 
    275 #define SSB_SPROM4_CCODE                0x1052  /* Country Code (2 bytes) */ 
    276 #define SSB_SPROM4_ANTAVAIL             0x105D  /* Antenna available bitfields */ 
    277 #define SSB_SPROM4_ANTAVAIL_A           0x00FF  /* A-PHY bitfield */ 
    278 #define SSB_SPROM4_ANTAVAIL_A_SHIFT     0 
    279 #define SSB_SPROM4_ANTAVAIL_BG          0xFF00  /* B-PHY and G-PHY bitfield */ 
    280 #define SSB_SPROM4_ANTAVAIL_BG_SHIFT    8 
    281 #define SSB_SPROM4_BFLLO                0x1044  /* Boardflags (low 16 bits) */ 
    282 #define SSB_SPROM4_AGAIN01              0x105E  /* Antenna Gain (in dBm Q5.2) */ 
     290#define SSB_SPROM4_ANTAVAIL             0x005D  /* Antenna available bitfields */ 
     291#define  SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */ 
     292#define  SSB_SPROM4_ANTAVAIL_A_SHIFT    0 
     293#define  SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */ 
     294#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT   8 
     295#define SSB_SPROM4_AGAIN01              0x005E  /* Antenna Gain (in dBm Q5.2) */ 
    283296#define  SSB_SPROM4_AGAIN0              0x00FF  /* Antenna 0 */ 
    284297#define  SSB_SPROM4_AGAIN0_SHIFT        0 
    285298#define  SSB_SPROM4_AGAIN1              0xFF00  /* Antenna 1 */ 
    286299#define  SSB_SPROM4_AGAIN1_SHIFT        8 
    287 #define SSB_SPROM4_AGAIN23              0x1060 
     300#define SSB_SPROM4_AGAIN23              0x0060 
    288301#define  SSB_SPROM4_AGAIN2              0x00FF  /* Antenna 2 */ 
    289302#define  SSB_SPROM4_AGAIN2_SHIFT        0 
    290303#define  SSB_SPROM4_AGAIN3              0xFF00  /* Antenna 3 */ 
    291304#define  SSB_SPROM4_AGAIN3_SHIFT        8 
    292 #define SSB_SPROM4_BFLHI                0x1046  /* Board Flags Hi */ 
    293 #define SSB_SPROM4_MAXP_BG              0x1080  /* Max Power BG in path 1 */ 
     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 
     345#define SSB_SPROM4_MAXP_BG              0x0080  /* Max Power BG in path 1 */ 
    294346#define  SSB_SPROM4_MAXP_BG_MASK        0x00FF  /* Mask for Max Power BG */ 
    295347#define  SSB_SPROM4_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
    296348#define  SSB_SPROM4_ITSSI_BG_SHIFT      8 
    297 #define SSB_SPROM4_MAXP_A               0x108A  /* Max Power A in path 1 */ 
     349#define SSB_SPROM4_MAXP_A               0x008A  /* Max Power A in path 1 */ 
    298350#define  SSB_SPROM4_MAXP_A_MASK         0x00FF  /* Mask for Max Power A */ 
    299351#define  SSB_SPROM4_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
    300352#define  SSB_SPROM4_ITSSI_A_SHIFT       8 
    301 #define SSB_SPROM4_GPIOA                0x1056  /* Gen. Purpose IO # 0 and 1 */ 
    302 #define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */ 
    303 #define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */ 
    304 #define  SSB_SPROM4_GPIOA_P1_SHIFT      8 
    305 #define SSB_SPROM4_GPIOB                0x1058  /* Gen. Purpose IO # 2 and 3 */ 
    306 #define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */ 
    307 #define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */ 
    308 #define  SSB_SPROM4_GPIOB_P3_SHIFT      8 
    309 #define SSB_SPROM4_PA0B0                0x1082  /* The paXbY locations are */ 
    310 #define SSB_SPROM4_PA0B1                0x1084  /*   only guesses */ 
    311 #define SSB_SPROM4_PA0B2                0x1086 
    312 #define SSB_SPROM4_PA1B0                0x108E 
    313 #define SSB_SPROM4_PA1B1                0x1090 
    314 #define SSB_SPROM4_PA1B2                0x1092 
     353#define SSB_SPROM4_PA0B0                0x0082  /* The paXbY locations are */ 
     354#define SSB_SPROM4_PA0B1                0x0084  /*   only guesses */ 
     355#define SSB_SPROM4_PA0B2                0x0086 
     356#define SSB_SPROM4_PA1B0                0x008E 
     357#define SSB_SPROM4_PA1B1                0x0090 
     358#define SSB_SPROM4_PA1B2                0x0092 
    315359 
    316360/* SPROM Revision 5 (inherits most data from rev 4) */ 
    317 #define SSB_SPROM5_BFLLO                0x104A  /* Boardflags (low 16 bits) */ 
    318 #define SSB_SPROM5_BFLHI                0x104C  /* Board Flags Hi */ 
    319 #define SSB_SPROM5_IL0MAC               0x1052  /* 6 byte MAC address for a/b/g/n */ 
    320 #define SSB_SPROM5_CCODE                0x1044  /* Country Code (2 bytes) */ 
    321 #define SSB_SPROM5_GPIOA                0x1076  /* Gen. Purpose IO # 0 and 1 */ 
     361#define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */ 
     362#define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */ 
     363#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 */ 
     366#define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */ 
     367#define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */ 
    322368#define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */ 
    323369#define  SSB_SPROM5_GPIOA_P1            0xFF00  /* Pin 1 */ 
    324370#define  SSB_SPROM5_GPIOA_P1_SHIFT      8 
    325 #define SSB_SPROM5_GPIOB                0x1078  /* Gen. Purpose IO # 2 and 3 */ 
     371#define SSB_SPROM5_GPIOB                0x0078  /* Gen. Purpose IO # 2 and 3 */ 
    326372#define  SSB_SPROM5_GPIOB_P2            0x00FF  /* Pin 2 */ 
    327373#define  SSB_SPROM5_GPIOB_P3            0xFF00  /* Pin 3 */ 
    328374#define  SSB_SPROM5_GPIOB_P3_SHIFT      8 
    329375 
    330376/* SPROM Revision 8 */ 
    331 #define SSB_SPROM8_BOARDREV             0x1082  /* Board revision */ 
    332 #define SSB_SPROM8_BFLLO                0x1084  /* Board flags (bits 0-15) */ 
    333 #define SSB_SPROM8_BFLHI                0x1086  /* Board flags (bits 16-31) */ 
    334 #define SSB_SPROM8_BFL2LO               0x1088  /* Board flags (bits 32-47) */ 
    335 #define SSB_SPROM8_BFL2HI               0x108A  /* Board flags (bits 48-63) */ 
    336 #define SSB_SPROM8_IL0MAC               0x108C  /* 6 byte MAC address */ 
    337 #define SSB_SPROM8_CCODE                0x1092  /* 2 byte country code */ 
    338 #define SSB_SPROM8_ANTAVAIL             0x109C  /* Antenna available bitfields*/ 
    339 #define SSB_SPROM8_ANTAVAIL_A           0xFF00  /* A-PHY bitfield */ 
    340 #define SSB_SPROM8_ANTAVAIL_A_SHIFT     8 
    341 #define SSB_SPROM8_ANTAVAIL_BG          0x00FF  /* B-PHY and G-PHY bitfield */ 
    342 #define SSB_SPROM8_ANTAVAIL_BG_SHIFT    0 
    343 #define SSB_SPROM8_AGAIN01              0x109E  /* Antenna Gain (in dBm Q5.2) */ 
     377#define SSB_SPROM8_BOARDREV             0x0082  /* Board revision */ 
     378#define SSB_SPROM8_BFLLO                0x0084  /* Board flags (bits 0-15) */ 
     379#define SSB_SPROM8_BFLHI                0x0086  /* Board flags (bits 16-31) */ 
     380#define SSB_SPROM8_BFL2LO               0x0088  /* Board flags (bits 32-47) */ 
     381#define SSB_SPROM8_BFL2HI               0x008A  /* Board flags (bits 48-63) */ 
     382#define SSB_SPROM8_IL0MAC               0x008C  /* 6 byte MAC address */ 
     383#define SSB_SPROM8_CCODE                0x0092  /* 2 byte country code */ 
     384#define SSB_SPROM8_GPIOA                0x0096  /*Gen. Purpose IO # 0 and 1 */ 
     385#define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */ 
     386#define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */ 
     387#define  SSB_SPROM8_GPIOA_P1_SHIFT      8 
     388#define SSB_SPROM8_GPIOB                0x0098  /* Gen. Purpose IO # 2 and 3 */ 
     389#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
     390#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
     391#define  SSB_SPROM8_GPIOB_P3_SHIFT      8 
     392#define SSB_SPROM8_ANTAVAIL             0x009C  /* Antenna available bitfields*/ 
     393#define  SSB_SPROM8_ANTAVAIL_A          0xFF00  /* A-PHY bitfield */ 
     394#define  SSB_SPROM8_ANTAVAIL_A_SHIFT    8 
     395#define  SSB_SPROM8_ANTAVAIL_BG         0x00FF  /* B-PHY and G-PHY bitfield */ 
     396#define  SSB_SPROM8_ANTAVAIL_BG_SHIFT   0 
     397#define SSB_SPROM8_AGAIN01              0x009E  /* Antenna Gain (in dBm Q5.2) */ 
    344398#define  SSB_SPROM8_AGAIN0              0x00FF  /* Antenna 0 */ 
    345399#define  SSB_SPROM8_AGAIN0_SHIFT        0 
    346400#define  SSB_SPROM8_AGAIN1              0xFF00  /* Antenna 1 */ 
    347401#define  SSB_SPROM8_AGAIN1_SHIFT        8 
    348 #define SSB_SPROM8_AGAIN23              0x10A0 
     402#define SSB_SPROM8_AGAIN23              0x00A0 
    349403#define  SSB_SPROM8_AGAIN2              0x00FF  /* Antenna 2 */ 
    350404#define  SSB_SPROM8_AGAIN2_SHIFT        0 
    351405#define  SSB_SPROM8_AGAIN3              0xFF00  /* Antenna 3 */ 
    352406#define  SSB_SPROM8_AGAIN3_SHIFT        8 
    353 #define SSB_SPROM8_GPIOA                0x1096  /*Gen. Purpose IO # 0 and 1 */ 
    354 #define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */ 
    355 #define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */ 
    356 #define  SSB_SPROM8_GPIOA_P1_SHIFT      8 
    357 #define SSB_SPROM8_GPIOB                0x1098  /* Gen. Purpose IO # 2 and 3 */ 
    358 #define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
    359 #define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
    360 #define  SSB_SPROM8_GPIOB_P3_SHIFT      8 
    361 #define SSB_SPROM8_RSSIPARM2G           0x10A4  /* RSSI params for 2GHz */ 
     407#define SSB_SPROM8_RSSIPARM2G           0x00A4  /* RSSI params for 2GHz */ 
    362408#define  SSB_SPROM8_RSSISMF2G           0x000F 
    363409#define  SSB_SPROM8_RSSISMC2G           0x00F0 
    364410#define  SSB_SPROM8_RSSISMC2G_SHIFT     4 
     
    366412#define  SSB_SPROM8_RSSISAV2G_SHIFT     8 
    367413#define  SSB_SPROM8_BXA2G               0x1800 
    368414#define  SSB_SPROM8_BXA2G_SHIFT         11 
    369 #define SSB_SPROM8_RSSIPARM5G           0x10A6  /* RSSI params for 5GHz */ 
     415#define SSB_SPROM8_RSSIPARM5G           0x00A6  /* RSSI params for 5GHz */ 
    370416#define  SSB_SPROM8_RSSISMF5G           0x000F 
    371417#define  SSB_SPROM8_RSSISMC5G           0x00F0 
    372418#define  SSB_SPROM8_RSSISMC5G_SHIFT     4 
     
    374420#define  SSB_SPROM8_RSSISAV5G_SHIFT     8 
    375421#define  SSB_SPROM8_BXA5G               0x1800 
    376422#define  SSB_SPROM8_BXA5G_SHIFT         11 
    377 #define SSB_SPROM8_TRI25G               0x10A8  /* TX isolation 2.4&5.3GHz */ 
     423#define SSB_SPROM8_TRI25G               0x00A8  /* TX isolation 2.4&5.3GHz */ 
    378424#define  SSB_SPROM8_TRI2G               0x00FF  /* TX isolation 2.4GHz */ 
    379425#define  SSB_SPROM8_TRI5G               0xFF00  /* TX isolation 5.3GHz */ 
    380426#define  SSB_SPROM8_TRI5G_SHIFT         8 
    381 #define SSB_SPROM8_TRI5GHL              0x10AA  /* TX isolation 5.2/5.8GHz */ 
     427#define SSB_SPROM8_TRI5GHL              0x00AA  /* TX isolation 5.2/5.8GHz */ 
    382428#define  SSB_SPROM8_TRI5GL              0x00FF  /* TX isolation 5.2GHz */ 
    383429#define  SSB_SPROM8_TRI5GH              0xFF00  /* TX isolation 5.8GHz */ 
    384430#define  SSB_SPROM8_TRI5GH_SHIFT        8 
    385 #define SSB_SPROM8_RXPO                 0x10AC  /* RX power offsets */ 
     431#define SSB_SPROM8_RXPO                 0x00AC  /* RX power offsets */ 
    386432#define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */ 
    387433#define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */ 
    388434#define  SSB_SPROM8_RXPO5G_SHIFT        8 
    389 #define SSB_SPROM8_MAXP_BG              0x10C0  /* Max Power 2GHz in path 1 */ 
     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 */ 
     485#define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */ 
    390486#define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */ 
    391487#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
    392488#define  SSB_SPROM8_ITSSI_BG_SHIFT      8 
    393 #define SSB_SPROM8_PA0B0                0x10C2  /* 2GHz power amp settings */ 
    394 #define SSB_SPROM8_PA0B1                0x10C4 
    395 #define SSB_SPROM8_PA0B2                0x10C6 
    396 #define SSB_SPROM8_MAXP_A               0x10C8  /* Max Power 5.3GHz */ 
     489#define SSB_SPROM8_PA0B0                0x00C2  /* 2GHz power amp settings */ 
     490#define SSB_SPROM8_PA0B1                0x00C4 
     491#define SSB_SPROM8_PA0B2                0x00C6 
     492#define SSB_SPROM8_MAXP_A               0x00C8  /* Max Power 5.3GHz */ 
    397493#define  SSB_SPROM8_MAXP_A_MASK         0x00FF  /* Mask for Max Power 5.3GHz */ 
    398494#define  SSB_SPROM8_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
    399495#define  SSB_SPROM8_ITSSI_A_SHIFT       8 
    400 #define SSB_SPROM8_MAXP_AHL             0x10CA  /* Max Power 5.2/5.8GHz */ 
     496#define SSB_SPROM8_MAXP_AHL             0x00CA  /* Max Power 5.2/5.8GHz */ 
    401497#define  SSB_SPROM8_MAXP_AH_MASK        0x00FF  /* Mask for Max Power 5.8GHz */ 
    402498#define  SSB_SPROM8_MAXP_AL_MASK        0xFF00  /* Mask for Max Power 5.2GHz */ 
    403499#define  SSB_SPROM8_MAXP_AL_SHIFT       8 
    404 #define SSB_SPROM8_PA1B0                0x10CC  /* 5.3GHz power amp settings */ 
    405 #define SSB_SPROM8_PA1B1                0x10CE 
    406 #define SSB_SPROM8_PA1B2                0x10D0 
    407 #define SSB_SPROM8_PA1LOB0              0x10D2  /* 5.2GHz power amp settings */ 
    408 #define SSB_SPROM8_PA1LOB1              0x10D4 
    409 #define SSB_SPROM8_PA1LOB2              0x10D6 
    410 #define SSB_SPROM8_PA1HIB0              0x10D8  /* 5.8GHz power amp settings */ 
    411 #define SSB_SPROM8_PA1HIB1              0x10DA 
    412 #define SSB_SPROM8_PA1HIB2              0x10DC 
    413 #define SSB_SPROM8_CCK2GPO              0x1140  /* CCK power offset */ 
    414 #define SSB_SPROM8_OFDM2GPO             0x1142  /* 2.4GHz OFDM power offset */ 
    415 #define SSB_SPROM8_OFDM5GPO             0x1146  /* 5.3GHz OFDM power offset */ 
    416 #define SSB_SPROM8_OFDM5GLPO            0x114A  /* 5.2GHz OFDM power offset */ 
    417 #define SSB_SPROM8_OFDM5GHPO            0x114E  /* 5.8GHz OFDM power offset */ 
     500#define SSB_SPROM8_PA1B0                0x00CC  /* 5.3GHz power amp settings */ 
     501#define SSB_SPROM8_PA1B1                0x00CE 
     502#define SSB_SPROM8_PA1B2                0x00D0 
     503#define SSB_SPROM8_PA1LOB0              0x00D2  /* 5.2GHz power amp settings */ 
     504#define SSB_SPROM8_PA1LOB1              0x00D4 
     505#define SSB_SPROM8_PA1LOB2              0x00D6 
     506#define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */ 
     507#define SSB_SPROM8_PA1HIB1              0x00DA 
     508#define SSB_SPROM8_PA1HIB2              0x00DC 
     509 
     510#define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */ 
     511#define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */ 
     512#define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */ 
     513#define SSB_SPROM8_OFDM5GLPO            0x014A  /* 5.2GHz OFDM power offset */ 
     514#define SSB_SPROM8_OFDM5GHPO            0x014E  /* 5.8GHz OFDM power offset */ 
     515 
     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 */ 
    418555 
    419556/* Values for SSB_SPROM1_BINF_CCODE */ 
    420557enum { 
  • 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/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/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.