source: trunk/target/linux/generic-2.6/patches-2.6.28/976-ssb_update.patch @ 18063

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

fix ssb compile error on 2.6.28

File size: 52.4 KB
  • new file drivers/ssb/driver_chipcommon_pmu.c

    - +  
     1/* 
     2 * Sonics Silicon Backplane 
     3 * Broadcom ChipCommon Power Management Unit driver 
     4 * 
     5 * Copyright 2009, Michael Buesch <mb@bu3sch.de> 
     6 * Copyright 2007, Broadcom Corporation 
     7 * 
     8 * Licensed under the GNU/GPL. See COPYING for details. 
     9 */ 
     10 
     11#include <linux/ssb/ssb.h> 
     12#include <linux/ssb/ssb_regs.h> 
     13#include <linux/ssb/ssb_driver_chipcommon.h> 
     14#include <linux/delay.h> 
     15 
     16#include "ssb_private.h" 
     17 
     18static u32 ssb_chipco_pll_read(struct ssb_chipcommon *cc, u32 offset) 
     19{ 
     20        chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, offset); 
     21        return chipco_read32(cc, SSB_CHIPCO_PLLCTL_DATA); 
     22} 
     23 
     24static void ssb_chipco_pll_write(struct ssb_chipcommon *cc, 
     25                                 u32 offset, u32 value) 
     26{ 
     27        chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, offset); 
     28        chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, value); 
     29} 
     30 
     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 
     46struct pmu0_plltab_entry { 
     47        u16 freq;       /* Crystal frequency in kHz.*/ 
     48        u8 xf;          /* Crystal frequency value for PMU control */ 
     49        u8 wb_int; 
     50        u32 wb_frac; 
     51}; 
     52 
     53static const struct pmu0_plltab_entry pmu0_plltab[] = { 
     54        { .freq = 12000, .xf =  1, .wb_int = 73, .wb_frac = 349525, }, 
     55        { .freq = 13000, .xf =  2, .wb_int = 67, .wb_frac = 725937, }, 
     56        { .freq = 14400, .xf =  3, .wb_int = 61, .wb_frac = 116508, }, 
     57        { .freq = 15360, .xf =  4, .wb_int = 57, .wb_frac = 305834, }, 
     58        { .freq = 16200, .xf =  5, .wb_int = 54, .wb_frac = 336579, }, 
     59        { .freq = 16800, .xf =  6, .wb_int = 52, .wb_frac = 399457, }, 
     60        { .freq = 19200, .xf =  7, .wb_int = 45, .wb_frac = 873813, }, 
     61        { .freq = 19800, .xf =  8, .wb_int = 44, .wb_frac = 466033, }, 
     62        { .freq = 20000, .xf =  9, .wb_int = 44, .wb_frac = 0,      }, 
     63        { .freq = 25000, .xf = 10, .wb_int = 70, .wb_frac = 419430, }, 
     64        { .freq = 26000, .xf = 11, .wb_int = 67, .wb_frac = 725937, }, 
     65        { .freq = 30000, .xf = 12, .wb_int = 58, .wb_frac = 699050, }, 
     66        { .freq = 38400, .xf = 13, .wb_int = 45, .wb_frac = 873813, }, 
     67        { .freq = 40000, .xf = 14, .wb_int = 45, .wb_frac = 0,      }, 
     68}; 
     69#define SSB_PMU0_DEFAULT_XTALFREQ       20000 
     70 
     71static const struct pmu0_plltab_entry * pmu0_plltab_find_entry(u32 crystalfreq) 
     72{ 
     73        const struct pmu0_plltab_entry *e; 
     74        unsigned int i; 
     75 
     76        for (i = 0; i < ARRAY_SIZE(pmu0_plltab); i++) { 
     77                e = &pmu0_plltab[i]; 
     78                if (e->freq == crystalfreq) 
     79                        return e; 
     80        } 
     81 
     82        return NULL; 
     83} 
     84 
     85/* Tune the PLL to the crystal speed. crystalfreq is in kHz. */ 
     86static void ssb_pmu0_pllinit_r0(struct ssb_chipcommon *cc, 
     87                                u32 crystalfreq) 
     88{ 
     89        struct ssb_bus *bus = cc->dev->bus; 
     90        const struct pmu0_plltab_entry *e = NULL; 
     91        u32 pmuctl, tmp, pllctl; 
     92        unsigned int i; 
     93 
     94        if ((bus->chip_id == 0x5354) && !crystalfreq) { 
     95                /* The 5354 crystal freq is 25MHz */ 
     96                crystalfreq = 25000; 
     97        } 
     98        if (crystalfreq) 
     99                e = pmu0_plltab_find_entry(crystalfreq); 
     100        if (!e) 
     101                e = pmu0_plltab_find_entry(SSB_PMU0_DEFAULT_XTALFREQ); 
     102        BUG_ON(!e); 
     103        crystalfreq = e->freq; 
     104        cc->pmu.crystalfreq = e->freq; 
     105 
     106        /* Check if the PLL already is programmed to this frequency. */ 
     107        pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL); 
     108        if (((pmuctl & SSB_CHIPCO_PMU_CTL_XTALFREQ) >> SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) == e->xf) { 
     109                /* We're already there... */ 
     110                return; 
     111        } 
     112 
     113        ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n", 
     114                   (crystalfreq / 1000), (crystalfreq % 1000)); 
     115 
     116        /* First turn the PLL off. */ 
     117        switch (bus->chip_id) { 
     118        case 0x4328: 
     119                chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 
     120                              ~(1 << SSB_PMURES_4328_BB_PLL_PU)); 
     121                chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, 
     122                              ~(1 << SSB_PMURES_4328_BB_PLL_PU)); 
     123                break; 
     124        case 0x5354: 
     125                chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 
     126                              ~(1 << SSB_PMURES_5354_BB_PLL_PU)); 
     127                chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, 
     128                              ~(1 << SSB_PMURES_5354_BB_PLL_PU)); 
     129                break; 
     130        default: 
     131                SSB_WARN_ON(1); 
     132        } 
     133        for (i = 1500; i; i--) { 
     134                tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST); 
     135                if (!(tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)) 
     136                        break; 
     137                udelay(10); 
     138        } 
     139        tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST); 
     140        if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT) 
     141                ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n"); 
     142 
     143        /* Set PDIV in PLL control 0. */ 
     144        pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL0); 
     145        if (crystalfreq >= SSB_PMU0_PLLCTL0_PDIV_FREQ) 
     146                pllctl |= SSB_PMU0_PLLCTL0_PDIV_MSK; 
     147        else 
     148                pllctl &= ~SSB_PMU0_PLLCTL0_PDIV_MSK; 
     149        ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL0, pllctl); 
     150 
     151        /* Set WILD in PLL control 1. */ 
     152        pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL1); 
     153        pllctl &= ~SSB_PMU0_PLLCTL1_STOPMOD; 
     154        pllctl &= ~(SSB_PMU0_PLLCTL1_WILD_IMSK | SSB_PMU0_PLLCTL1_WILD_FMSK); 
     155        pllctl |= ((u32)e->wb_int << SSB_PMU0_PLLCTL1_WILD_IMSK_SHIFT) & SSB_PMU0_PLLCTL1_WILD_IMSK; 
     156        pllctl |= ((u32)e->wb_frac << SSB_PMU0_PLLCTL1_WILD_FMSK_SHIFT) & SSB_PMU0_PLLCTL1_WILD_FMSK; 
     157        if (e->wb_frac == 0) 
     158                pllctl |= SSB_PMU0_PLLCTL1_STOPMOD; 
     159        ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL1, pllctl); 
     160 
     161        /* Set WILD in PLL control 2. */ 
     162        pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL2); 
     163        pllctl &= ~SSB_PMU0_PLLCTL2_WILD_IMSKHI; 
     164        pllctl |= (((u32)e->wb_int >> 4) << SSB_PMU0_PLLCTL2_WILD_IMSKHI_SHIFT) & SSB_PMU0_PLLCTL2_WILD_IMSKHI; 
     165        ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL2, pllctl); 
     166 
     167        /* Set the crystalfrequency and the divisor. */ 
     168        pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL); 
     169        pmuctl &= ~SSB_CHIPCO_PMU_CTL_ILP_DIV; 
     170        pmuctl |= (((crystalfreq + 127) / 128 - 1) << SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT) 
     171                        & SSB_CHIPCO_PMU_CTL_ILP_DIV; 
     172        pmuctl &= ~SSB_CHIPCO_PMU_CTL_XTALFREQ; 
     173        pmuctl |= ((u32)e->xf << SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) & SSB_CHIPCO_PMU_CTL_XTALFREQ; 
     174        chipco_write32(cc, SSB_CHIPCO_PMU_CTL, pmuctl); 
     175} 
     176 
     177struct pmu1_plltab_entry { 
     178        u16 freq;       /* Crystal frequency in kHz.*/ 
     179        u8 xf;          /* Crystal frequency value for PMU control */ 
     180        u8 ndiv_int; 
     181        u32 ndiv_frac; 
     182        u8 p1div; 
     183        u8 p2div; 
     184}; 
     185 
     186static const struct pmu1_plltab_entry pmu1_plltab[] = { 
     187        { .freq = 12000, .xf =  1, .p1div = 3, .p2div = 22, .ndiv_int =  0x9, .ndiv_frac = 0xFFFFEF, }, 
     188        { .freq = 13000, .xf =  2, .p1div = 1, .p2div =  6, .ndiv_int =  0xb, .ndiv_frac = 0x483483, }, 
     189        { .freq = 14400, .xf =  3, .p1div = 1, .p2div = 10, .ndiv_int =  0xa, .ndiv_frac = 0x1C71C7, }, 
     190        { .freq = 15360, .xf =  4, .p1div = 1, .p2div =  5, .ndiv_int =  0xb, .ndiv_frac = 0x755555, }, 
     191        { .freq = 16200, .xf =  5, .p1div = 1, .p2div = 10, .ndiv_int =  0x5, .ndiv_frac = 0x6E9E06, }, 
     192        { .freq = 16800, .xf =  6, .p1div = 1, .p2div = 10, .ndiv_int =  0x5, .ndiv_frac = 0x3CF3CF, }, 
     193        { .freq = 19200, .xf =  7, .p1div = 1, .p2div =  9, .ndiv_int =  0x5, .ndiv_frac = 0x17B425, }, 
     194        { .freq = 19800, .xf =  8, .p1div = 1, .p2div = 11, .ndiv_int =  0x4, .ndiv_frac = 0xA57EB,  }, 
     195        { .freq = 20000, .xf =  9, .p1div = 1, .p2div = 11, .ndiv_int =  0x4, .ndiv_frac = 0,        }, 
     196        { .freq = 24000, .xf = 10, .p1div = 3, .p2div = 11, .ndiv_int =  0xa, .ndiv_frac = 0,        }, 
     197        { .freq = 25000, .xf = 11, .p1div = 5, .p2div = 16, .ndiv_int =  0xb, .ndiv_frac = 0,        }, 
     198        { .freq = 26000, .xf = 12, .p1div = 1, .p2div =  2, .ndiv_int = 0x10, .ndiv_frac = 0xEC4EC4, }, 
     199        { .freq = 30000, .xf = 13, .p1div = 3, .p2div =  8, .ndiv_int =  0xb, .ndiv_frac = 0,        }, 
     200        { .freq = 38400, .xf = 14, .p1div = 1, .p2div =  5, .ndiv_int =  0x4, .ndiv_frac = 0x955555, }, 
     201        { .freq = 40000, .xf = 15, .p1div = 1, .p2div =  2, .ndiv_int =  0xb, .ndiv_frac = 0,        }, 
     202}; 
     203 
     204#define SSB_PMU1_DEFAULT_XTALFREQ       15360 
     205 
     206static const struct pmu1_plltab_entry * pmu1_plltab_find_entry(u32 crystalfreq) 
     207{ 
     208        const struct pmu1_plltab_entry *e; 
     209        unsigned int i; 
     210 
     211        for (i = 0; i < ARRAY_SIZE(pmu1_plltab); i++) { 
     212                e = &pmu1_plltab[i]; 
     213                if (e->freq == crystalfreq) 
     214                        return e; 
     215        } 
     216 
     217        return NULL; 
     218} 
     219 
     220/* Tune the PLL to the crystal speed. crystalfreq is in kHz. */ 
     221static void ssb_pmu1_pllinit_r0(struct ssb_chipcommon *cc, 
     222                                u32 crystalfreq) 
     223{ 
     224        struct ssb_bus *bus = cc->dev->bus; 
     225        const struct pmu1_plltab_entry *e = NULL; 
     226        u32 buffer_strength = 0; 
     227        u32 tmp, pllctl, pmuctl; 
     228        unsigned int i; 
     229 
     230        if (bus->chip_id == 0x4312) { 
     231                /* We do not touch the BCM4312 PLL and assume 
     232                 * the default crystal settings work out-of-the-box. */ 
     233                cc->pmu.crystalfreq = 20000; 
     234                return; 
     235        } 
     236 
     237        if (crystalfreq) 
     238                e = pmu1_plltab_find_entry(crystalfreq); 
     239        if (!e) 
     240                e = pmu1_plltab_find_entry(SSB_PMU1_DEFAULT_XTALFREQ); 
     241        BUG_ON(!e); 
     242        crystalfreq = e->freq; 
     243        cc->pmu.crystalfreq = e->freq; 
     244 
     245        /* Check if the PLL already is programmed to this frequency. */ 
     246        pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL); 
     247        if (((pmuctl & SSB_CHIPCO_PMU_CTL_XTALFREQ) >> SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) == e->xf) { 
     248                /* We're already there... */ 
     249                return; 
     250        } 
     251 
     252        ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n", 
     253                   (crystalfreq / 1000), (crystalfreq % 1000)); 
     254 
     255        /* First turn the PLL off. */ 
     256        switch (bus->chip_id) { 
     257        case 0x4325: 
     258                chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 
     259                              ~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) | 
     260                                (1 << SSB_PMURES_4325_HT_AVAIL))); 
     261                chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, 
     262                              ~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) | 
     263                                (1 << SSB_PMURES_4325_HT_AVAIL))); 
     264                /* Adjust the BBPLL to 2 on all channels later. */ 
     265                buffer_strength = 0x222222; 
     266                break; 
     267        default: 
     268                SSB_WARN_ON(1); 
     269        } 
     270        for (i = 1500; i; i--) { 
     271                tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST); 
     272                if (!(tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)) 
     273                        break; 
     274                udelay(10); 
     275        } 
     276        tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST); 
     277        if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT) 
     278                ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n"); 
     279 
     280        /* Set p1div and p2div. */ 
     281        pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL0); 
     282        pllctl &= ~(SSB_PMU1_PLLCTL0_P1DIV | SSB_PMU1_PLLCTL0_P2DIV); 
     283        pllctl |= ((u32)e->p1div << SSB_PMU1_PLLCTL0_P1DIV_SHIFT) & SSB_PMU1_PLLCTL0_P1DIV; 
     284        pllctl |= ((u32)e->p2div << SSB_PMU1_PLLCTL0_P2DIV_SHIFT) & SSB_PMU1_PLLCTL0_P2DIV; 
     285        ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL0, pllctl); 
     286 
     287        /* Set ndiv int and ndiv mode */ 
     288        pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL2); 
     289        pllctl &= ~(SSB_PMU1_PLLCTL2_NDIVINT | SSB_PMU1_PLLCTL2_NDIVMODE); 
     290        pllctl |= ((u32)e->ndiv_int << SSB_PMU1_PLLCTL2_NDIVINT_SHIFT) & SSB_PMU1_PLLCTL2_NDIVINT; 
     291        pllctl |= (1 << SSB_PMU1_PLLCTL2_NDIVMODE_SHIFT) & SSB_PMU1_PLLCTL2_NDIVMODE; 
     292        ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, pllctl); 
     293 
     294        /* Set ndiv frac */ 
     295        pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL3); 
     296        pllctl &= ~SSB_PMU1_PLLCTL3_NDIVFRAC; 
     297        pllctl |= ((u32)e->ndiv_frac << SSB_PMU1_PLLCTL3_NDIVFRAC_SHIFT) & SSB_PMU1_PLLCTL3_NDIVFRAC; 
     298        ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL3, pllctl); 
     299 
     300        /* Change the drive strength, if required. */ 
     301        if (buffer_strength) { 
     302                pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL5); 
     303                pllctl &= ~SSB_PMU1_PLLCTL5_CLKDRV; 
     304                pllctl |= (buffer_strength << SSB_PMU1_PLLCTL5_CLKDRV_SHIFT) & SSB_PMU1_PLLCTL5_CLKDRV; 
     305                ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL5, pllctl); 
     306        } 
     307 
     308        /* Tune the crystalfreq and the divisor. */ 
     309        pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL); 
     310        pmuctl &= ~(SSB_CHIPCO_PMU_CTL_ILP_DIV | SSB_CHIPCO_PMU_CTL_XTALFREQ); 
     311        pmuctl |= ((((u32)e->freq + 127) / 128 - 1) << SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT) 
     312                        & SSB_CHIPCO_PMU_CTL_ILP_DIV; 
     313        pmuctl |= ((u32)e->xf << SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) & SSB_CHIPCO_PMU_CTL_XTALFREQ; 
     314        chipco_write32(cc, SSB_CHIPCO_PMU_CTL, pmuctl); 
     315} 
     316 
     317static void ssb_pmu_pll_init(struct ssb_chipcommon *cc) 
     318{ 
     319        struct ssb_bus *bus = cc->dev->bus; 
     320        u32 crystalfreq = 0; /* in kHz. 0 = keep default freq. */ 
     321 
     322        if (bus->bustype == SSB_BUSTYPE_SSB) { 
     323                /* TODO: The user may override the crystal frequency. */ 
     324        } 
     325 
     326        switch (bus->chip_id) { 
     327        case 0x4312: 
     328        case 0x4325: 
     329                ssb_pmu1_pllinit_r0(cc, crystalfreq); 
     330                break; 
     331        case 0x4328: 
     332        case 0x5354: 
     333                ssb_pmu0_pllinit_r0(cc, crystalfreq); 
     334                break; 
     335        default: 
     336                ssb_printk(KERN_ERR PFX 
     337                           "ERROR: PLL init unknown for device %04X\n", 
     338                           bus->chip_id); 
     339        } 
     340} 
     341 
     342struct pmu_res_updown_tab_entry { 
     343        u8 resource;    /* The resource number */ 
     344        u16 updown;     /* The updown value */ 
     345}; 
     346 
     347enum pmu_res_depend_tab_task { 
     348        PMU_RES_DEP_SET = 1, 
     349        PMU_RES_DEP_ADD, 
     350        PMU_RES_DEP_REMOVE, 
     351}; 
     352 
     353struct pmu_res_depend_tab_entry { 
     354        u8 resource;    /* The resource number */ 
     355        u8 task;        /* SET | ADD | REMOVE */ 
     356        u32 depend;     /* The depend mask */ 
     357}; 
     358 
     359static const struct pmu_res_updown_tab_entry pmu_res_updown_tab_4328a0[] = { 
     360        { .resource = SSB_PMURES_4328_EXT_SWITCHER_PWM,         .updown = 0x0101, }, 
     361        { .resource = SSB_PMURES_4328_BB_SWITCHER_PWM,          .updown = 0x1F01, }, 
     362        { .resource = SSB_PMURES_4328_BB_SWITCHER_BURST,        .updown = 0x010F, }, 
     363        { .resource = SSB_PMURES_4328_BB_EXT_SWITCHER_BURST,    .updown = 0x0101, }, 
     364        { .resource = SSB_PMURES_4328_ILP_REQUEST,              .updown = 0x0202, }, 
     365        { .resource = SSB_PMURES_4328_RADIO_SWITCHER_PWM,       .updown = 0x0F01, }, 
     366        { .resource = SSB_PMURES_4328_RADIO_SWITCHER_BURST,     .updown = 0x0F01, }, 
     367        { .resource = SSB_PMURES_4328_ROM_SWITCH,               .updown = 0x0101, }, 
     368        { .resource = SSB_PMURES_4328_PA_REF_LDO,               .updown = 0x0F01, }, 
     369        { .resource = SSB_PMURES_4328_RADIO_LDO,                .updown = 0x0F01, }, 
     370        { .resource = SSB_PMURES_4328_AFE_LDO,                  .updown = 0x0F01, }, 
     371        { .resource = SSB_PMURES_4328_PLL_LDO,                  .updown = 0x0F01, }, 
     372        { .resource = SSB_PMURES_4328_BG_FILTBYP,               .updown = 0x0101, }, 
     373        { .resource = SSB_PMURES_4328_TX_FILTBYP,               .updown = 0x0101, }, 
     374        { .resource = SSB_PMURES_4328_RX_FILTBYP,               .updown = 0x0101, }, 
     375        { .resource = SSB_PMURES_4328_XTAL_PU,                  .updown = 0x0101, }, 
     376        { .resource = SSB_PMURES_4328_XTAL_EN,                  .updown = 0xA001, }, 
     377        { .resource = SSB_PMURES_4328_BB_PLL_FILTBYP,           .updown = 0x0101, }, 
     378        { .resource = SSB_PMURES_4328_RF_PLL_FILTBYP,           .updown = 0x0101, }, 
     379        { .resource = SSB_PMURES_4328_BB_PLL_PU,                .updown = 0x0701, }, 
     380}; 
     381 
     382static const struct pmu_res_depend_tab_entry pmu_res_depend_tab_4328a0[] = { 
     383        { 
     384                /* Adjust ILP Request to avoid forcing EXT/BB into burst mode. */ 
     385                .resource = SSB_PMURES_4328_ILP_REQUEST, 
     386                .task = PMU_RES_DEP_SET, 
     387                .depend = ((1 << SSB_PMURES_4328_EXT_SWITCHER_PWM) | 
     388                           (1 << SSB_PMURES_4328_BB_SWITCHER_PWM)), 
     389        }, 
     390}; 
     391 
     392static const struct pmu_res_updown_tab_entry pmu_res_updown_tab_4325a0[] = { 
     393        { .resource = SSB_PMURES_4325_XTAL_PU,                  .updown = 0x1501, }, 
     394}; 
     395 
     396static const struct pmu_res_depend_tab_entry pmu_res_depend_tab_4325a0[] = { 
     397        { 
     398                /* Adjust HT-Available dependencies. */ 
     399                .resource = SSB_PMURES_4325_HT_AVAIL, 
     400                .task = PMU_RES_DEP_ADD, 
     401                .depend = ((1 << SSB_PMURES_4325_RX_PWRSW_PU) | 
     402                           (1 << SSB_PMURES_4325_TX_PWRSW_PU) | 
     403                           (1 << SSB_PMURES_4325_LOGEN_PWRSW_PU) | 
     404                           (1 << SSB_PMURES_4325_AFE_PWRSW_PU)), 
     405        }, 
     406}; 
     407 
     408static void ssb_pmu_resources_init(struct ssb_chipcommon *cc) 
     409{ 
     410        struct ssb_bus *bus = cc->dev->bus; 
     411        u32 min_msk = 0, max_msk = 0; 
     412        unsigned int i; 
     413        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
     414        unsigned int updown_tab_size; 
     415        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
     416        unsigned int depend_tab_size; 
     417 
     418        switch (bus->chip_id) { 
     419        case 0x4312: 
     420                /* We keep the default settings: 
     421                 * min_msk = 0xCBB 
     422                 * max_msk = 0x7FFFF 
     423                 */ 
     424                break; 
     425        case 0x4325: 
     426                /* Power OTP down later. */ 
     427                min_msk = (1 << SSB_PMURES_4325_CBUCK_BURST) | 
     428                          (1 << SSB_PMURES_4325_LNLDO2_PU); 
     429                if (chipco_read32(cc, SSB_CHIPCO_CHIPSTAT) & 
     430                    SSB_CHIPCO_CHST_4325_PMUTOP_2B) 
     431                        min_msk |= (1 << SSB_PMURES_4325_CLDO_CBUCK_BURST); 
     432                /* The PLL may turn on, if it decides so. */ 
     433                max_msk = 0xFFFFF; 
     434                updown_tab = pmu_res_updown_tab_4325a0; 
     435                updown_tab_size = ARRAY_SIZE(pmu_res_updown_tab_4325a0); 
     436                depend_tab = pmu_res_depend_tab_4325a0; 
     437                depend_tab_size = ARRAY_SIZE(pmu_res_depend_tab_4325a0); 
     438                break; 
     439        case 0x4328: 
     440                min_msk = (1 << SSB_PMURES_4328_EXT_SWITCHER_PWM) | 
     441                          (1 << SSB_PMURES_4328_BB_SWITCHER_PWM) | 
     442                          (1 << SSB_PMURES_4328_XTAL_EN); 
     443                /* The PLL may turn on, if it decides so. */ 
     444                max_msk = 0xFFFFF; 
     445                updown_tab = pmu_res_updown_tab_4328a0; 
     446                updown_tab_size = ARRAY_SIZE(pmu_res_updown_tab_4328a0); 
     447                depend_tab = pmu_res_depend_tab_4328a0; 
     448                depend_tab_size = ARRAY_SIZE(pmu_res_depend_tab_4328a0); 
     449                break; 
     450        case 0x5354: 
     451                /* The PLL may turn on, if it decides so. */ 
     452                max_msk = 0xFFFFF; 
     453                break; 
     454        default: 
     455                ssb_printk(KERN_ERR PFX 
     456                           "ERROR: PMU resource config unknown for device %04X\n", 
     457                           bus->chip_id); 
     458        } 
     459 
     460        if (updown_tab) { 
     461                for (i = 0; i < updown_tab_size; i++) { 
     462                        chipco_write32(cc, SSB_CHIPCO_PMU_RES_TABSEL, 
     463                                       updown_tab[i].resource); 
     464                        chipco_write32(cc, SSB_CHIPCO_PMU_RES_UPDNTM, 
     465                                       updown_tab[i].updown); 
     466                } 
     467        } 
     468        if (depend_tab) { 
     469                for (i = 0; i < depend_tab_size; i++) { 
     470                        chipco_write32(cc, SSB_CHIPCO_PMU_RES_TABSEL, 
     471                                       depend_tab[i].resource); 
     472                        switch (depend_tab[i].task) { 
     473                        case PMU_RES_DEP_SET: 
     474                                chipco_write32(cc, SSB_CHIPCO_PMU_RES_DEPMSK, 
     475                                               depend_tab[i].depend); 
     476                                break; 
     477                        case PMU_RES_DEP_ADD: 
     478                                chipco_set32(cc, SSB_CHIPCO_PMU_RES_DEPMSK, 
     479                                             depend_tab[i].depend); 
     480                                break; 
     481                        case PMU_RES_DEP_REMOVE: 
     482                                chipco_mask32(cc, SSB_CHIPCO_PMU_RES_DEPMSK, 
     483                                              ~(depend_tab[i].depend)); 
     484                                break; 
     485                        default: 
     486                                SSB_WARN_ON(1); 
     487                        } 
     488                } 
     489        } 
     490 
     491        /* Set the resource masks. */ 
     492        if (min_msk) 
     493                chipco_write32(cc, SSB_CHIPCO_PMU_MINRES_MSK, min_msk); 
     494        if (max_msk) 
     495                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
     496} 
     497 
     498void ssb_pmu_init(struct ssb_chipcommon *cc) 
     499{ 
     500        struct ssb_bus *bus = cc->dev->bus; 
     501        u32 pmucap; 
     502 
     503        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
     504                return; 
     505 
     506        pmucap = chipco_read32(cc, SSB_CHIPCO_PMU_CAP); 
     507        cc->pmu.rev = (pmucap & SSB_CHIPCO_PMU_CAP_REVISION); 
     508 
     509        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
     510                    cc->pmu.rev, pmucap); 
     511 
     512        if (cc->pmu.rev >= 1) { 
     513                if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) { 
     514                        chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     515                                      ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     516                } else { 
     517                        chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     518                                     SSB_CHIPCO_PMU_CTL_NOILPONW); 
     519                } 
     520        } 
     521        ssb_pmu_pll_init(cc); 
     522        ssb_pmu_resources_init(cc); 
     523} 
     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/Kconfig

    a b config SSB_B43_PCI_BRIDGE 
    5353 
    5454config SSB_PCMCIAHOST_POSSIBLE 
    5555        bool 
    56         depends on SSB && (PCMCIA = y || PCMCIA = SSB) && EXPERIMENTAL 
     56        depends on SSB && (PCMCIA = y || PCMCIA = SSB) 
    5757        default y 
    5858 
    5959config SSB_PCMCIAHOST 
    60         bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)" 
     60        bool "Support for SSB on PCMCIA-bus host" 
    6161        depends on SSB_PCMCIAHOST_POSSIBLE 
    6262        select SSB_SPROM 
    6363        help 
    config SSB_DRIVER_PCICORE 
    107107          If unsure, say Y 
    108108 
    109109config SSB_PCICORE_HOSTMODE 
    110         bool "Hostmode support for SSB PCI core (EXPERIMENTAL)" 
    111         depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS && EXPERIMENTAL 
     110        bool "Hostmode support for SSB PCI core" 
     111        depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS 
    112112        help 
    113113          PCIcore hostmode operation (external PCI bus). 
    114114 
    115115config SSB_DRIVER_MIPS 
    116         bool "SSB Broadcom MIPS core driver (EXPERIMENTAL)" 
    117         depends on SSB && MIPS && EXPERIMENTAL 
     116        bool "SSB Broadcom MIPS core driver" 
     117        depends on SSB && MIPS 
    118118        select SSB_SERIAL 
    119119        help 
    120120          Driver for the Sonics Silicon Backplane attached 
    config SSB_DRIVER_MIPS 
    126126config SSB_EMBEDDED 
    127127        bool 
    128128        depends on SSB_DRIVER_MIPS 
     129        select USB_EHCI_HCD_SSB if USB_EHCI_HCD 
     130        select USB_OHCI_HCD_SSB if USB_OHCI_HCD 
    129131        default y 
    130132 
    131133config SSB_DRIVER_EXTIF 
    132         bool "SSB Broadcom EXTIF core driver (EXPERIMENTAL)" 
    133         depends on SSB_DRIVER_MIPS && EXPERIMENTAL 
     134        bool "SSB Broadcom EXTIF core driver" 
     135        depends on SSB_DRIVER_MIPS 
    134136        help 
    135137          Driver for the Sonics Silicon Backplane attached 
    136138          Broadcom EXTIF core. 
  • drivers/ssb/Makefile

    a b ssb-$(CONFIG_SSB_PCMCIAHOST) += pcmcia. 
    99 
    1010# built-in drivers 
    1111ssb-y                                   += driver_chipcommon.o 
     12ssb-y                                   += driver_chipcommon_pmu.o 
    1213ssb-$(CONFIG_SSB_DRIVER_MIPS)           += driver_mipscore.o 
    1314ssb-$(CONFIG_SSB_DRIVER_EXTIF)          += driver_extif.o 
    1415ssb-$(CONFIG_SSB_DRIVER_PCICORE)        += driver_pcicore.o 
  • drivers/ssb/b43_pci_bridge.c

    a b  
    1818 
    1919static const struct pci_device_id b43_pci_bridge_tbl[] = { 
    2020        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4301) }, 
     21        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4306) }, 
    2122        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4307) }, 
    2223        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4311) }, 
    2324        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) }, 
     25        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4315) }, 
    2426        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) }, 
    2527        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) }, 
    2628        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) }, 
    static const struct pci_device_id b43_pc 
    2931        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) }, 
    3032        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4328) }, 
    3133        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4329) }, 
     34        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x432b) }, 
    3235        { 0, }, 
    3336}; 
    3437MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl); 
  • drivers/ssb/main.c

    a b static int ssb_devices_register(struct s 
    473473                case SSB_BUSTYPE_SSB: 
    474474                        dev->dma_mask = &dev->coherent_dma_mask; 
    475475                        break; 
     476                default: 
     477                        break; 
    476478                } 
    477479 
    478480                sdev->dev = dev; 
    static int __init ssb_modinit(void) 
    13591361        ssb_buses_lock(); 
    13601362        err = ssb_attach_queued_buses(); 
    13611363        ssb_buses_unlock(); 
    1362         if (err) 
     1364        if (err) { 
    13631365                bus_unregister(&ssb_bustype); 
     1366                goto out; 
     1367        } 
    13641368 
    13651369        err = b43_pci_ssb_bridge_init(); 
    13661370        if (err) { 
    static int __init ssb_modinit(void) 
    13761380                /* don't fail SSB init because of this */ 
    13771381                err = 0; 
    13781382        } 
    1379  
     1383out: 
    13801384        return err; 
    13811385} 
    13821386/* 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_r45(struct ssb 
    467473        /* TODO - get remaining rev 4 stuff needed */ 
    468474} 
    469475 
     476static void sprom_extract_r8(struct ssb_sprom *out, const u16 *in) 
     477{ 
     478        int i; 
     479        u16 v; 
     480 
     481        /* extract the MAC address */ 
     482        for (i = 0; i < 3; i++) { 
     483                v = in[SPOFF(SSB_SPROM8_IL0MAC) + i]; 
     484                *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v); 
     485        } 
     486        SPEX(country_code, SSB_SPROM8_CCODE, 0xFFFF, 0); 
     487        SPEX(boardflags_lo, SSB_SPROM8_BFLLO, 0xFFFF, 0); 
     488        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); 
     491        SPEX(ant_available_a, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_A, 
     492             SSB_SPROM8_ANTAVAIL_A_SHIFT); 
     493        SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG, 
     494             SSB_SPROM8_ANTAVAIL_BG_SHIFT); 
     495        SPEX(maxpwr_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_MAXP_BG_MASK, 0); 
     496        SPEX(itssi_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_ITSSI_BG, 
     497             SSB_SPROM8_ITSSI_BG_SHIFT); 
     498        SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0); 
     499        SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A, 
     500             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); 
     504        SPEX(gpio0, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P0, 0); 
     505        SPEX(gpio1, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P1, 
     506             SSB_SPROM8_GPIOA_P1_SHIFT); 
     507        SPEX(gpio2, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P2, 0); 
     508        SPEX(gpio3, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P3, 
     509             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); 
     550 
     551        /* Extract the antenna gain values. */ 
     552        SPEX(antenna_gain.ghz24.a0, SSB_SPROM8_AGAIN01, 
     553             SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT); 
     554        SPEX(antenna_gain.ghz24.a1, SSB_SPROM8_AGAIN01, 
     555             SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT); 
     556        SPEX(antenna_gain.ghz24.a2, SSB_SPROM8_AGAIN23, 
     557             SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT); 
     558        SPEX(antenna_gain.ghz24.a3, SSB_SPROM8_AGAIN23, 
     559             SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT); 
     560        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
     561               sizeof(out->antenna_gain.ghz5)); 
     562 
     563        /* TODO - get remaining rev 8 stuff needed */ 
     564} 
     565 
    470566static int sprom_extract(struct ssb_bus *bus, struct ssb_sprom *out, 
    471567                         const u16 *in, u16 size) 
    472568{ 
    static int sprom_extract(struct ssb_bus  
    487583                out->revision = 4; 
    488584                sprom_extract_r45(out, in); 
    489585        } else { 
    490                 if (out->revision == 0) 
    491                         goto unsupported; 
    492                 if (out->revision >= 1 && out->revision <= 3) { 
     586                switch (out->revision) { 
     587                case 1: 
     588                case 2: 
     589                case 3: 
    493590                        sprom_extract_r123(out, in); 
    494                 } 
    495                 if (out->revision == 4 || out->revision == 5) 
     591                        break; 
     592                case 4: 
     593                case 5: 
    496594                        sprom_extract_r45(out, in); 
    497                 if (out->revision > 5) 
    498                         goto unsupported; 
     595                        break; 
     596                case 8: 
     597                        sprom_extract_r8(out, in); 
     598                        break; 
     599                default: 
     600                        ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     601                                   "  revision %d detected. Will extract" 
     602                                   " v1\n", out->revision); 
     603                        out->revision = 1; 
     604                        sprom_extract_r123(out, in); 
     605                } 
    499606        } 
    500607 
    501608        if (out->boardflags_lo == 0xFFFF) 
    static int sprom_extract(struct ssb_bus  
    504611                out->boardflags_hi = 0;  /* per specs */ 
    505612 
    506613        return 0; 
    507 unsupported: 
    508         ssb_printk(KERN_WARNING PFX "Unsupported SPROM revision %d " 
    509                    "detected. Will extract v1\n", out->revision); 
    510         sprom_extract_r123(out, in); 
    511         return 0; 
    512614} 
    513615 
    514616static int ssb_pci_sprom_get(struct ssb_bus *bus, 
  • 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. */ 
  • include/linux/ssb/ssb_driver_chipcommon.h

    a b  
    181181#define SSB_CHIPCO_PROG_WAITCNT         0x0124 
    182182#define SSB_CHIPCO_FLASH_CFG            0x0128 
    183183#define SSB_CHIPCO_FLASH_WAITCNT        0x012C 
     184#define SSB_CHIPCO_CLKCTLST             0x01E0 /* Clock control and status (rev >= 20) */ 
     185#define  SSB_CHIPCO_CLKCTLST_FORCEALP   0x00000001 /* Force ALP request */ 
     186#define  SSB_CHIPCO_CLKCTLST_FORCEHT    0x00000002 /* Force HT request */ 
     187#define  SSB_CHIPCO_CLKCTLST_FORCEILP   0x00000004 /* Force ILP request */ 
     188#define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */ 
     189#define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ  0x00000010 /* HT available request */ 
     190#define  SSB_CHIPCO_CLKCTLST_HWCROFF    0x00000020 /* Force HW clock request off */ 
     191#define  SSB_CHIPCO_CLKCTLST_HAVEHT     0x00010000 /* HT available */ 
     192#define  SSB_CHIPCO_CLKCTLST_HAVEALP    0x00020000 /* APL available */ 
     193#define SSB_CHIPCO_HW_WORKAROUND        0x01E4 /* Hardware workaround (rev >= 20) */ 
    184194#define SSB_CHIPCO_UART0_DATA           0x0300 
    185195#define SSB_CHIPCO_UART0_IMR            0x0304 
    186196#define SSB_CHIPCO_UART0_FCR            0x0308 
     
    197207#define SSB_CHIPCO_UART1_LSR            0x0414 
    198208#define SSB_CHIPCO_UART1_MSR            0x0418 
    199209#define SSB_CHIPCO_UART1_SCRATCH        0x041C 
     210/* PMU registers (rev >= 20) */ 
     211#define SSB_CHIPCO_PMU_CTL                      0x0600 /* PMU control */ 
     212#define  SSB_CHIPCO_PMU_CTL_ILP_DIV             0xFFFF0000 /* ILP div mask */ 
     213#define  SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT       16 
     214#define  SSB_CHIPCO_PMU_CTL_NOILPONW            0x00000200 /* No ILP on wait */ 
     215#define  SSB_CHIPCO_PMU_CTL_HTREQEN             0x00000100 /* HT req enable */ 
     216#define  SSB_CHIPCO_PMU_CTL_ALPREQEN            0x00000080 /* ALP req enable */ 
     217#define  SSB_CHIPCO_PMU_CTL_XTALFREQ            0x0000007C /* Crystal freq */ 
     218#define  SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT      2 
     219#define  SSB_CHIPCO_PMU_CTL_ILPDIVEN            0x00000002 /* ILP div enable */ 
     220#define  SSB_CHIPCO_PMU_CTL_LPOSEL              0x00000001 /* LPO sel */ 
     221#define SSB_CHIPCO_PMU_CAP                      0x0604 /* PMU capabilities */ 
     222#define  SSB_CHIPCO_PMU_CAP_REVISION            0x000000FF /* Revision mask */ 
     223#define SSB_CHIPCO_PMU_STAT                     0x0608 /* PMU status */ 
     224#define  SSB_CHIPCO_PMU_STAT_INTPEND            0x00000040 /* Interrupt pending */ 
     225#define  SSB_CHIPCO_PMU_STAT_SBCLKST            0x00000030 /* Backplane clock status? */ 
     226#define  SSB_CHIPCO_PMU_STAT_HAVEALP            0x00000008 /* ALP available */ 
     227#define  SSB_CHIPCO_PMU_STAT_HAVEHT             0x00000004 /* HT available */ 
     228#define  SSB_CHIPCO_PMU_STAT_RESINIT            0x00000003 /* Res init */ 
     229#define SSB_CHIPCO_PMU_RES_STAT                 0x060C /* PMU res status */ 
     230#define SSB_CHIPCO_PMU_RES_PEND                 0x0610 /* PMU res pending */ 
     231#define SSB_CHIPCO_PMU_TIMER                    0x0614 /* PMU timer */ 
     232#define SSB_CHIPCO_PMU_MINRES_MSK               0x0618 /* PMU min res mask */ 
     233#define SSB_CHIPCO_PMU_MAXRES_MSK               0x061C /* PMU max res mask */ 
     234#define SSB_CHIPCO_PMU_RES_TABSEL               0x0620 /* PMU res table sel */ 
     235#define SSB_CHIPCO_PMU_RES_DEPMSK               0x0624 /* PMU res dep mask */ 
     236#define SSB_CHIPCO_PMU_RES_UPDNTM               0x0628 /* PMU res updown timer */ 
     237#define SSB_CHIPCO_PMU_RES_TIMER                0x062C /* PMU res timer */ 
     238#define SSB_CHIPCO_PMU_CLKSTRETCH               0x0630 /* PMU clockstretch */ 
     239#define SSB_CHIPCO_PMU_WATCHDOG                 0x0634 /* PMU watchdog */ 
     240#define SSB_CHIPCO_PMU_RES_REQTS                0x0640 /* PMU res req timer sel */ 
     241#define SSB_CHIPCO_PMU_RES_REQT                 0x0644 /* PMU res req timer */ 
     242#define SSB_CHIPCO_PMU_RES_REQM                 0x0648 /* PMU res req mask */ 
     243#define SSB_CHIPCO_CHIPCTL_ADDR                 0x0650 
     244#define SSB_CHIPCO_CHIPCTL_DATA                 0x0654 
     245#define SSB_CHIPCO_REGCTL_ADDR                  0x0658 
     246#define SSB_CHIPCO_REGCTL_DATA                  0x065C 
     247#define SSB_CHIPCO_PLLCTL_ADDR                  0x0660 
     248#define SSB_CHIPCO_PLLCTL_DATA                  0x0664 
     249 
     250 
     251 
     252/** PMU PLL registers */ 
     253 
     254/* PMU rev 0 PLL registers */ 
     255#define SSB_PMU0_PLLCTL0                        0 
     256#define  SSB_PMU0_PLLCTL0_PDIV_MSK              0x00000001 
     257#define  SSB_PMU0_PLLCTL0_PDIV_FREQ             25000 /* kHz */ 
     258#define SSB_PMU0_PLLCTL1                        1 
     259#define  SSB_PMU0_PLLCTL1_WILD_IMSK             0xF0000000 /* Wild int mask (low nibble) */ 
     260#define  SSB_PMU0_PLLCTL1_WILD_IMSK_SHIFT       28 
     261#define  SSB_PMU0_PLLCTL1_WILD_FMSK             0x0FFFFF00 /* Wild frac mask */ 
     262#define  SSB_PMU0_PLLCTL1_WILD_FMSK_SHIFT       8 
     263#define  SSB_PMU0_PLLCTL1_STOPMOD               0x00000040 /* Stop mod */ 
     264#define SSB_PMU0_PLLCTL2                        2 
     265#define  SSB_PMU0_PLLCTL2_WILD_IMSKHI           0x0000000F /* Wild int mask (high nibble) */ 
     266#define  SSB_PMU0_PLLCTL2_WILD_IMSKHI_SHIFT     0 
     267 
     268/* PMU rev 1 PLL registers */ 
     269#define SSB_PMU1_PLLCTL0                        0 
     270#define  SSB_PMU1_PLLCTL0_P1DIV                 0x00F00000 /* P1 div */ 
     271#define  SSB_PMU1_PLLCTL0_P1DIV_SHIFT           20 
     272#define  SSB_PMU1_PLLCTL0_P2DIV                 0x0F000000 /* P2 div */ 
     273#define  SSB_PMU1_PLLCTL0_P2DIV_SHIFT           24 
     274#define SSB_PMU1_PLLCTL1                        1 
     275#define  SSB_PMU1_PLLCTL1_M1DIV                 0x000000FF /* M1 div */ 
     276#define  SSB_PMU1_PLLCTL1_M1DIV_SHIFT           0 
     277#define  SSB_PMU1_PLLCTL1_M2DIV                 0x0000FF00 /* M2 div */ 
     278#define  SSB_PMU1_PLLCTL1_M2DIV_SHIFT           8 
     279#define  SSB_PMU1_PLLCTL1_M3DIV                 0x00FF0000 /* M3 div */ 
     280#define  SSB_PMU1_PLLCTL1_M3DIV_SHIFT           16 
     281#define  SSB_PMU1_PLLCTL1_M4DIV                 0xFF000000 /* M4 div */ 
     282#define  SSB_PMU1_PLLCTL1_M4DIV_SHIFT           24 
     283#define SSB_PMU1_PLLCTL2                        2 
     284#define  SSB_PMU1_PLLCTL2_M5DIV                 0x000000FF /* M5 div */ 
     285#define  SSB_PMU1_PLLCTL2_M5DIV_SHIFT           0 
     286#define  SSB_PMU1_PLLCTL2_M6DIV                 0x0000FF00 /* M6 div */ 
     287#define  SSB_PMU1_PLLCTL2_M6DIV_SHIFT           8 
     288#define  SSB_PMU1_PLLCTL2_NDIVMODE              0x000E0000 /* NDIV mode */ 
     289#define  SSB_PMU1_PLLCTL2_NDIVMODE_SHIFT        17 
     290#define  SSB_PMU1_PLLCTL2_NDIVINT               0x1FF00000 /* NDIV int */ 
     291#define  SSB_PMU1_PLLCTL2_NDIVINT_SHIFT         20 
     292#define SSB_PMU1_PLLCTL3                        3 
     293#define  SSB_PMU1_PLLCTL3_NDIVFRAC              0x00FFFFFF /* NDIV frac */ 
     294#define  SSB_PMU1_PLLCTL3_NDIVFRAC_SHIFT        0 
     295#define SSB_PMU1_PLLCTL4                        4 
     296#define SSB_PMU1_PLLCTL5                        5 
     297#define  SSB_PMU1_PLLCTL5_CLKDRV                0xFFFFFF00 /* clk drv */ 
     298#define  SSB_PMU1_PLLCTL5_CLKDRV_SHIFT          8 
     299 
     300/* BCM4312 PLL resource numbers. */ 
     301#define SSB_PMURES_4312_SWITCHER_BURST          0 
     302#define SSB_PMURES_4312_SWITCHER_PWM            1 
     303#define SSB_PMURES_4312_PA_REF_LDO              2 
     304#define SSB_PMURES_4312_CORE_LDO_BURST          3 
     305#define SSB_PMURES_4312_CORE_LDO_PWM            4 
     306#define SSB_PMURES_4312_RADIO_LDO               5 
     307#define SSB_PMURES_4312_ILP_REQUEST             6 
     308#define SSB_PMURES_4312_BG_FILTBYP              7 
     309#define SSB_PMURES_4312_TX_FILTBYP              8 
     310#define SSB_PMURES_4312_RX_FILTBYP              9 
     311#define SSB_PMURES_4312_XTAL_PU                 10 
     312#define SSB_PMURES_4312_ALP_AVAIL               11 
     313#define SSB_PMURES_4312_BB_PLL_FILTBYP          12 
     314#define SSB_PMURES_4312_RF_PLL_FILTBYP          13 
     315#define SSB_PMURES_4312_HT_AVAIL                14 
     316 
     317/* BCM4325 PLL resource numbers. */ 
     318#define SSB_PMURES_4325_BUCK_BOOST_BURST        0 
     319#define SSB_PMURES_4325_CBUCK_BURST             1 
     320#define SSB_PMURES_4325_CBUCK_PWM               2 
     321#define SSB_PMURES_4325_CLDO_CBUCK_BURST        3 
     322#define SSB_PMURES_4325_CLDO_CBUCK_PWM          4 
     323#define SSB_PMURES_4325_BUCK_BOOST_PWM          5 
     324#define SSB_PMURES_4325_ILP_REQUEST             6 
     325#define SSB_PMURES_4325_ABUCK_BURST             7 
     326#define SSB_PMURES_4325_ABUCK_PWM               8 
     327#define SSB_PMURES_4325_LNLDO1_PU               9 
     328#define SSB_PMURES_4325_LNLDO2_PU               10 
     329#define SSB_PMURES_4325_LNLDO3_PU               11 
     330#define SSB_PMURES_4325_LNLDO4_PU               12 
     331#define SSB_PMURES_4325_XTAL_PU                 13 
     332#define SSB_PMURES_4325_ALP_AVAIL               14 
     333#define SSB_PMURES_4325_RX_PWRSW_PU             15 
     334#define SSB_PMURES_4325_TX_PWRSW_PU             16 
     335#define SSB_PMURES_4325_RFPLL_PWRSW_PU          17 
     336#define SSB_PMURES_4325_LOGEN_PWRSW_PU          18 
     337#define SSB_PMURES_4325_AFE_PWRSW_PU            19 
     338#define SSB_PMURES_4325_BBPLL_PWRSW_PU          20 
     339#define SSB_PMURES_4325_HT_AVAIL                21 
     340 
     341/* BCM4328 PLL resource numbers. */ 
     342#define SSB_PMURES_4328_EXT_SWITCHER_PWM        0 
     343#define SSB_PMURES_4328_BB_SWITCHER_PWM         1 
     344#define SSB_PMURES_4328_BB_SWITCHER_BURST       2 
     345#define SSB_PMURES_4328_BB_EXT_SWITCHER_BURST   3 
     346#define SSB_PMURES_4328_ILP_REQUEST             4 
     347#define SSB_PMURES_4328_RADIO_SWITCHER_PWM      5 
     348#define SSB_PMURES_4328_RADIO_SWITCHER_BURST    6 
     349#define SSB_PMURES_4328_ROM_SWITCH              7 
     350#define SSB_PMURES_4328_PA_REF_LDO              8 
     351#define SSB_PMURES_4328_RADIO_LDO               9 
     352#define SSB_PMURES_4328_AFE_LDO                 10 
     353#define SSB_PMURES_4328_PLL_LDO                 11 
     354#define SSB_PMURES_4328_BG_FILTBYP              12 
     355#define SSB_PMURES_4328_TX_FILTBYP              13 
     356#define SSB_PMURES_4328_RX_FILTBYP              14 
     357#define SSB_PMURES_4328_XTAL_PU                 15 
     358#define SSB_PMURES_4328_XTAL_EN                 16 
     359#define SSB_PMURES_4328_BB_PLL_FILTBYP          17 
     360#define SSB_PMURES_4328_RF_PLL_FILTBYP          18 
     361#define SSB_PMURES_4328_BB_PLL_PU               19 
     362 
     363/* BCM5354 PLL resource numbers. */ 
     364#define SSB_PMURES_5354_EXT_SWITCHER_PWM        0 
     365#define SSB_PMURES_5354_BB_SWITCHER_PWM         1 
     366#define SSB_PMURES_5354_BB_SWITCHER_BURST       2 
     367#define SSB_PMURES_5354_BB_EXT_SWITCHER_BURST   3 
     368#define SSB_PMURES_5354_ILP_REQUEST             4 
     369#define SSB_PMURES_5354_RADIO_SWITCHER_PWM      5 
     370#define SSB_PMURES_5354_RADIO_SWITCHER_BURST    6 
     371#define SSB_PMURES_5354_ROM_SWITCH              7 
     372#define SSB_PMURES_5354_PA_REF_LDO              8 
     373#define SSB_PMURES_5354_RADIO_LDO               9 
     374#define SSB_PMURES_5354_AFE_LDO                 10 
     375#define SSB_PMURES_5354_PLL_LDO                 11 
     376#define SSB_PMURES_5354_BG_FILTBYP              12 
     377#define SSB_PMURES_5354_TX_FILTBYP              13 
     378#define SSB_PMURES_5354_RX_FILTBYP              14 
     379#define SSB_PMURES_5354_XTAL_PU                 15 
     380#define SSB_PMURES_5354_XTAL_EN                 16 
     381#define SSB_PMURES_5354_BB_PLL_FILTBYP          17 
     382#define SSB_PMURES_5354_RF_PLL_FILTBYP          18 
     383#define SSB_PMURES_5354_BB_PLL_PU               19 
     384 
     385 
     386 
     387/** Chip specific Chip-Status register contents. */ 
     388#define SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL      0x00000003 
     389#define SSB_CHIPCO_CHST_4325_DEFCIS_SEL         0 /* OTP is powered up, use def. CIS, no SPROM */ 
     390#define SSB_CHIPCO_CHST_4325_SPROM_SEL          1 /* OTP is powered up, SPROM is present */ 
     391#define SSB_CHIPCO_CHST_4325_OTP_SEL            2 /* OTP is powered up, no SPROM */ 
     392#define SSB_CHIPCO_CHST_4325_OTP_PWRDN          3 /* OTP is powered down, SPROM is present */ 
     393#define SSB_CHIPCO_CHST_4325_SDIO_USB_MODE      0x00000004 
     394#define SSB_CHIPCO_CHST_4325_SDIO_USB_MODE_SHIFT  2 
     395#define SSB_CHIPCO_CHST_4325_RCAL_VALID         0x00000008 
     396#define SSB_CHIPCO_CHST_4325_RCAL_VALID_SHIFT   3 
     397#define SSB_CHIPCO_CHST_4325_RCAL_VALUE         0x000001F0 
     398#define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT   4 
     399#define SSB_CHIPCO_CHST_4325_PMUTOP_2B          0x00000200 /* 1 for 2b, 0 for to 2a */ 
    200400 
    201401 
    202402 
     
    353553struct ssb_device; 
    354554struct ssb_serial_port; 
    355555 
     556/* Data for the PMU, if available. 
     557 * Check availability with ((struct ssb_chipcommon)->capabilities & SSB_CHIPCO_CAP_PMU) 
     558 */ 
     559struct ssb_chipcommon_pmu { 
     560        u8 rev;                 /* PMU revision */ 
     561        u32 crystalfreq;        /* The active crystal frequency (in kHz) */ 
     562}; 
     563 
    356564struct ssb_chipcommon { 
    357565        struct ssb_device *dev; 
    358566        u32 capabilities; 
    359567        /* Fast Powerup Delay constant */ 
    360568        u16 fast_pwrup_delay; 
     569        struct ssb_chipcommon_pmu pmu; 
    361570}; 
    362571 
    363572static inline bool ssb_chipco_available(struct ssb_chipcommon *cc) 
    static inline bool ssb_chipco_available( 
    365574        return (cc->dev != NULL); 
    366575} 
    367576 
     577/* Register access */ 
     578#define chipco_read32(cc, offset)       ssb_read32((cc)->dev, offset) 
     579#define chipco_write32(cc, offset, val) ssb_write32((cc)->dev, offset, val) 
     580 
     581#define chipco_mask32(cc, offset, mask) \ 
     582                chipco_write32(cc, offset, chipco_read32(cc, offset) & (mask)) 
     583#define chipco_set32(cc, offset, set) \ 
     584                chipco_write32(cc, offset, chipco_read32(cc, offset) | (set)) 
     585#define chipco_maskset32(cc, offset, mask, set) \ 
     586                chipco_write32(cc, offset, (chipco_read32(cc, offset) & (mask)) | (set)) 
     587 
    368588extern void ssb_chipcommon_init(struct ssb_chipcommon *cc); 
    369589 
    370590extern void ssb_chipco_suspend(struct ssb_chipcommon *cc); 
    extern int ssb_chipco_serial_init(struct 
    406626                                  struct ssb_serial_port *ports); 
    407627#endif /* CONFIG_SSB_SERIAL */ 
    408628 
     629/* PMU support */ 
     630extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
     631 
     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); 
     642 
    409643#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)) 
     
    326326#define  SSB_SPROM5_GPIOB_P3            0xFF00  /* Pin 3 */ 
    327327#define  SSB_SPROM5_GPIOB_P3_SHIFT      8 
    328328 
     329/* SPROM Revision 8 */ 
     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) */ 
     335#define SSB_SPROM8_IL0MAC               0x108C  /* 6 byte MAC address */ 
     336#define SSB_SPROM8_CCODE                0x1092  /* 2 byte country code */ 
     337#define SSB_SPROM8_ANTAVAIL             0x109C  /* Antenna available bitfields*/ 
     338#define SSB_SPROM8_ANTAVAIL_A           0xFF00  /* A-PHY bitfield */ 
     339#define SSB_SPROM8_ANTAVAIL_A_SHIFT     8 
     340#define SSB_SPROM8_ANTAVAIL_BG          0x00FF  /* B-PHY and G-PHY bitfield */ 
     341#define SSB_SPROM8_ANTAVAIL_BG_SHIFT    0 
     342#define SSB_SPROM8_AGAIN01              0x109E  /* Antenna Gain (in dBm Q5.2) */ 
     343#define  SSB_SPROM8_AGAIN0              0x00FF  /* Antenna 0 */ 
     344#define  SSB_SPROM8_AGAIN0_SHIFT        0 
     345#define  SSB_SPROM8_AGAIN1              0xFF00  /* Antenna 1 */ 
     346#define  SSB_SPROM8_AGAIN1_SHIFT        8 
     347#define SSB_SPROM8_AGAIN23              0x10A0 
     348#define  SSB_SPROM8_AGAIN2              0x00FF  /* Antenna 2 */ 
     349#define  SSB_SPROM8_AGAIN2_SHIFT        0 
     350#define  SSB_SPROM8_AGAIN3              0xFF00  /* Antenna 3 */ 
     351#define  SSB_SPROM8_AGAIN3_SHIFT        8 
     352#define SSB_SPROM8_GPIOA                0x1096  /*Gen. Purpose IO # 0 and 1 */ 
     353#define  SSB_SPROM8_GPIOA_P0            0x00FF  /* Pin 0 */ 
     354#define  SSB_SPROM8_GPIOA_P1            0xFF00  /* Pin 1 */ 
     355#define  SSB_SPROM8_GPIOA_P1_SHIFT      8 
     356#define SSB_SPROM8_GPIOB                0x1098  /* Gen. Purpose IO # 2 and 3 */ 
     357#define  SSB_SPROM8_GPIOB_P2            0x00FF  /* Pin 2 */ 
     358#define  SSB_SPROM8_GPIOB_P3            0xFF00  /* Pin 3 */ 
     359#define  SSB_SPROM8_GPIOB_P3_SHIFT      8 
     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 */ 
     390#define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */ 
     391#define  SSB_SPROM8_ITSSI_BG_SHIFT      8 
     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 */ 
     397#define  SSB_SPROM8_ITSSI_A             0xFF00  /* Mask for path 1 itssi_a */ 
     398#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 */ 
    329417 
    330418/* Values for SSB_SPROM1_BINF_CCODE */ 
    331419enum { 
  • drivers/ssb/driver_chipcommon.c

    a b enum ssb_clksrc { 
    2626}; 
    2727 
    2828 
    29 static inline u32 chipco_read32(struct ssb_chipcommon *cc, 
    30                                 u16 offset) 
    31 { 
    32         return ssb_read32(cc->dev, offset); 
    33 } 
    34  
    35 static inline void chipco_write32(struct ssb_chipcommon *cc, 
    36                                   u16 offset, 
    37                                   u32 value) 
    38 { 
    39         ssb_write32(cc->dev, offset, value); 
    40 } 
    41  
    4229static inline u32 chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset, 
    4330                                        u32 mask, u32 value) 
    4431{ 
  • 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.