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

Last change on this file since 20655 was 18022, checked in by nbd, 7 years ago

ssb: sync with wireless-2.6

File size: 19.1 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 */ 
    void ssb_pmu_init(struct ssb_chipcommon  
    506521        ssb_pmu_pll_init(cc); 
    507522        ssb_pmu_resources_init(cc); 
    508523} 
     524 
     525void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc, 
     526                             enum ssb_pmu_ldo_volt_id id, u32 voltage) 
     527{ 
     528        struct ssb_bus *bus = cc->dev->bus; 
     529        u32 addr, shift, mask; 
     530 
     531        switch (bus->chip_id) { 
     532        case 0x4328: 
     533        case 0x5354: 
     534                switch (id) { 
     535                case LDO_VOLT1: 
     536                        addr = 2; 
     537                        shift = 25; 
     538                        mask = 0xF; 
     539                        break; 
     540                case LDO_VOLT2: 
     541                        addr = 3; 
     542                        shift = 1; 
     543                        mask = 0xF; 
     544                        break; 
     545                case LDO_VOLT3: 
     546                        addr = 3; 
     547                        shift = 9; 
     548                        mask = 0xF; 
     549                        break; 
     550                case LDO_PAREF: 
     551                        addr = 3; 
     552                        shift = 17; 
     553                        mask = 0x3F; 
     554                        break; 
     555                default: 
     556                        SSB_WARN_ON(1); 
     557                        return; 
     558                } 
     559                break; 
     560        case 0x4312: 
     561                if (SSB_WARN_ON(id != LDO_PAREF)) 
     562                        return; 
     563                addr = 0; 
     564                shift = 21; 
     565                mask = 0x3F; 
     566                break; 
     567        default: 
     568                return; 
     569        } 
     570 
     571        ssb_chipco_regctl_maskset(cc, addr, ~(mask << shift), 
     572                                  (voltage & mask) << shift); 
     573} 
     574 
     575void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on) 
     576{ 
     577        struct ssb_bus *bus = cc->dev->bus; 
     578        int ldo; 
     579 
     580        switch (bus->chip_id) { 
     581        case 0x4312: 
     582                ldo = SSB_PMURES_4312_PA_REF_LDO; 
     583                break; 
     584        case 0x4328: 
     585                ldo = SSB_PMURES_4328_PA_REF_LDO; 
     586                break; 
     587        case 0x5354: 
     588                ldo = SSB_PMURES_5354_PA_REF_LDO; 
     589                break; 
     590        default: 
     591                return; 
     592        } 
     593 
     594        if (on) 
     595                chipco_set32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 1 << ldo); 
     596        else 
     597                chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, ~(1 << ldo)); 
     598        chipco_read32(cc, SSB_CHIPCO_PMU_MINRES_MSK); //SPEC FIXME found via mmiotrace - dummy read? 
     599} 
     600 
     601EXPORT_SYMBOL(ssb_pmu_set_ldo_voltage); 
     602EXPORT_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: 
    169169/* Get the word-offset for a SSB_SPROM_XXX define. */ 
    170170#define SPOFF(offset)   (((offset) - SSB_SPROM_BASE) / 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 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        } 
  • 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        } 
    int ssb_pcmcia_get_invariants(struct ssb 
    678678                        sprom->board_rev = tuple.TupleData[1]; 
    679679                        break; 
    680680                case SSB_PCMCIA_CIS_PA: 
    681                         GOTO_ERROR_ON(tuple.TupleDataLen != 9, 
     681                        GOTO_ERROR_ON((tuple.TupleDataLen != 9) && 
     682                                      (tuple.TupleDataLen != 10), 
    682683                                      "pa tpl size"); 
    683684                        sprom->pa0b0 = tuple.TupleData[1] | 
    684685                                 ((u16)tuple.TupleData[2] << 8); 
    int ssb_pcmcia_get_invariants(struct ssb 
    718719                        sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1]; 
    719720                        break; 
    720721                case SSB_PCMCIA_CIS_BFLAGS: 
    721                         GOTO_ERROR_ON(tuple.TupleDataLen != 3, 
     722                        GOTO_ERROR_ON((tuple.TupleDataLen != 3) && 
     723                                      (tuple.TupleDataLen != 5), 
    722724                                      "bfl tpl size"); 
    723725                        sprom->boardflags_lo = tuple.TupleData[1] | 
    724726                                         ((u16)tuple.TupleData[2] << 8); 
  • 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 { 
    240271 
    241272        /* The core in the basic address register window. (PCI bus only) */ 
    242273        struct ssb_device *mapped_device; 
    243         /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
    244         u8 mapped_pcmcia_seg; 
     274        union { 
     275                /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
     276                u8 mapped_pcmcia_seg; 
     277                /* Current SSB base address window for SDIO. */ 
     278                u32 sdio_sbaddr; 
     279        }; 
    245280        /* Lock for core and segment switching. 
    246281         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    247282        spinlock_t bar_lock; 
    struct ssb_bus { 
    252287        struct pci_dev *host_pci; 
    253288        /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
    254289        struct pcmcia_device *host_pcmcia; 
     290        /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
     291        struct sdio_func *host_sdio; 
     292 
     293        /* See enum ssb_quirks */ 
     294        unsigned int quirks; 
    255295 
    256296#ifdef CONFIG_SSB_SPROM 
    257297        /* Mutex to protect the SPROM writing. */ 
    struct ssb_bus { 
    306346#endif /* DEBUG */ 
    307347}; 
    308348 
     349enum ssb_quirks { 
     350        /* SDIO connected card requires performing a read after writing a 32-bit value */ 
     351        SSB_QUIRK_SDIO_READ_AFTER_WRITE32       = (1 << 0), 
     352}; 
     353 
    309354/* The initialization-invariants. */ 
    310355struct ssb_init_invariants { 
    311356        /* Versioning information about the PCB. */ 
    extern int ssb_bus_pcmciabus_register(st 
    336381                                      struct pcmcia_device *pcmcia_dev, 
    337382                                      unsigned long baseaddr); 
    338383#endif /* CONFIG_SSB_PCMCIAHOST */ 
     384#ifdef CONFIG_SSB_SDIOHOST 
     385extern int ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     386                                    struct sdio_func *sdio_func, 
     387                                    unsigned int quirks); 
     388#endif /* CONFIG_SSB_SDIOHOST */ 
     389 
    339390 
    340391extern void ssb_bus_unregister(struct ssb_bus *bus); 
    341392 
  • include/linux/ssb/ssb_driver_chipcommon.h

    a b extern int ssb_chipco_serial_init(struct 
    629629/* PMU support */ 
    630630extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
    631631 
     632enum ssb_pmu_ldo_volt_id { 
     633        LDO_PAREF = 0, 
     634        LDO_VOLT1, 
     635        LDO_VOLT2, 
     636        LDO_VOLT3, 
     637}; 
     638 
     639void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc, 
     640                             enum ssb_pmu_ldo_volt_id id, u32 voltage); 
     641void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on); 
    632642 
    633643#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)) 
     
    327327#define  SSB_SPROM5_GPIOB_P3_SHIFT      8 
    328328 
    329329/* SPROM Revision 8 */ 
    330 #define SSB_SPROM8_BFLLO                0x1084  /* Boardflags (low 16 bits) */ 
    331 #define SSB_SPROM8_BFLHI                0x1086  /* Boardflags Hi */ 
     330#define SSB_SPROM8_BOARDREV             0x1082  /* Board revision */ 
     331#define SSB_SPROM8_BFLLO                0x1084  /* Board flags (bits 0-15) */ 
     332#define SSB_SPROM8_BFLHI                0x1086  /* Board flags (bits 16-31) */ 
     333#define SSB_SPROM8_BFL2LO               0x1088  /* Board flags (bits 32-47) */ 
     334#define SSB_SPROM8_BFL2HI               0x108A  /* Board flags (bits 48-63) */ 
    332335#define SSB_SPROM8_IL0MAC               0x108C  /* 6 byte MAC address */ 
    333336#define SSB_SPROM8_CCODE                0x1092  /* 2 byte country code */ 
    334337#define SSB_SPROM8_ANTAVAIL             0x109C  /* Antenna available bitfields*/ 
     
    354357#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
    355358#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
    356359#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 */ 
     360#define SSB_SPROM8_RSSIPARM2G           0x10A4  /* RSSI params for 2GHz */ 
     361#define  SSB_SPROM8_RSSISMF2G           0x000F 
     362#define  SSB_SPROM8_RSSISMC2G           0x00F0 
     363#define  SSB_SPROM8_RSSISMC2G_SHIFT     4 
     364#define  SSB_SPROM8_RSSISAV2G           0x0700 
     365#define  SSB_SPROM8_RSSISAV2G_SHIFT     8 
     366#define  SSB_SPROM8_BXA2G               0x1800 
     367#define  SSB_SPROM8_BXA2G_SHIFT         11 
     368#define SSB_SPROM8_RSSIPARM5G           0x10A6  /* RSSI params for 5GHz */ 
     369#define  SSB_SPROM8_RSSISMF5G           0x000F 
     370#define  SSB_SPROM8_RSSISMC5G           0x00F0 
     371#define  SSB_SPROM8_RSSISMC5G_SHIFT     4 
     372#define  SSB_SPROM8_RSSISAV5G           0x0700 
     373#define  SSB_SPROM8_RSSISAV5G_SHIFT     8 
     374#define  SSB_SPROM8_BXA5G               0x1800 
     375#define  SSB_SPROM8_BXA5G_SHIFT         11 
     376#define SSB_SPROM8_TRI25G               0x10A8  /* TX isolation 2.4&5.3GHz */ 
     377#define  SSB_SPROM8_TRI2G               0x00FF  /* TX isolation 2.4GHz */ 
     378#define  SSB_SPROM8_TRI5G               0xFF00  /* TX isolation 5.3GHz */ 
     379#define  SSB_SPROM8_TRI5G_SHIFT         8 
     380#define SSB_SPROM8_TRI5GHL              0x10AA  /* TX isolation 5.2/5.8GHz */ 
     381#define  SSB_SPROM8_TRI5GL              0x00FF  /* TX isolation 5.2GHz */ 
     382#define  SSB_SPROM8_TRI5GH              0xFF00  /* TX isolation 5.8GHz */ 
     383#define  SSB_SPROM8_TRI5GH_SHIFT        8 
     384#define SSB_SPROM8_RXPO                 0x10AC  /* RX power offsets */ 
     385#define  SSB_SPROM8_RXPO2G              0x00FF  /* 2GHz RX power offset */ 
     386#define  SSB_SPROM8_RXPO5G              0xFF00  /* 5GHz RX power offset */ 
     387#define  SSB_SPROM8_RXPO5G_SHIFT        8 
     388#define SSB_SPROM8_MAXP_BG              0x10C0  /* Max Power 2GHz in path 1 */ 
     389#define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */ 
    359390#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
    360391#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 */ 
     392#define SSB_SPROM8_PA0B0                0x10C2  /* 2GHz power amp settings */ 
     393#define SSB_SPROM8_PA0B1                0x10C4 
     394#define SSB_SPROM8_PA0B2                0x10C6 
     395#define SSB_SPROM8_MAXP_A               0x10C8  /* Max Power 5.3GHz */ 
     396#define  SSB_SPROM8_MAXP_A_MASK         0x00FF  /* Mask for Max Power 5.3GHz */ 
    363397#define  SSB_SPROM8_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
    364398#define  SSB_SPROM8_ITSSI_A_SHIFT       8 
     399#define SSB_SPROM8_MAXP_AHL             0x10CA  /* Max Power 5.2/5.8GHz */ 
     400#define  SSB_SPROM8_MAXP_AH_MASK        0x00FF  /* Mask for Max Power 5.8GHz */ 
     401#define  SSB_SPROM8_MAXP_AL_MASK        0xFF00  /* Mask for Max Power 5.2GHz */ 
     402#define  SSB_SPROM8_MAXP_AL_SHIFT       8 
     403#define SSB_SPROM8_PA1B0                0x10CC  /* 5.3GHz power amp settings */ 
     404#define SSB_SPROM8_PA1B1                0x10CE 
     405#define SSB_SPROM8_PA1B2                0x10D0 
     406#define SSB_SPROM8_PA1LOB0              0x10D2  /* 5.2GHz power amp settings */ 
     407#define SSB_SPROM8_PA1LOB1              0x10D4 
     408#define SSB_SPROM8_PA1LOB2              0x10D6 
     409#define SSB_SPROM8_PA1HIB0              0x10D8  /* 5.8GHz power amp settings */ 
     410#define SSB_SPROM8_PA1HIB1              0x10DA 
     411#define SSB_SPROM8_PA1HIB2              0x10DC 
     412#define SSB_SPROM8_CCK2GPO              0x1140  /* CCK power offset */ 
     413#define SSB_SPROM8_OFDM2GPO             0x1142  /* 2.4GHz OFDM power offset */ 
     414#define SSB_SPROM8_OFDM5GPO             0x1146  /* 5.3GHz OFDM power offset */ 
     415#define SSB_SPROM8_OFDM5GLPO            0x114A  /* 5.2GHz OFDM power offset */ 
     416#define SSB_SPROM8_OFDM5GHPO            0x114E  /* 5.8GHz OFDM power offset */ 
    365417 
    366418/* Values for SSB_SPROM1_BINF_CCODE */ 
    367419enum { 
  • drivers/ssb/scan.c

    a b static u32 scan_read32(struct ssb_bus *b 
    175175                } else 
    176176                        ssb_pcmcia_switch_segment(bus, 0); 
    177177                break; 
     178        default: 
     179                break; 
    178180        } 
    179181        return readl(bus->mmio + offset); 
    180182} 
    static int scan_switchcore(struct ssb_bu 
    188190                return ssb_pci_switch_coreidx(bus, coreidx); 
    189191        case SSB_BUSTYPE_PCMCIA: 
    190192                return ssb_pcmcia_switch_coreidx(bus, coreidx); 
     193        default: 
     194                break; 
    191195        } 
    192196        return 0; 
    193197} 
    void ssb_iounmap(struct ssb_bus *bus) 
    206210                SSB_BUG_ON(1); /* Can't reach this code. */ 
    207211#endif 
    208212                break; 
     213        default: 
     214                break; 
    209215        } 
    210216        bus->mmio = NULL; 
    211217        bus->mapped_device = NULL; 
    static void __iomem *ssb_ioremap(struct  
    230236                SSB_BUG_ON(1); /* Can't reach this code. */ 
    231237#endif 
    232238                break; 
     239        default: 
     240                break; 
    233241        } 
    234242 
    235243        return mmio; 
Note: See TracBrowser for help on using the repository browser.