source: branches/backfire/target/linux/generic-2.6/patches-2.6.30/941-ssb_update.patch @ 21276

Last change on this file since 21276 was 21276, checked in by nbd, 6 years ago

[backfire] backport ssb updates from r21269, this is required for future mac80211 updates

File size: 54.6 KB
  • drivers/ssb/driver_chipcommon_pmu.c

    a b static void ssb_chipco_pll_write(struct  
    2828        chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, value); 
    2929} 
    3030 
     31static void ssb_chipco_regctl_maskset(struct ssb_chipcommon *cc, 
     32                                   u32 offset, u32 mask, u32 set) 
     33{ 
     34        u32 value; 
     35 
     36        chipco_read32(cc, SSB_CHIPCO_REGCTL_ADDR); 
     37        chipco_write32(cc, SSB_CHIPCO_REGCTL_ADDR, offset); 
     38        chipco_read32(cc, SSB_CHIPCO_REGCTL_ADDR); 
     39        value = chipco_read32(cc, SSB_CHIPCO_REGCTL_DATA); 
     40        value &= mask; 
     41        value |= set; 
     42        chipco_write32(cc, SSB_CHIPCO_REGCTL_DATA, value); 
     43        chipco_read32(cc, SSB_CHIPCO_REGCTL_DATA); 
     44} 
     45 
    3146struct pmu0_plltab_entry { 
    3247        u16 freq;       /* Crystal frequency in kHz.*/ 
    3348        u8 xf;          /* Crystal frequency value for PMU control */ 
    static void ssb_pmu_pll_init(struct ssb_ 
    317332        case 0x5354: 
    318333                ssb_pmu0_pllinit_r0(cc, crystalfreq); 
    319334                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; 
    320341        default: 
    321342                ssb_printk(KERN_ERR PFX 
    322343                           "ERROR: PLL init unknown for device %04X\n", 
    static void ssb_pmu_resources_init(struc 
    402423 
    403424        switch (bus->chip_id) { 
    404425        case 0x4312: 
     426        case 0x4322: 
    405427                /* We keep the default settings: 
    406428                 * min_msk = 0xCBB 
    407429                 * max_msk = 0x7FFFF 
    void ssb_pmu_init(struct ssb_chipcommon  
    506528        ssb_pmu_pll_init(cc); 
    507529        ssb_pmu_resources_init(cc); 
    508530} 
     531 
     532void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc, 
     533                             enum ssb_pmu_ldo_volt_id id, u32 voltage) 
     534{ 
     535        struct ssb_bus *bus = cc->dev->bus; 
     536        u32 addr, shift, mask; 
     537 
     538        switch (bus->chip_id) { 
     539        case 0x4328: 
     540        case 0x5354: 
     541                switch (id) { 
     542                case LDO_VOLT1: 
     543                        addr = 2; 
     544                        shift = 25; 
     545                        mask = 0xF; 
     546                        break; 
     547                case LDO_VOLT2: 
     548                        addr = 3; 
     549                        shift = 1; 
     550                        mask = 0xF; 
     551                        break; 
     552                case LDO_VOLT3: 
     553                        addr = 3; 
     554                        shift = 9; 
     555                        mask = 0xF; 
     556                        break; 
     557                case LDO_PAREF: 
     558                        addr = 3; 
     559                        shift = 17; 
     560                        mask = 0x3F; 
     561                        break; 
     562                default: 
     563                        SSB_WARN_ON(1); 
     564                        return; 
     565                } 
     566                break; 
     567        case 0x4312: 
     568                if (SSB_WARN_ON(id != LDO_PAREF)) 
     569                        return; 
     570                addr = 0; 
     571                shift = 21; 
     572                mask = 0x3F; 
     573                break; 
     574        default: 
     575                return; 
     576        } 
     577 
     578        ssb_chipco_regctl_maskset(cc, addr, ~(mask << shift), 
     579                                  (voltage & mask) << shift); 
     580} 
     581 
     582void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on) 
     583{ 
     584        struct ssb_bus *bus = cc->dev->bus; 
     585        int ldo; 
     586 
     587        switch (bus->chip_id) { 
     588        case 0x4312: 
     589                ldo = SSB_PMURES_4312_PA_REF_LDO; 
     590                break; 
     591        case 0x4328: 
     592                ldo = SSB_PMURES_4328_PA_REF_LDO; 
     593                break; 
     594        case 0x5354: 
     595                ldo = SSB_PMURES_5354_PA_REF_LDO; 
     596                break; 
     597        default: 
     598                return; 
     599        } 
     600 
     601        if (on) 
     602                chipco_set32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 1 << ldo); 
     603        else 
     604                chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, ~(1 << ldo)); 
     605        chipco_read32(cc, SSB_CHIPCO_PMU_MINRES_MSK); //SPEC FIXME found via mmiotrace - dummy read? 
     606} 
     607 
     608EXPORT_SYMBOL(ssb_pmu_set_ldo_voltage); 
     609EXPORT_SYMBOL(ssb_pmu_set_ldo_paref); 
  • drivers/ssb/main.c

    a b static int ssb_devices_register(struct s 
    472472                case SSB_BUSTYPE_SSB: 
    473473                        dev->dma_mask = &dev->coherent_dma_mask; 
    474474                        break; 
     475                default: 
     476                        break; 
    475477                } 
    476478 
    477479                sdev->dev = dev; 
    static int __init ssb_modinit(void) 
    13581360        ssb_buses_lock(); 
    13591361        err = ssb_attach_queued_buses(); 
    13601362        ssb_buses_unlock(); 
    1361         if (err) 
     1363        if (err) { 
    13621364                bus_unregister(&ssb_bustype); 
     1365                goto out; 
     1366        } 
    13631367 
    13641368        err = b43_pci_ssb_bridge_init(); 
    13651369        if (err) { 
    static int __init ssb_modinit(void) 
    13751379                /* don't fail SSB init because of this */ 
    13761380                err = 0; 
    13771381        } 
    1378  
     1382out: 
    13791383        return err; 
    13801384} 
    13811385/* ssb must be initialized after PCI but before the ssb drivers. 
  • drivers/ssb/pci.c

    a b err_pci: 
    167167} 
    168168 
    169169/* Get the word-offset for a SSB_SPROM_XXX define. */ 
    170 #define SPOFF(offset)   (((offset) - SSB_SPROM_BASE) / sizeof(u16)) 
     170#define SPOFF(offset)   ((offset) / sizeof(u16)) 
    171171/* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */ 
    172 #define SPEX(_outvar, _offset, _mask, _shift)   \ 
     172#define SPEX16(_outvar, _offset, _mask, _shift) \ 
    173173        out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift)) 
     174#define SPEX32(_outvar, _offset, _mask, _shift) \ 
     175        out->_outvar = ((((u32)in[SPOFF((_offset)+2)] << 16 | \ 
     176                           in[SPOFF(_offset)]) & (_mask)) >> (_shift)) 
     177#define SPEX(_outvar, _offset, _mask, _shift) \ 
     178        SPEX16(_outvar, _offset, _mask, _shift) 
     179 
    174180 
    175181static inline u8 ssb_crc8(u8 crc, u8 data) 
    176182{ 
    static int sprom_do_read(struct ssb_bus  
    247253        int i; 
    248254 
    249255        for (i = 0; i < bus->sprom_size; i++) 
    250                 sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     256                sprom[i] = ioread16(bus->mmio + bus->sprom_offset + (i * 2)); 
    251257 
    252258        return 0; 
    253259} 
    static int sprom_do_write(struct ssb_bus 
    278284                        ssb_printk("75%%"); 
    279285                else if (i % 2) 
    280286                        ssb_printk("."); 
    281                 writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     287                writew(sprom[i], bus->mmio + bus->sprom_offset + (i * 2)); 
    282288                mmiowb(); 
    283289                msleep(20); 
    284290        } 
    static void sprom_extract_r8(struct ssb_ 
    474480 
    475481        /* extract the MAC address */ 
    476482        for (i = 0; i < 3; i++) { 
    477                 v = in[SPOFF(SSB_SPROM1_IL0MAC) + i]; 
     483                v = in[SPOFF(SSB_SPROM8_IL0MAC) + i]; 
    478484                *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v); 
    479485        } 
    480486        SPEX(country_code, SSB_SPROM8_CCODE, 0xFFFF, 0); 
    481487        SPEX(boardflags_lo, SSB_SPROM8_BFLLO, 0xFFFF, 0); 
    482488        SPEX(boardflags_hi, SSB_SPROM8_BFLHI, 0xFFFF, 0); 
     489        SPEX(boardflags2_lo, SSB_SPROM8_BFL2LO, 0xFFFF, 0); 
     490        SPEX(boardflags2_hi, SSB_SPROM8_BFL2HI, 0xFFFF, 0); 
    483491        SPEX(ant_available_a, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_A, 
    484492             SSB_SPROM8_ANTAVAIL_A_SHIFT); 
    485493        SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG, 
    static void sprom_extract_r8(struct ssb_ 
    490498        SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0); 
    491499        SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A, 
    492500             SSB_SPROM8_ITSSI_A_SHIFT); 
     501        SPEX(maxpwr_ah, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AH_MASK, 0); 
     502        SPEX(maxpwr_al, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AL_MASK, 
     503             SSB_SPROM8_MAXP_AL_SHIFT); 
    493504        SPEX(gpio0, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P0, 0); 
    494505        SPEX(gpio1, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P1, 
    495506             SSB_SPROM8_GPIOA_P1_SHIFT); 
    496507        SPEX(gpio2, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P2, 0); 
    497508        SPEX(gpio3, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P3, 
    498509             SSB_SPROM8_GPIOB_P3_SHIFT); 
     510        SPEX(tri2g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI2G, 0); 
     511        SPEX(tri5g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI5G, 
     512             SSB_SPROM8_TRI5G_SHIFT); 
     513        SPEX(tri5gl, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GL, 0); 
     514        SPEX(tri5gh, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GH, 
     515             SSB_SPROM8_TRI5GH_SHIFT); 
     516        SPEX(rxpo2g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO2G, 0); 
     517        SPEX(rxpo5g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO5G, 
     518             SSB_SPROM8_RXPO5G_SHIFT); 
     519        SPEX(rssismf2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMF2G, 0); 
     520        SPEX(rssismc2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMC2G, 
     521             SSB_SPROM8_RSSISMC2G_SHIFT); 
     522        SPEX(rssisav2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISAV2G, 
     523             SSB_SPROM8_RSSISAV2G_SHIFT); 
     524        SPEX(bxa2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_BXA2G, 
     525             SSB_SPROM8_BXA2G_SHIFT); 
     526        SPEX(rssismf5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMF5G, 0); 
     527        SPEX(rssismc5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMC5G, 
     528             SSB_SPROM8_RSSISMC5G_SHIFT); 
     529        SPEX(rssisav5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISAV5G, 
     530             SSB_SPROM8_RSSISAV5G_SHIFT); 
     531        SPEX(bxa5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_BXA5G, 
     532             SSB_SPROM8_BXA5G_SHIFT); 
     533        SPEX(pa0b0, SSB_SPROM8_PA0B0, 0xFFFF, 0); 
     534        SPEX(pa0b1, SSB_SPROM8_PA0B1, 0xFFFF, 0); 
     535        SPEX(pa0b2, SSB_SPROM8_PA0B2, 0xFFFF, 0); 
     536        SPEX(pa1b0, SSB_SPROM8_PA1B0, 0xFFFF, 0); 
     537        SPEX(pa1b1, SSB_SPROM8_PA1B1, 0xFFFF, 0); 
     538        SPEX(pa1b2, SSB_SPROM8_PA1B2, 0xFFFF, 0); 
     539        SPEX(pa1lob0, SSB_SPROM8_PA1LOB0, 0xFFFF, 0); 
     540        SPEX(pa1lob1, SSB_SPROM8_PA1LOB1, 0xFFFF, 0); 
     541        SPEX(pa1lob2, SSB_SPROM8_PA1LOB2, 0xFFFF, 0); 
     542        SPEX(pa1hib0, SSB_SPROM8_PA1HIB0, 0xFFFF, 0); 
     543        SPEX(pa1hib1, SSB_SPROM8_PA1HIB1, 0xFFFF, 0); 
     544        SPEX(pa1hib2, SSB_SPROM8_PA1HIB2, 0xFFFF, 0); 
     545        SPEX(cck2gpo, SSB_SPROM8_CCK2GPO, 0xFFFF, 0); 
     546        SPEX32(ofdm2gpo, SSB_SPROM8_OFDM2GPO, 0xFFFFFFFF, 0); 
     547        SPEX32(ofdm5glpo, SSB_SPROM8_OFDM5GLPO, 0xFFFFFFFF, 0); 
     548        SPEX32(ofdm5gpo, SSB_SPROM8_OFDM5GPO, 0xFFFFFFFF, 0); 
     549        SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, 0xFFFFFFFF, 0); 
    499550 
    500551        /* Extract the antenna gain values. */ 
    501552        SPEX(antenna_gain.ghz24.a0, SSB_SPROM8_AGAIN01, 
    static int sprom_extract(struct ssb_bus  
    549600                        ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    550601                                   "  revision %d detected. Will extract" 
    551602                                   " v1\n", out->revision); 
     603                        out->revision = 1; 
    552604                        sprom_extract_r123(out, in); 
    553605                } 
    554606        } 
    static int ssb_pci_sprom_get(struct ssb_ 
    568620        int err = -ENOMEM; 
    569621        u16 *buf; 
    570622 
     623        if (!ssb_is_sprom_available(bus)) { 
     624                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
     625                return -ENODEV; 
     626        } 
     627 
     628        bus->sprom_offset = (bus->chipco.dev->id.revision < 31) ? 
     629                SSB_SPROM_BASE1 : SSB_SPROM_BASE31; 
     630 
    571631        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
    572632        if (!buf) 
    573633                goto out; 
  • drivers/ssb/pcmcia.c

    a b static int ssb_pcmcia_sprom_write_all(st 
    583583                        ssb_printk("."); 
    584584                err = ssb_pcmcia_sprom_write(bus, i, sprom[i]); 
    585585                if (err) { 
    586                         ssb_printk("\n" KERN_NOTICE PFX 
     586                        ssb_printk(KERN_NOTICE PFX 
    587587                                   "Failed to write to SPROM.\n"); 
    588588                        failed = 1; 
    589589                        break; 
    static int ssb_pcmcia_sprom_write_all(st 
    591591        } 
    592592        err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS); 
    593593        if (err) { 
    594                 ssb_printk("\n" KERN_NOTICE PFX 
     594                ssb_printk(KERN_NOTICE PFX 
    595595                           "Could not disable SPROM write access.\n"); 
    596596                failed = 1; 
    597597        } 
    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) 
    622623{ 
    623         tuple_t tuple; 
    624         int res; 
    625         unsigned char buf[32]; 
     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) 
     639{ 
     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                                       "pa tpl size"); 
    683                         sprom->pa0b0 = tuple.TupleData[1] | 
    684                                  ((u16)tuple.TupleData[2] << 8); 
    685                         sprom->pa0b1 = tuple.TupleData[3] | 
    686                                  ((u16)tuple.TupleData[4] << 8); 
    687                         sprom->pa0b2 = tuple.TupleData[5] | 
    688                                  ((u16)tuple.TupleData[6] << 8); 
    689                         sprom->itssi_a = tuple.TupleData[7]; 
    690                         sprom->itssi_bg = tuple.TupleData[7]; 
    691                         sprom->maxpwr_a = tuple.TupleData[8]; 
    692                         sprom->maxpwr_bg = tuple.TupleData[8]; 
    693                         break; 
    694                 case SSB_PCMCIA_CIS_OEMNAME: 
    695                         /* We ignore this. */ 
    696                         break; 
    697                 case SSB_PCMCIA_CIS_CCODE: 
    698                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    699                                       "ccode tpl size"); 
    700                         sprom->country_code = tuple.TupleData[1]; 
    701                         break; 
    702                 case SSB_PCMCIA_CIS_ANTENNA: 
    703                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    704                                       "ant tpl size"); 
    705                         sprom->ant_available_a = tuple.TupleData[1]; 
    706                         sprom->ant_available_bg = tuple.TupleData[1]; 
    707                         break; 
    708                 case SSB_PCMCIA_CIS_ANTGAIN: 
    709                         GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
    710                                       "antg tpl size"); 
    711                         sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1]; 
    712                         sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1]; 
    713                         sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1]; 
    714                         sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1]; 
    715                         sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1]; 
    716                         sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1]; 
    717                         sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1]; 
    718                         sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1]; 
    719                         break; 
    720                 case SSB_PCMCIA_CIS_BFLAGS: 
    721                         GOTO_ERROR_ON(tuple.TupleDataLen != 3, 
    722                                       "bfl tpl size"); 
    723                         sprom->boardflags_lo = tuple.TupleData[1] | 
    724                                          ((u16)tuple.TupleData[2] << 8); 
    725                         break; 
    726                 case SSB_PCMCIA_CIS_LEDS: 
    727                         GOTO_ERROR_ON(tuple.TupleDataLen != 5, 
    728                                       "leds tpl size"); 
    729                         sprom->gpio0 = tuple.TupleData[1]; 
    730                         sprom->gpio1 = tuple.TupleData[2]; 
    731                         sprom->gpio2 = tuple.TupleData[3]; 
    732                         sprom->gpio3 = tuple.TupleData[4]; 
    733                         break; 
    734                 } 
    735                 res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 
    736                 if (res == -ENOSPC) 
    737                         break; 
    738                 GOTO_ERROR_ON(res != 0, "VEN next tpl"); 
    739                 res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
    740                 GOTO_ERROR_ON(res != 0, "VEN next tpl data"); 
    741         } 
     747        res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, 
     748                                ssb_pcmcia_do_get_invariants, sprom); 
     749        if ((res == 0) || (res == -ENOSPC)) 
     750                return 0; 
    742751 
    743         return 0; 
    744 error: 
    745752        ssb_printk(KERN_ERR PFX 
    746                    "PCMCIA: Failed to fetch device invariants: %s\n", 
    747                    error_description); 
     753                        "PCMCIA: Failed to fetch device invariants\n"); 
    748754        return -ENODEV; 
    749755} 
    750756 
  • include/linux/ssb/ssb.h

    a b struct ssb_sprom { 
    2727        u8 et1mdcport;          /* MDIO for enet1 */ 
    2828        u8 board_rev;           /* Board revision number from SPROM. */ 
    2929        u8 country_code;        /* Country Code */ 
    30         u8 ant_available_a;     /* A-PHY antenna available bits (up to 4) */ 
    31         u8 ant_available_bg;    /* B/G-PHY antenna available bits (up to 4) */ 
     30        u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
     31        u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
    3232        u16 pa0b0; 
    3333        u16 pa0b1; 
    3434        u16 pa0b2; 
    3535        u16 pa1b0; 
    3636        u16 pa1b1; 
    3737        u16 pa1b2; 
     38        u16 pa1lob0; 
     39        u16 pa1lob1; 
     40        u16 pa1lob2; 
     41        u16 pa1hib0; 
     42        u16 pa1hib1; 
     43        u16 pa1hib2; 
    3844        u8 gpio0;               /* GPIO pin 0 */ 
    3945        u8 gpio1;               /* GPIO pin 1 */ 
    4046        u8 gpio2;               /* GPIO pin 2 */ 
    4147        u8 gpio3;               /* GPIO pin 3 */ 
    42         u16 maxpwr_a;           /* A-PHY Amplifier Max Power (in dBm Q5.2) */ 
    43         u16 maxpwr_bg;          /* B/G-PHY Amplifier Max Power (in dBm Q5.2) */ 
     48        u16 maxpwr_bg;          /* 2.4GHz Amplifier Max Power (in dBm Q5.2) */ 
     49        u16 maxpwr_al;          /* 5.2GHz Amplifier Max Power (in dBm Q5.2) */ 
     50        u16 maxpwr_a;           /* 5.3GHz Amplifier Max Power (in dBm Q5.2) */ 
     51        u16 maxpwr_ah;          /* 5.8GHz Amplifier Max Power (in dBm Q5.2) */ 
    4452        u8 itssi_a;             /* Idle TSSI Target for A-PHY */ 
    4553        u8 itssi_bg;            /* Idle TSSI Target for B/G-PHY */ 
    46         u16 boardflags_lo;      /* Boardflags (low 16 bits) */ 
    47         u16 boardflags_hi;      /* Boardflags (high 16 bits) */ 
     54        u8 tri2g;               /* 2.4GHz TX isolation */ 
     55        u8 tri5gl;              /* 5.2GHz TX isolation */ 
     56        u8 tri5g;               /* 5.3GHz TX isolation */ 
     57        u8 tri5gh;              /* 5.8GHz TX isolation */ 
     58        u8 rxpo2g;              /* 2GHz RX power offset */ 
     59        u8 rxpo5g;              /* 5GHz RX power offset */ 
     60        u8 rssisav2g;           /* 2GHz RSSI params */ 
     61        u8 rssismc2g; 
     62        u8 rssismf2g; 
     63        u8 bxa2g;               /* 2GHz BX arch */ 
     64        u8 rssisav5g;           /* 5GHz RSSI params */ 
     65        u8 rssismc5g; 
     66        u8 rssismf5g; 
     67        u8 bxa5g;               /* 5GHz BX arch */ 
     68        u16 cck2gpo;            /* CCK power offset */ 
     69        u32 ofdm2gpo;           /* 2.4GHz OFDM power offset */ 
     70        u32 ofdm5glpo;          /* 5.2GHz OFDM power offset */ 
     71        u32 ofdm5gpo;           /* 5.3GHz OFDM power offset */ 
     72        u32 ofdm5ghpo;          /* 5.8GHz OFDM power offset */ 
     73        u16 boardflags_lo;      /* Board flags (bits 0-15) */ 
     74        u16 boardflags_hi;      /* Board flags (bits 16-31) */ 
     75        u16 boardflags2_lo;     /* Board flags (bits 32-47) */ 
     76        u16 boardflags2_hi;     /* Board flags (bits 48-63) */ 
     77        /* TODO store board flags in a single u64 */ 
    4878 
    4979        /* Antenna gain values for up to 4 antennas 
    5080         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    struct ssb_sprom { 
    5888                } ghz5;         /* 5GHz band */ 
    5989        } antenna_gain; 
    6090 
    61         /* TODO - add any parameters needed from rev 2, 3, or 4 SPROMs */ 
     91        /* TODO - add any parameters needed from rev 2, 3, 4, 5 or 8 SPROMs */ 
    6292}; 
    6393 
    6494/* Information about the PCB the circuitry is soldered on. */ 
    enum ssb_bustype { 
    208238        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */ 
    209239        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
    210240        SSB_BUSTYPE_PCMCIA,     /* SSB is connected to PCMCIA bus */ 
     241        SSB_BUSTYPE_SDIO,       /* SSB is connected to SDIO bus */ 
    211242}; 
    212243 
    213244/* board_vendor */ 
    struct ssb_bus { 
    238269 
    239270        const struct ssb_bus_ops *ops; 
    240271 
    241         /* The core in the basic address register window. (PCI bus only) */ 
     272        /* The core currently mapped into the MMIO window. 
     273         * Not valid on all host-buses. So don't use outside of SSB. */ 
    242274        struct ssb_device *mapped_device; 
    243         /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
    244         u8 mapped_pcmcia_seg; 
     275        union { 
     276                /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
     277                u8 mapped_pcmcia_seg; 
     278                /* Current SSB base address window for SDIO. */ 
     279                u32 sdio_sbaddr; 
     280        }; 
    245281        /* Lock for core and segment switching. 
    246282         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    247283        spinlock_t bar_lock; 
    248284 
    249         /* The bus this backplane is running on. */ 
     285        /* The host-bus this backplane is running on. */ 
    250286        enum ssb_bustype bustype; 
    251         /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
    252         struct pci_dev *host_pci; 
    253         /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
    254         struct pcmcia_device *host_pcmcia; 
     287        /* Pointers to the host-bus. Check bustype before using any of these pointers. */ 
     288        union { 
     289                /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
     290                struct pci_dev *host_pci; 
     291                /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
     292                struct pcmcia_device *host_pcmcia; 
     293                /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
     294                struct sdio_func *host_sdio; 
     295        }; 
     296 
     297        /* See enum ssb_quirks */ 
     298        unsigned int quirks; 
    255299 
    256300#ifdef CONFIG_SSB_SPROM 
    257301        /* Mutex to protect the SPROM writing. */ 
    struct ssb_bus { 
    261305        /* ID information about the Chip. */ 
    262306        u16 chip_id; 
    263307        u16 chip_rev; 
     308        u16 sprom_offset; 
    264309        u16 sprom_size;         /* number of words in sprom */ 
    265310        u8 chip_package; 
    266311 
    struct ssb_bus { 
    306351#endif /* DEBUG */ 
    307352}; 
    308353 
     354enum ssb_quirks { 
     355        /* SDIO connected card requires performing a read after writing a 32-bit value */ 
     356        SSB_QUIRK_SDIO_READ_AFTER_WRITE32       = (1 << 0), 
     357}; 
     358 
    309359/* The initialization-invariants. */ 
    310360struct ssb_init_invariants { 
    311361        /* Versioning information about the PCB. */ 
    extern int ssb_bus_pcmciabus_register(st 
    336386                                      struct pcmcia_device *pcmcia_dev, 
    337387                                      unsigned long baseaddr); 
    338388#endif /* CONFIG_SSB_PCMCIAHOST */ 
     389#ifdef CONFIG_SSB_SDIOHOST 
     390extern int ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     391                                    struct sdio_func *sdio_func, 
     392                                    unsigned int quirks); 
     393#endif /* CONFIG_SSB_SDIOHOST */ 
     394 
    339395 
    340396extern void ssb_bus_unregister(struct ssb_bus *bus); 
    341397 
     398/* Does the device have an SPROM? */ 
     399extern bool ssb_is_sprom_available(struct ssb_bus *bus); 
     400 
    342401/* Set a fallback SPROM. 
    343402 * See kdoc at the function definition for complete documentation. */ 
    344403extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
  • include/linux/ssb/ssb_driver_chipcommon.h

    a b  
    5353#define  SSB_CHIPCO_CAP_64BIT           0x08000000      /* 64-bit Backplane */ 
    5454#define  SSB_CHIPCO_CAP_PMU             0x10000000      /* PMU available (rev >= 20) */ 
    5555#define  SSB_CHIPCO_CAP_ECI             0x20000000      /* ECI available (rev >= 20) */ 
     56#define  SSB_CHIPCO_CAP_SPROM           0x40000000      /* SPROM present */ 
    5657#define SSB_CHIPCO_CORECTL              0x0008 
    5758#define  SSB_CHIPCO_CORECTL_UARTCLK0    0x00000001      /* Drive UART with internal clock */ 
    5859#define  SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */ 
     
    385386 
    386387 
    387388/** Chip specific Chip-Status register contents. */ 
     389#define SSB_CHIPCO_CHST_4322_SPROM_EXISTS       0x00000040 /* SPROM present */ 
    388390#define SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL      0x00000003 
    389391#define SSB_CHIPCO_CHST_4325_DEFCIS_SEL         0 /* OTP is powered up, use def. CIS, no SPROM */ 
    390392#define SSB_CHIPCO_CHST_4325_SPROM_SEL          1 /* OTP is powered up, SPROM is present */ 
     
    398400#define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT   4 
    399401#define SSB_CHIPCO_CHST_4325_PMUTOP_2B          0x00000200 /* 1 for 2b, 0 for to 2a */ 
    400402 
     403/** Macros to determine SPROM presence based on Chip-Status register. */ 
     404#define SSB_CHIPCO_CHST_4312_SPROM_PRESENT(status) \ 
     405        ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     406                SSB_CHIPCO_CHST_4325_OTP_SEL) 
     407#define SSB_CHIPCO_CHST_4322_SPROM_PRESENT(status) \ 
     408        (status & SSB_CHIPCO_CHST_4322_SPROM_EXISTS) 
     409#define SSB_CHIPCO_CHST_4325_SPROM_PRESENT(status) \ 
     410        (((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     411                SSB_CHIPCO_CHST_4325_DEFCIS_SEL) && \ 
     412         ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     413                SSB_CHIPCO_CHST_4325_OTP_SEL)) 
     414 
    401415 
    402416 
    403417/** Clockcontrol masks and values **/ 
    struct ssb_chipcommon_pmu { 
    564578struct ssb_chipcommon { 
    565579        struct ssb_device *dev; 
    566580        u32 capabilities; 
     581        u32 status; 
    567582        /* Fast Powerup Delay constant */ 
    568583        u16 fast_pwrup_delay; 
    569584        struct ssb_chipcommon_pmu pmu; 
    extern int ssb_chipco_serial_init(struct 
    629644/* PMU support */ 
    630645extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
    631646 
     647enum ssb_pmu_ldo_volt_id { 
     648        LDO_PAREF = 0, 
     649        LDO_VOLT1, 
     650        LDO_VOLT2, 
     651        LDO_VOLT3, 
     652}; 
     653 
     654void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc, 
     655                             enum ssb_pmu_ldo_volt_id id, u32 voltage); 
     656void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on); 
    632657 
    633658#endif /* LINUX_SSB_CHIPCO_H_ */ 
  • include/linux/ssb/ssb_regs.h

    a b  
    162162 
    163163/* SPROM shadow area. If not otherwise noted, fields are 
    164164 * two bytes wide. Note that the SPROM can _only_ be read 
    165  * in two-byte quantinies. 
     165 * in two-byte quantities. 
    166166 */ 
    167167#define SSB_SPROMSIZE_WORDS             64 
    168168#define SSB_SPROMSIZE_BYTES             (SSB_SPROMSIZE_WORDS * sizeof(u16)) 
     
    170170#define SSB_SPROMSIZE_WORDS_R4          220 
    171171#define SSB_SPROMSIZE_BYTES_R123        (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16)) 
    172172#define SSB_SPROMSIZE_BYTES_R4          (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16)) 
    173 #define SSB_SPROM_BASE                  0x1000 
    174 #define SSB_SPROM_REVISION              0x107E 
     173#define SSB_SPROM_BASE1                 0x1000 
     174#define SSB_SPROM_BASE31                0x0800 
     175#define SSB_SPROM_REVISION              0x007E 
    175176#define  SSB_SPROM_REVISION_REV         0x00FF  /* SPROM Revision number */ 
    176177#define  SSB_SPROM_REVISION_CRC         0xFF00  /* SPROM CRC8 value */ 
    177178#define  SSB_SPROM_REVISION_CRC_SHIFT   8 
    178179 
    179180/* SPROM Revision 1 */ 
    180 #define SSB_SPROM1_SPID                 0x1004  /* Subsystem Product ID for PCI */ 
    181 #define SSB_SPROM1_SVID                 0x1006  /* Subsystem Vendor ID for PCI */ 
    182 #define SSB_SPROM1_PID                  0x1008  /* Product ID for PCI */ 
    183 #define SSB_SPROM1_IL0MAC               0x1048  /* 6 bytes MAC address for 802.11b/g */ 
    184 #define SSB_SPROM1_ET0MAC               0x104E  /* 6 bytes MAC address for Ethernet */ 
    185 #define SSB_SPROM1_ET1MAC               0x1054  /* 6 bytes MAC address for 802.11a */ 
    186 #define SSB_SPROM1_ETHPHY               0x105A  /* Ethernet PHY settings */ 
     181#define SSB_SPROM1_SPID                 0x0004  /* Subsystem Product ID for PCI */ 
     182#define SSB_SPROM1_SVID                 0x0006  /* Subsystem Vendor ID for PCI */ 
     183#define SSB_SPROM1_PID                  0x0008  /* Product ID for PCI */ 
     184#define SSB_SPROM1_IL0MAC               0x0048  /* 6 bytes MAC address for 802.11b/g */ 
     185#define SSB_SPROM1_ET0MAC               0x004E  /* 6 bytes MAC address for Ethernet */ 
     186#define SSB_SPROM1_ET1MAC               0x0054  /* 6 bytes MAC address for 802.11a */ 
     187#define SSB_SPROM1_ETHPHY               0x005A  /* Ethernet PHY settings */ 
    187188#define  SSB_SPROM1_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */ 
    188189#define  SSB_SPROM1_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */ 
    189190#define  SSB_SPROM1_ETHPHY_ET1A_SHIFT   5 
    190191#define  SSB_SPROM1_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */ 
    191192#define  SSB_SPROM1_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */ 
    192 #define SSB_SPROM1_BINF                 0x105C  /* Board info */ 
     193#define SSB_SPROM1_BINF                 0x005C  /* Board info */ 
    193194#define  SSB_SPROM1_BINF_BREV           0x00FF  /* Board Revision */ 
    194195#define  SSB_SPROM1_BINF_CCODE          0x0F00  /* Country Code */ 
    195196#define  SSB_SPROM1_BINF_CCODE_SHIFT    8 
     
    197198#define  SSB_SPROM1_BINF_ANTBG_SHIFT    12 
    198199#define  SSB_SPROM1_BINF_ANTA           0xC000  /* Available A-PHY antennas */ 
    199200#define  SSB_SPROM1_BINF_ANTA_SHIFT     14 
    200 #define SSB_SPROM1_PA0B0                0x105E 
    201 #define SSB_SPROM1_PA0B1                0x1060 
    202 #define SSB_SPROM1_PA0B2                0x1062 
    203 #define SSB_SPROM1_GPIOA                0x1064  /* General Purpose IO pins 0 and 1 */ 
     201#define SSB_SPROM1_PA0B0                0x005E 
     202#define SSB_SPROM1_PA0B1                0x0060 
     203#define SSB_SPROM1_PA0B2                0x0062 
     204#define SSB_SPROM1_GPIOA                0x0064  /* General Purpose IO pins 0 and 1 */ 
    204205#define  SSB_SPROM1_GPIOA_P0            0x00FF  /* Pin 0 */ 
    205206#define  SSB_SPROM1_GPIOA_P1            0xFF00  /* Pin 1 */ 
    206207#define  SSB_SPROM1_GPIOA_P1_SHIFT      8 
    207 #define SSB_SPROM1_GPIOB                0x1066  /* General Purpuse IO pins 2 and 3 */ 
     208#define SSB_SPROM1_GPIOB                0x0066  /* General Purpuse IO pins 2 and 3 */ 
    208209#define  SSB_SPROM1_GPIOB_P2            0x00FF  /* Pin 2 */ 
    209210#define  SSB_SPROM1_GPIOB_P3            0xFF00  /* Pin 3 */ 
    210211#define  SSB_SPROM1_GPIOB_P3_SHIFT      8 
    211 #define SSB_SPROM1_MAXPWR               0x1068  /* Power Amplifier Max Power */ 
     212#define SSB_SPROM1_MAXPWR               0x0068  /* Power Amplifier Max Power */ 
    212213#define  SSB_SPROM1_MAXPWR_BG           0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */ 
    213214#define  SSB_SPROM1_MAXPWR_A            0xFF00  /* A-PHY (in dBm Q5.2) */ 
    214215#define  SSB_SPROM1_MAXPWR_A_SHIFT      8 
    215 #define SSB_SPROM1_PA1B0                0x106A 
    216 #define SSB_SPROM1_PA1B1                0x106C 
    217 #define SSB_SPROM1_PA1B2                0x106E 
    218 #define SSB_SPROM1_ITSSI                0x1070  /* Idle TSSI Target */ 
     216#define SSB_SPROM1_PA1B0                0x006A 
     217#define SSB_SPROM1_PA1B1                0x006C 
     218#define SSB_SPROM1_PA1B2                0x006E 
     219#define SSB_SPROM1_ITSSI                0x0070  /* Idle TSSI Target */ 
    219220#define  SSB_SPROM1_ITSSI_BG            0x00FF  /* B-PHY and G-PHY*/ 
    220221#define  SSB_SPROM1_ITSSI_A             0xFF00  /* A-PHY */ 
    221222#define  SSB_SPROM1_ITSSI_A_SHIFT       8 
    222 #define SSB_SPROM1_BFLLO                0x1072  /* Boardflags (low 16 bits) */ 
    223 #define SSB_SPROM1_AGAIN                0x1074  /* Antenna Gain (in dBm Q5.2) */ 
     223#define SSB_SPROM1_BFLLO                0x0072  /* Boardflags (low 16 bits) */ 
     224#define SSB_SPROM1_AGAIN                0x0074  /* Antenna Gain (in dBm Q5.2) */ 
    224225#define  SSB_SPROM1_AGAIN_BG            0x00FF  /* B-PHY and G-PHY */ 
    225226#define  SSB_SPROM1_AGAIN_BG_SHIFT      0 
    226227#define  SSB_SPROM1_AGAIN_A             0xFF00  /* A-PHY */ 
    227228#define  SSB_SPROM1_AGAIN_A_SHIFT       8 
    228229 
    229230/* SPROM Revision 2 (inherits from rev 1) */ 
    230 #define SSB_SPROM2_BFLHI                0x1038  /* Boardflags (high 16 bits) */ 
    231 #define SSB_SPROM2_MAXP_A               0x103A  /* A-PHY Max Power */ 
     231#define SSB_SPROM2_BFLHI                0x0038  /* Boardflags (high 16 bits) */ 
     232#define SSB_SPROM2_MAXP_A               0x003A  /* A-PHY Max Power */ 
    232233#define  SSB_SPROM2_MAXP_A_HI           0x00FF  /* Max Power High */ 
    233234#define  SSB_SPROM2_MAXP_A_LO           0xFF00  /* Max Power Low */ 
    234235#define  SSB_SPROM2_MAXP_A_LO_SHIFT     8 
    235 #define SSB_SPROM2_PA1LOB0              0x103C  /* A-PHY PowerAmplifier Low Settings */ 
    236 #define SSB_SPROM2_PA1LOB1              0x103E  /* A-PHY PowerAmplifier Low Settings */ 
    237 #define SSB_SPROM2_PA1LOB2              0x1040  /* A-PHY PowerAmplifier Low Settings */ 
    238 #define SSB_SPROM2_PA1HIB0              0x1042  /* A-PHY PowerAmplifier High Settings */ 
    239 #define SSB_SPROM2_PA1HIB1              0x1044  /* A-PHY PowerAmplifier High Settings */ 
    240 #define SSB_SPROM2_PA1HIB2              0x1046  /* A-PHY PowerAmplifier High Settings */ 
    241 #define SSB_SPROM2_OPO                  0x1078  /* OFDM Power Offset from CCK Level */ 
     236#define SSB_SPROM2_PA1LOB0              0x003C  /* A-PHY PowerAmplifier Low Settings */ 
     237#define SSB_SPROM2_PA1LOB1              0x003E  /* A-PHY PowerAmplifier Low Settings */ 
     238#define SSB_SPROM2_PA1LOB2              0x0040  /* A-PHY PowerAmplifier Low Settings */ 
     239#define SSB_SPROM2_PA1HIB0              0x0042  /* A-PHY PowerAmplifier High Settings */ 
     240#define SSB_SPROM2_PA1HIB1              0x0044  /* A-PHY PowerAmplifier High Settings */ 
     241#define SSB_SPROM2_PA1HIB2              0x0046  /* A-PHY PowerAmplifier High Settings */ 
     242#define SSB_SPROM2_OPO                  0x0078  /* OFDM Power Offset from CCK Level */ 
    242243#define  SSB_SPROM2_OPO_VALUE           0x00FF 
    243244#define  SSB_SPROM2_OPO_UNUSED          0xFF00 
    244 #define SSB_SPROM2_CCODE                0x107C  /* Two char Country Code */ 
     245#define SSB_SPROM2_CCODE                0x007C  /* Two char Country Code */ 
    245246 
    246247/* SPROM Revision 3 (inherits most data from rev 2) */ 
    247 #define SSB_SPROM3_IL0MAC               0x104A  /* 6 bytes MAC address for 802.11b/g */ 
    248 #define SSB_SPROM3_OFDMAPO              0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
    249 #define SSB_SPROM3_OFDMALPO             0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
    250 #define SSB_SPROM3_OFDMAHPO             0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
    251 #define SSB_SPROM3_GPIOLDC              0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
     248#define SSB_SPROM3_OFDMAPO              0x002C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
     249#define SSB_SPROM3_OFDMALPO             0x0030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
     250#define SSB_SPROM3_OFDMAHPO             0x0034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
     251#define SSB_SPROM3_GPIOLDC              0x0042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
    252252#define  SSB_SPROM3_GPIOLDC_OFF         0x0000FF00      /* Off Count */ 
    253253#define  SSB_SPROM3_GPIOLDC_OFF_SHIFT   8 
    254254#define  SSB_SPROM3_GPIOLDC_ON          0x00FF0000      /* On Count */ 
    255255#define  SSB_SPROM3_GPIOLDC_ON_SHIFT    16 
    256 #define SSB_SPROM3_CCKPO                0x1078  /* CCK Power Offset */ 
     256#define SSB_SPROM3_IL0MAC               0x004A  /* 6 bytes MAC address for 802.11b/g */ 
     257#define SSB_SPROM3_CCKPO                0x0078  /* CCK Power Offset */ 
    257258#define  SSB_SPROM3_CCKPO_1M            0x000F  /* 1M Rate PO */ 
    258259#define  SSB_SPROM3_CCKPO_2M            0x00F0  /* 2M Rate PO */ 
    259260#define  SSB_SPROM3_CCKPO_2M_SHIFT      4 
     
    264265#define  SSB_SPROM3_OFDMGPO             0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */ 
    265266 
    266267/* SPROM Revision 4 */ 
    267 #define SSB_SPROM4_IL0MAC               0x104C  /* 6 byte MAC address for a/b/g/n */ 
    268 #define SSB_SPROM4_ETHPHY               0x105A  /* Ethernet PHY settings ?? */ 
     268#define SSB_SPROM4_BFLLO                0x0044  /* Boardflags (low 16 bits) */ 
     269#define SSB_SPROM4_BFLHI                0x0046  /* Board Flags Hi */ 
     270#define SSB_SPROM4_IL0MAC               0x004C  /* 6 byte MAC address for a/b/g/n */ 
     271#define SSB_SPROM4_CCODE                0x0052  /* Country Code (2 bytes) */ 
     272#define SSB_SPROM4_GPIOA                0x0056  /* Gen. Purpose IO # 0 and 1 */ 
     273#define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */ 
     274#define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */ 
     275#define  SSB_SPROM4_GPIOA_P1_SHIFT      8 
     276#define SSB_SPROM4_GPIOB                0x0058  /* Gen. Purpose IO # 2 and 3 */ 
     277#define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */ 
     278#define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */ 
     279#define  SSB_SPROM4_GPIOB_P3_SHIFT      8 
     280#define SSB_SPROM4_ETHPHY               0x005A  /* Ethernet PHY settings ?? */ 
    269281#define  SSB_SPROM4_ETHPHY_ET0A         0x001F  /* MII Address for enet0 */ 
    270282#define  SSB_SPROM4_ETHPHY_ET1A         0x03E0  /* MII Address for enet1 */ 
    271283#define  SSB_SPROM4_ETHPHY_ET1A_SHIFT   5 
    272284#define  SSB_SPROM4_ETHPHY_ET0M         (1<<14) /* MDIO for enet0 */ 
    273285#define  SSB_SPROM4_ETHPHY_ET1M         (1<<15) /* MDIO for enet1 */ 
    274 #define SSB_SPROM4_CCODE                0x1052  /* Country Code (2 bytes) */ 
    275 #define SSB_SPROM4_ANTAVAIL             0x105D  /* Antenna available bitfields */ 
    276 #define SSB_SPROM4_ANTAVAIL_A           0x00FF  /* A-PHY bitfield */ 
    277 #define SSB_SPROM4_ANTAVAIL_A_SHIFT     0 
    278 #define SSB_SPROM4_ANTAVAIL_BG          0xFF00  /* B-PHY and G-PHY bitfield */ 
    279 #define SSB_SPROM4_ANTAVAIL_BG_SHIFT    8 
    280 #define SSB_SPROM4_BFLLO                0x1044  /* Boardflags (low 16 bits) */ 
    281 #define SSB_SPROM4_AGAIN01              0x105E  /* Antenna Gain (in dBm Q5.2) */ 
     286#define SSB_SPROM4_ANTAVAIL             0x005D  /* Antenna available bitfields */ 
     287#define  SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */ 
     288#define  SSB_SPROM4_ANTAVAIL_A_SHIFT    0 
     289#define  SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */ 
     290#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT   8 
     291#define SSB_SPROM4_AGAIN01              0x005E  /* Antenna Gain (in dBm Q5.2) */ 
    282292#define  SSB_SPROM4_AGAIN0              0x00FF  /* Antenna 0 */ 
    283293#define  SSB_SPROM4_AGAIN0_SHIFT        0 
    284294#define  SSB_SPROM4_AGAIN1              0xFF00  /* Antenna 1 */ 
    285295#define  SSB_SPROM4_AGAIN1_SHIFT        8 
    286 #define SSB_SPROM4_AGAIN23              0x1060 
     296#define SSB_SPROM4_AGAIN23              0x0060 
    287297#define  SSB_SPROM4_AGAIN2              0x00FF  /* Antenna 2 */ 
    288298#define  SSB_SPROM4_AGAIN2_SHIFT        0 
    289299#define  SSB_SPROM4_AGAIN3              0xFF00  /* Antenna 3 */ 
    290300#define  SSB_SPROM4_AGAIN3_SHIFT        8 
    291 #define SSB_SPROM4_BFLHI                0x1046  /* Board Flags Hi */ 
    292 #define SSB_SPROM4_MAXP_BG              0x1080  /* Max Power BG in path 1 */ 
     301#define SSB_SPROM4_MAXP_BG              0x0080  /* Max Power BG in path 1 */ 
    293302#define  SSB_SPROM4_MAXP_BG_MASK        0x00FF  /* Mask for Max Power BG */ 
    294303#define  SSB_SPROM4_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
    295304#define  SSB_SPROM4_ITSSI_BG_SHIFT      8 
    296 #define SSB_SPROM4_MAXP_A               0x108A  /* Max Power A in path 1 */ 
     305#define SSB_SPROM4_MAXP_A               0x008A  /* Max Power A in path 1 */ 
    297306#define  SSB_SPROM4_MAXP_A_MASK         0x00FF  /* Mask for Max Power A */ 
    298307#define  SSB_SPROM4_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
    299308#define  SSB_SPROM4_ITSSI_A_SHIFT       8 
    300 #define SSB_SPROM4_GPIOA                0x1056  /* Gen. Purpose IO # 0 and 1 */ 
    301 #define  SSB_SPROM4_GPIOA_P0            0x00FF  /* Pin 0 */ 
    302 #define  SSB_SPROM4_GPIOA_P1            0xFF00  /* Pin 1 */ 
    303 #define  SSB_SPROM4_GPIOA_P1_SHIFT      8 
    304 #define SSB_SPROM4_GPIOB                0x1058  /* Gen. Purpose IO # 2 and 3 */ 
    305 #define  SSB_SPROM4_GPIOB_P2            0x00FF  /* Pin 2 */ 
    306 #define  SSB_SPROM4_GPIOB_P3            0xFF00  /* Pin 3 */ 
    307 #define  SSB_SPROM4_GPIOB_P3_SHIFT      8 
    308 #define SSB_SPROM4_PA0B0                0x1082  /* The paXbY locations are */ 
    309 #define SSB_SPROM4_PA0B1                0x1084  /*   only guesses */ 
    310 #define SSB_SPROM4_PA0B2                0x1086 
    311 #define SSB_SPROM4_PA1B0                0x108E 
    312 #define SSB_SPROM4_PA1B1                0x1090 
    313 #define SSB_SPROM4_PA1B2                0x1092 
     309#define SSB_SPROM4_PA0B0                0x0082  /* The paXbY locations are */ 
     310#define SSB_SPROM4_PA0B1                0x0084  /*   only guesses */ 
     311#define SSB_SPROM4_PA0B2                0x0086 
     312#define SSB_SPROM4_PA1B0                0x008E 
     313#define SSB_SPROM4_PA1B1                0x0090 
     314#define SSB_SPROM4_PA1B2                0x0092 
    314315 
    315316/* SPROM Revision 5 (inherits most data from rev 4) */ 
    316 #define SSB_SPROM5_BFLLO                0x104A  /* Boardflags (low 16 bits) */ 
    317 #define SSB_SPROM5_BFLHI                0x104C  /* Board Flags Hi */ 
    318 #define SSB_SPROM5_IL0MAC               0x1052  /* 6 byte MAC address for a/b/g/n */ 
    319 #define SSB_SPROM5_CCODE                0x1044  /* Country Code (2 bytes) */ 
    320 #define SSB_SPROM5_GPIOA                0x1076  /* Gen. Purpose IO # 0 and 1 */ 
     317#define SSB_SPROM5_CCODE                0x0044  /* Country Code (2 bytes) */ 
     318#define SSB_SPROM5_BFLLO                0x004A  /* Boardflags (low 16 bits) */ 
     319#define SSB_SPROM5_BFLHI                0x004C  /* Board Flags Hi */ 
     320#define SSB_SPROM5_IL0MAC               0x0052  /* 6 byte MAC address for a/b/g/n */ 
     321#define SSB_SPROM5_GPIOA                0x0076  /* Gen. Purpose IO # 0 and 1 */ 
    321322#define  SSB_SPROM5_GPIOA_P0            0x00FF  /* Pin 0 */ 
    322323#define  SSB_SPROM5_GPIOA_P1            0xFF00  /* Pin 1 */ 
    323324#define  SSB_SPROM5_GPIOA_P1_SHIFT      8 
    324 #define SSB_SPROM5_GPIOB                0x1078  /* Gen. Purpose IO # 2 and 3 */ 
     325#define SSB_SPROM5_GPIOB                0x0078  /* Gen. Purpose IO # 2 and 3 */ 
    325326#define  SSB_SPROM5_GPIOB_P2            0x00FF  /* Pin 2 */ 
    326327#define  SSB_SPROM5_GPIOB_P3            0xFF00  /* Pin 3 */ 
    327328#define  SSB_SPROM5_GPIOB_P3_SHIFT      8 
    328329 
    329330/* SPROM Revision 8 */ 
    330 #define SSB_SPROM8_BFLLO                0x1084  /* Boardflags (low 16 bits) */ 
    331 #define SSB_SPROM8_BFLHI                0x1086  /* Boardflags Hi */ 
    332 #define SSB_SPROM8_IL0MAC               0x108C  /* 6 byte MAC address */ 
    333 #define SSB_SPROM8_CCODE                0x1092  /* 2 byte country code */ 
    334 #define SSB_SPROM8_ANTAVAIL             0x109C  /* Antenna available bitfields*/ 
    335 #define SSB_SPROM8_ANTAVAIL_A           0xFF00  /* A-PHY bitfield */ 
    336 #define SSB_SPROM8_ANTAVAIL_A_SHIFT     8 
    337 #define SSB_SPROM8_ANTAVAIL_BG          0x00FF  /* B-PHY and G-PHY bitfield */ 
    338 #define SSB_SPROM8_ANTAVAIL_BG_SHIFT    0 
    339 #define SSB_SPROM8_AGAIN01              0x109E  /* Antenna Gain (in dBm Q5.2) */ 
     331#define SSB_SPROM8_BOARDREV             0x0082  /* Board revision */ 
     332#define SSB_SPROM8_BFLLO                0x0084  /* Board flags (bits 0-15) */ 
     333#define SSB_SPROM8_BFLHI                0x0086  /* Board flags (bits 16-31) */ 
     334#define SSB_SPROM8_BFL2LO               0x0088  /* Board flags (bits 32-47) */ 
     335#define SSB_SPROM8_BFL2HI               0x008A  /* Board flags (bits 48-63) */ 
     336#define SSB_SPROM8_IL0MAC               0x008C  /* 6 byte MAC address */ 
     337#define SSB_SPROM8_CCODE                0x0092  /* 2 byte country code */ 
     338#define SSB_SPROM8_GPIOA                0x0096  /*Gen. Purpose IO # 0 and 1 */ 
     339#define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */ 
     340#define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */ 
     341#define  SSB_SPROM8_GPIOA_P1_SHIFT      8 
     342#define SSB_SPROM8_GPIOB                0x0098  /* Gen. Purpose IO # 2 and 3 */ 
     343#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
     344#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
     345#define  SSB_SPROM8_GPIOB_P3_SHIFT      8 
     346#define SSB_SPROM8_ANTAVAIL             0x009C  /* Antenna available bitfields*/ 
     347#define  SSB_SPROM8_ANTAVAIL_A          0xFF00  /* A-PHY bitfield */ 
     348#define  SSB_SPROM8_ANTAVAIL_A_SHIFT    8 
     349#define  SSB_SPROM8_ANTAVAIL_BG         0x00FF  /* B-PHY and G-PHY bitfield */ 
     350#define  SSB_SPROM8_ANTAVAIL_BG_SHIFT   0 
     351#define SSB_SPROM8_AGAIN01              0x009E  /* Antenna Gain (in dBm Q5.2) */ 
    340352#define  SSB_SPROM8_AGAIN0              0x00FF  /* Antenna 0 */ 
    341353#define  SSB_SPROM8_AGAIN0_SHIFT        0 
    342354#define  SSB_SPROM8_AGAIN1              0xFF00  /* Antenna 1 */ 
    343355#define  SSB_SPROM8_AGAIN1_SHIFT        8 
    344 #define SSB_SPROM8_AGAIN23              0x10A0 
     356#define SSB_SPROM8_AGAIN23              0x00A0 
    345357#define  SSB_SPROM8_AGAIN2              0x00FF  /* Antenna 2 */ 
    346358#define  SSB_SPROM8_AGAIN2_SHIFT        0 
    347359#define  SSB_SPROM8_AGAIN3              0xFF00  /* Antenna 3 */ 
    348360#define  SSB_SPROM8_AGAIN3_SHIFT        8 
    349 #define SSB_SPROM8_GPIOA                0x1096  /*Gen. Purpose IO # 0 and 1 */ 
    350 #define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */ 
    351 #define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */ 
    352 #define  SSB_SPROM8_GPIOA_P1_SHIFT      8 
    353 #define SSB_SPROM8_GPIOB                0x1098  /* Gen. Purpose IO # 2 and 3 */ 
    354 #define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
    355 #define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
    356 #define  SSB_SPROM8_GPIOB_P3_SHIFT      8 
    357 #define SSB_SPROM8_MAXP_BG              0x10C0  /* Max Power BG in path 1 */ 
    358 #define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power BG */ 
     361#define SSB_SPROM8_RSSIPARM2G           0x00A4  /* RSSI params for 2GHz */ 
     362#define  SSB_SPROM8_RSSISMF2G           0x000F 
     363#define  SSB_SPROM8_RSSISMC2G           0x00F0 
     364#define  SSB_SPROM8_RSSISMC2G_SHIFT     4 
     365#define  SSB_SPROM8_RSSISAV2G           0x0700 
     366#define  SSB_SPROM8_RSSISAV2G_SHIFT     8 
     367#define  SSB_SPROM8_BXA2G               0x1800 
     368#define  SSB_SPROM8_BXA2G_SHIFT         11 
     369#define SSB_SPROM8_RSSIPARM5G           0x00A6  /* RSSI params for 5GHz */ 
     370#define  SSB_SPROM8_RSSISMF5G           0x000F 
     371#define  SSB_SPROM8_RSSISMC5G           0x00F0 
     372#define  SSB_SPROM8_RSSISMC5G_SHIFT     4 
     373#define  SSB_SPROM8_RSSISAV5G           0x0700 
     374#define  SSB_SPROM8_RSSISAV5G_SHIFT     8 
     375#define  SSB_SPROM8_BXA5G               0x1800 
     376#define  SSB_SPROM8_BXA5G_SHIFT         11 
     377#define SSB_SPROM8_TRI25G               0x00A8  /* TX isolation 2.4&5.3GHz */ 
     378#define  SSB_SPROM8_TRI2G               0x00FF  /* TX isolation 2.4GHz */ 
     379#define  SSB_SPROM8_TRI5G               0xFF00  /* TX isolation 5.3GHz */ 
     380#define  SSB_SPROM8_TRI5G_SHIFT         8 
     381#define SSB_SPROM8_TRI5GHL              0x00AA  /* TX isolation 5.2/5.8GHz */ 
     382#define  SSB_SPROM8_TRI5GL              0x00FF  /* TX isolation 5.2GHz */ 
     383#define  SSB_SPROM8_TRI5GH              0xFF00  /* TX isolation 5.8GHz */ 
     384#define  SSB_SPROM8_TRI5GH_SHIFT        8 
     385#define SSB_SPROM8_RXPO                 0x00AC  /* RX power offsets */ 
     386#define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */ 
     387#define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */ 
     388#define  SSB_SPROM8_RXPO5G_SHIFT        8 
     389#define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */ 
     390#define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */ 
    359391#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
    360392#define  SSB_SPROM8_ITSSI_BG_SHIFT      8 
    361 #define SSB_SPROM8_MAXP_A               0x10C8  /* Max Power A in path 1 */ 
    362 #define  SSB_SPROM8_MAXP_A_MASK         0x00FF  /* Mask for Max Power A */ 
     393#define SSB_SPROM8_PA0B0                0x00C2  /* 2GHz power amp settings */ 
     394#define SSB_SPROM8_PA0B1                0x00C4 
     395#define SSB_SPROM8_PA0B2                0x00C6 
     396#define SSB_SPROM8_MAXP_A               0x00C8  /* Max Power 5.3GHz */ 
     397#define  SSB_SPROM8_MAXP_A_MASK         0x00FF  /* Mask for Max Power 5.3GHz */ 
    363398#define  SSB_SPROM8_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
    364399#define  SSB_SPROM8_ITSSI_A_SHIFT       8 
     400#define SSB_SPROM8_MAXP_AHL             0x00CA  /* Max Power 5.2/5.8GHz */ 
     401#define  SSB_SPROM8_MAXP_AH_MASK        0x00FF  /* Mask for Max Power 5.8GHz */ 
     402#define  SSB_SPROM8_MAXP_AL_MASK        0xFF00  /* Mask for Max Power 5.2GHz */ 
     403#define  SSB_SPROM8_MAXP_AL_SHIFT       8 
     404#define SSB_SPROM8_PA1B0                0x00CC  /* 5.3GHz power amp settings */ 
     405#define SSB_SPROM8_PA1B1                0x00CE 
     406#define SSB_SPROM8_PA1B2                0x00D0 
     407#define SSB_SPROM8_PA1LOB0              0x00D2  /* 5.2GHz power amp settings */ 
     408#define SSB_SPROM8_PA1LOB1              0x00D4 
     409#define SSB_SPROM8_PA1LOB2              0x00D6 
     410#define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */ 
     411#define SSB_SPROM8_PA1HIB1              0x00DA 
     412#define SSB_SPROM8_PA1HIB2              0x00DC 
     413#define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */ 
     414#define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */ 
     415#define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */ 
     416#define SSB_SPROM8_OFDM5GLPO            0x014A  /* 5.2GHz OFDM power offset */ 
     417#define SSB_SPROM8_OFDM5GHPO            0x014E  /* 5.8GHz OFDM power offset */ 
    365418 
    366419/* Values for SSB_SPROM1_BINF_CCODE */ 
    367420enum { 
  • drivers/ssb/scan.c

    a b static u8 chipid_to_nrcores(u16 chipid) 
    162162static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx, 
    163163                       u16 offset) 
    164164{ 
     165        u32 lo, hi; 
     166 
    165167        switch (bus->bustype) { 
    166168        case SSB_BUSTYPE_SSB: 
    167169                offset += current_coreidx * SSB_CORE_SIZE; 
    static u32 scan_read32(struct ssb_bus *b 
    174176                        offset -= 0x800; 
    175177                } else 
    176178                        ssb_pcmcia_switch_segment(bus, 0); 
     179                lo = readw(bus->mmio + offset); 
     180                hi = readw(bus->mmio + offset + 2); 
     181                return lo | (hi << 16); 
     182        default: 
    177183                break; 
    178184        } 
    179185        return readl(bus->mmio + offset); 
    static int scan_switchcore(struct ssb_bu 
    188194                return ssb_pci_switch_coreidx(bus, coreidx); 
    189195        case SSB_BUSTYPE_PCMCIA: 
    190196                return ssb_pcmcia_switch_coreidx(bus, coreidx); 
     197        default: 
     198                break; 
    191199        } 
    192200        return 0; 
    193201} 
    void ssb_iounmap(struct ssb_bus *bus) 
    206214                SSB_BUG_ON(1); /* Can't reach this code. */ 
    207215#endif 
    208216                break; 
     217        default: 
     218                break; 
    209219        } 
    210220        bus->mmio = NULL; 
    211221        bus->mapped_device = NULL; 
    static void __iomem *ssb_ioremap(struct  
    230240                SSB_BUG_ON(1); /* Can't reach this code. */ 
    231241#endif 
    232242                break; 
     243        default: 
     244                break; 
    233245        } 
    234246 
    235247        return mmio; 
    int ssb_bus_scan(struct ssb_bus *bus, 
    339351                dev->bus = bus; 
    340352                dev->ops = bus->ops; 
    341353 
    342                 ssb_dprintk(KERN_INFO PFX 
     354                printk(KERN_DEBUG PFX 
    343355                            "Core %d found: %s " 
    344356                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    345357                            i, ssb_core_name(dev->id.coreid), 
  • drivers/ssb/driver_chipcommon.c

    a b void ssb_chipcommon_init(struct ssb_chip 
    233233{ 
    234234        if (!cc->dev) 
    235235                return; /* We don't have a ChipCommon */ 
     236        if (cc->dev->id.revision >= 11) 
     237                cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    236238        ssb_pmu_init(cc); 
    237239        chipco_powercontrol_init(cc); 
    238240        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    u32 ssb_chipco_gpio_control(struct ssb_c 
    370372{ 
    371373        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
    372374} 
     375EXPORT_SYMBOL(ssb_chipco_gpio_control); 
    373376 
    374377u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value) 
    375378{ 
  • drivers/ssb/driver_mipscore.c

    a b static const u32 ipsflag_irq_shift[] = { 
    4949 
    5050static inline u32 ssb_irqflag(struct ssb_device *dev) 
    5151{ 
    52         return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
     52        u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG); 
     53        if (tpsflag) 
     54                return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
     55        else 
     56                /* not irq supported */ 
     57                return 0x3f; 
     58} 
     59 
     60static struct ssb_device *find_device(struct ssb_device *rdev, int irqflag) 
     61{ 
     62        struct ssb_bus *bus = rdev->bus; 
     63        int i; 
     64        for (i = 0; i < bus->nr_devices; i++) { 
     65                struct ssb_device *dev; 
     66                dev = &(bus->devices[i]); 
     67                if (ssb_irqflag(dev) == irqflag) 
     68                        return dev; 
     69        } 
     70        return NULL; 
    5371} 
    5472 
    5573/* Get the MIPS IRQ assignment for a specified device. 
    5674 * If unassigned, 0 is returned. 
     75 * If disabled, 5 is returned. 
     76 * If not supported, 6 is returned. 
    5777 */ 
    5878unsigned int ssb_mips_irq(struct ssb_device *dev) 
    5979{ 
    6080        struct ssb_bus *bus = dev->bus; 
     81        struct ssb_device *mdev = bus->mipscore.dev; 
    6182        u32 irqflag; 
    6283        u32 ipsflag; 
    6384        u32 tmp; 
    6485        unsigned int irq; 
    6586 
    6687        irqflag = ssb_irqflag(dev); 
     88        if (irqflag == 0x3f) 
     89                return 6; 
    6790        ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG); 
    6891        for (irq = 1; irq <= 4; irq++) { 
    6992                tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]); 
    7093                if (tmp == irqflag) 
    7194                        break; 
    7295        } 
    73         if (irq == 5) 
    74                 irq = 0; 
     96        if (irq == 5) { 
     97                if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)) 
     98                        irq = 0; 
     99        } 
    75100 
    76101        return irq; 
    77102} 
    static void set_irq(struct ssb_device *d 
    97122        struct ssb_device *mdev = bus->mipscore.dev; 
    98123        u32 irqflag = ssb_irqflag(dev); 
    99124 
     125        BUG_ON(oldirq == 6); 
     126 
    100127        dev->irq = irq + 2; 
    101128 
    102         ssb_dprintk(KERN_INFO PFX 
    103                     "set_irq: core 0x%04x, irq %d => %d\n", 
    104                     dev->id.coreid, oldirq, irq); 
    105129        /* clear the old irq */ 
    106130        if (oldirq == 0) 
    107131                ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC))); 
    108         else 
     132        else if (oldirq != 5) 
    109133                clear_irq(bus, oldirq); 
    110134 
    111135        /* assign the new one */ 
    112136        if (irq == 0) { 
    113137                ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC))); 
    114138        } else { 
     139                u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG); 
     140                if ((ipsflag & ipsflag_irq_mask[irq]) != ipsflag_irq_mask[irq]) { 
     141                        u32 oldipsflag = (ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]; 
     142                        struct ssb_device *olddev = find_device(dev, oldipsflag); 
     143                        if (olddev) 
     144                                set_irq(olddev, 0); 
     145                } 
    115146                irqflag <<= ipsflag_irq_shift[irq]; 
    116                 irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]); 
     147                irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]); 
    117148                ssb_write32(mdev, SSB_IPSFLAG, irqflag); 
    118149        } 
     150        ssb_dprintk(KERN_INFO PFX 
     151                    "set_irq: core 0x%04x, irq %d => %d\n", 
     152                    dev->id.coreid, oldirq+2, irq+2); 
     153} 
     154 
     155static void print_irq(struct ssb_device *dev, unsigned int irq) 
     156{ 
     157        int i; 
     158        static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"}; 
     159        ssb_dprintk(KERN_INFO PFX 
     160                "core 0x%04x, irq :", dev->id.coreid); 
     161        for (i = 0; i <= 6; i++) { 
     162                ssb_dprintk(" %s%s", irq_name[i], i==irq?"*":" "); 
     163        } 
     164        ssb_dprintk("\n"); 
     165} 
     166 
     167static void dump_irq(struct ssb_bus *bus) 
     168{ 
     169        int i; 
     170        for (i = 0; i < bus->nr_devices; i++) { 
     171                struct ssb_device *dev; 
     172                dev = &(bus->devices[i]); 
     173                print_irq(dev, ssb_mips_irq(dev)); 
     174        } 
    119175} 
    120176 
    121177static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
    void ssb_mipscore_init(struct ssb_mipsco 
    197253 
    198254        /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */ 
    199255        for (irq = 2, i = 0; i < bus->nr_devices; i++) { 
     256                int mips_irq; 
    200257                dev = &(bus->devices[i]); 
    201                 dev->irq = ssb_mips_irq(dev) + 2; 
     258                mips_irq = ssb_mips_irq(dev); 
     259                if (mips_irq > 4) 
     260                        dev->irq = 0; 
     261                else 
     262                        dev->irq = mips_irq + 2; 
     263                if (dev->irq > 5) 
     264                        continue; 
    202265                switch (dev->id.coreid) { 
    203266                case SSB_DEV_USB11_HOST: 
    204267                        /* shouldn't need a separate irq line for non-4710, most of them have a proper 
    205268                         * external usb controller on the pci */ 
    206269                        if ((bus->chip_id == 0x4710) && (irq <= 4)) { 
    207270                                set_irq(dev, irq++); 
    208                                 break; 
    209271                        } 
    210                         /* fallthrough */ 
     272                        break; 
    211273                case SSB_DEV_PCI: 
    212274                case SSB_DEV_ETHERNET: 
    213275                case SSB_DEV_ETHERNET_GBIT: 
    void ssb_mipscore_init(struct ssb_mipsco 
    218280                                set_irq(dev, irq++); 
    219281                                break; 
    220282                        } 
     283                        /* fallthrough */ 
     284                case SSB_DEV_EXTIF: 
     285                        set_irq(dev, 0); 
     286                        break; 
    221287                } 
    222288        } 
     289        ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n"); 
     290        dump_irq(bus); 
    223291 
    224292        ssb_mips_serial_init(mcore); 
    225293        ssb_mips_flash_detect(mcore); 
  • drivers/ssb/sprom.c

    a b  
    1313 
    1414#include "ssb_private.h" 
    1515 
     16#include <linux/ctype.h> 
     17#include <linux/slab.h> 
     18 
    1619 
    1720static const struct ssb_sprom *fallback_sprom; 
    1821 
    static int sprom2hex(const u16 *sprom, c 
    3336static int hex2sprom(u16 *sprom, const char *dump, size_t len, 
    3437                     size_t sprom_size_words) 
    3538{ 
    36         char tmp[5] = { 0 }; 
    37         int cnt = 0; 
     39        char c, tmp[5] = { 0 }; 
     40        int err, cnt = 0; 
    3841        unsigned long parsed; 
    3942 
    40         if (len < sprom_size_words * 2) 
     43        /* Strip whitespace at the end. */ 
     44        while (len) { 
     45                c = dump[len - 1]; 
     46                if (!isspace(c) && c != '\0') 
     47                        break; 
     48                len--; 
     49        } 
     50        /* Length must match exactly. */ 
     51        if (len != sprom_size_words * 4) 
    4152                return -EINVAL; 
    4253 
    4354        while (cnt < sprom_size_words) { 
    4455                memcpy(tmp, dump, 4); 
    4556                dump += 4; 
    46                 parsed = simple_strtoul(tmp, NULL, 16); 
     57                err = strict_strtoul(tmp, 16, &parsed); 
     58                if (err) 
     59                        return err; 
    4760                sprom[cnt++] = swab16((u16)parsed); 
    4861        } 
    4962 
    ssize_t ssb_attr_sprom_store(struct ssb_ 
    90103        u16 *sprom; 
    91104        int res = 0, err = -ENOMEM; 
    92105        size_t sprom_size_words = bus->sprom_size; 
     106        struct ssb_freeze_context freeze; 
    93107 
    94108        sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 
    95109        if (!sprom) 
    ssize_t ssb_attr_sprom_store(struct ssb_ 
    111125        err = -ERESTARTSYS; 
    112126        if (mutex_lock_interruptible(&bus->sprom_mutex)) 
    113127                goto out_kfree; 
    114         err = ssb_devices_freeze(bus); 
    115         if (err == -EOPNOTSUPP) { 
    116                 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
    117                            "No suspend support. Is CONFIG_PM enabled?\n"); 
    118                 goto out_unlock; 
    119         } 
     128        err = ssb_devices_freeze(bus, &freeze); 
    120129        if (err) { 
    121130                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
    122131                goto out_unlock; 
    123132        } 
    124133        res = sprom_write(bus, sprom); 
    125         err = ssb_devices_thaw(bus); 
     134        err = ssb_devices_thaw(&freeze); 
    126135        if (err) 
    127136                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    128137out_unlock: 
    const struct ssb_sprom *ssb_get_fallback 
    167176{ 
    168177        return fallback_sprom; 
    169178} 
     179 
     180/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     181bool ssb_is_sprom_available(struct ssb_bus *bus) 
     182{ 
     183        /* status register only exists on chipcomon rev >= 11 and we need check 
     184           for >= 31 only */ 
     185        /* this routine differs from specs as we do not access SPROM directly 
     186           on PCMCIA */ 
     187        if (bus->bustype == SSB_BUSTYPE_PCI && 
     188            bus->chipco.dev->id.revision >= 31) 
     189                return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
     190 
     191        return true; 
     192} 
  • drivers/ssb/ssb_private.h

    a b extern const struct ssb_sprom *ssb_get_f 
    136136 
    137137/* core.c */ 
    138138extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
    139 extern int ssb_devices_freeze(struct ssb_bus *bus); 
    140 extern int ssb_devices_thaw(struct ssb_bus *bus); 
    141139extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
    142140int ssb_for_each_bus_call(unsigned long data, 
    143141                          int (*func)(struct ssb_bus *bus, unsigned long data)); 
    144142extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev); 
    145143 
     144struct ssb_freeze_context { 
     145        /* Pointer to the bus */ 
     146        struct ssb_bus *bus; 
     147        /* Boolean list to indicate whether a device is frozen on this bus. */ 
     148        bool device_frozen[SSB_MAX_NR_CORES]; 
     149}; 
     150extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx); 
     151extern int ssb_devices_thaw(struct ssb_freeze_context *ctx); 
     152 
     153 
    146154 
    147155/* b43_pci_bridge.c */ 
    148156#ifdef CONFIG_SSB_B43_PCI_BRIDGE 
    149157extern int __init b43_pci_ssb_bridge_init(void); 
    150158extern void __exit b43_pci_ssb_bridge_exit(void); 
    151 #else /* CONFIG_SSB_B43_PCI_BRIDGR */ 
     159#else /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    152160static inline int b43_pci_ssb_bridge_init(void) 
    153161{ 
    154162        return 0; 
    static inline int b43_pci_ssb_bridge_ini 
    156164static inline void b43_pci_ssb_bridge_exit(void) 
    157165{ 
    158166} 
    159 #endif /* CONFIG_SSB_PCIHOST */ 
     167#endif /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    160168 
    161169#endif /* LINUX_SSB_PRIVATE_H_ */ 
Note: See TracBrowser for help on using the repository browser.