Ticket #6580: asus.diff

File asus.diff, 36.7 KB (added by bernhardloos@…, 8 years ago)

booting kernel

  • arch/mips/bcm47xx/irq.c

    old new  
    3030#include <linux/irq.h> 
    3131#include <linux/pci.h> 
    3232#include <linux/ssb/ssb.h> 
     33#include <linux/ssb/ssb_driver_mips.h> 
    3334 
    3435#include <asm/irq_cpu.h> 
    3536 
     
    3738extern struct ssb_bus ssb_bcm47xx; 
    3839 
    3940 
    40 void plat_irq_dispatch(void) 
     41void asmlinkage plat_irq_dispatch(void) 
    4142{ 
    4243        u32 cause; 
    4344 
     
    6162 
    6263void __init arch_init_irq(void) 
    6364{ 
     65        if (ssb_bcm47xx.mipscore.dev->id.coreid == SSB_DEV_MIPS_74K) { 
     66                ssb_write32(ssb_bcm47xx.mipscore.dev, SSB_MIPS74K_INT_CONTROL(5), 1 << 31); 
     67        } 
     68        /* the kernel reads the timer irq from some register and beleave it's #5, but we route it to #7 */ 
     69        cp0_compare_irq = 7; 
    6470        mips_cpu_irq_init(); 
    6571} 
  • drivers/ssb/driver_chipcommon.c

    old new  
    258258void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, 
    259259                             u32 *plltype, u32 *n, u32 *m) 
    260260{ 
    261         if ((chipco_read32(cc, SSB_CHIPCO_CHIPID) & SSB_CHIPCO_IDMASK) == 0x5354) 
    262                 return; 
    263261        *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N); 
    264262        *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT); 
    265263        switch (*plltype) { 
     
    283281void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    284282                                 u32 *plltype, u32 *n, u32 *m) 
    285283{ 
    286         if ((chipco_read32(cc, SSB_CHIPCO_CHIPID) & SSB_CHIPCO_IDMASK) == 0x5354) 
    287                 return; 
    288284        *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N); 
    289285        *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT); 
    290286        switch (*plltype) { 
     
    407403                                                chipco_read32(cc, SSB_CHIPCO_CLOCK_M2)); 
    408404                div = 1; 
    409405        } else { 
    410                 if (ccrev == 20) { 
    411                         /* BCM5354 uses constant 25MHz clock */ 
    412                         baud_base = 25000000; 
    413                         div = 48; 
    414                         /* Set the override bit so we don't divide it */ 
    415                         chipco_write32(cc, SSB_CHIPCO_CORECTL, 
    416                                        chipco_read32(cc, SSB_CHIPCO_CORECTL) 
    417                                        | SSB_CHIPCO_CORECTL_UARTCLK0); 
    418                 } else if ((ccrev >= 11) && (ccrev != 15)) { 
    419                         /* Fixed ALP clock */ 
    420                         baud_base = 20000000; 
    421                         if (cc->capabilities & SSB_CHIPCO_CAP_PMU) { 
    422                                 /* FIXME: baud_base is different for devices with a PMU */ 
     406                if ((ccrev >= 11) && (ccrev != 15)) { 
     407                        if (cc->pmu.crystalfreq) 
     408                                baud_base = cc->pmu.crystalfreq * 1000; 
     409                        else { 
     410                                printk(KERN_WARNING "Crystal frequency not specified for BCM%x\n", bus->chip_id); 
    423411                                SSB_WARN_ON(1); 
     412                                baud_base = 20000000; 
    424413                        } 
    425                         div = 1; 
    426                         if (ccrev >= 21) { 
    427                                 /* Turn off UART clock before switching clocksource. */ 
    428                                 chipco_write32(cc, SSB_CHIPCO_CORECTL, 
    429                                                chipco_read32(cc, SSB_CHIPCO_CORECTL) 
    430                                                & ~SSB_CHIPCO_CORECTL_UARTCLKEN); 
    431                         } 
    432                         /* Set the override bit so we don't divide it */ 
    433                         chipco_write32(cc, SSB_CHIPCO_CORECTL, 
    434                                        chipco_read32(cc, SSB_CHIPCO_CORECTL) 
    435                                        | SSB_CHIPCO_CORECTL_UARTCLK0); 
     414 
     415                        if (ccrev == 20)  
     416                                div = 48; /* FIXME: this is not in the original broadcom code */ 
     417                        else 
     418                                div = 1; 
     419 
    436420                        if (ccrev >= 21) { 
    437421                                /* Re-enable the UART clock. */ 
    438422                                chipco_write32(cc, SSB_CHIPCO_CORECTL, 
  • drivers/ssb/driver_chipcommon_pmu.c

    old new  
    9191        u32 pmuctl, tmp, pllctl; 
    9292        unsigned int i; 
    9393 
    94         if ((bus->chip_id == 0x5354) && !crystalfreq) { 
    95                 /* The 5354 crystal freq is 25MHz */ 
    96                 crystalfreq = 25000; 
    97         } 
    9894        if (crystalfreq) 
    9995                e = pmu0_plltab_find_entry(crystalfreq); 
    10096        if (!e) 
     
    221217static void ssb_pmu1_pllinit_r0(struct ssb_chipcommon *cc, 
    222218                                u32 crystalfreq) 
    223219{ 
    224         struct ssb_bus *bus = cc->dev->bus; 
    225220        const struct pmu1_plltab_entry *e = NULL; 
    226221        u32 buffer_strength = 0; 
    227222        u32 tmp, pllctl, pmuctl; 
    228223        unsigned int i; 
    229224 
    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  
    237225        if (crystalfreq) 
    238226                e = pmu1_plltab_find_entry(crystalfreq); 
    239227        if (!e) 
     
    253241                   (crystalfreq / 1000), (crystalfreq % 1000)); 
    254242 
    255243        /* 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         } 
     244        chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK, 
     245                      ~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) | 
     246                        (1 << SSB_PMURES_4325_HT_AVAIL))); 
     247        chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, 
     248                      ~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) | 
     249                        (1 << SSB_PMURES_4325_HT_AVAIL))); 
     250        /* Adjust the BBPLL to 2 on all channels later. */ 
     251        buffer_strength = 0x222222; 
     252 
    270253        for (i = 1500; i; i--) { 
    271254                tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST); 
    272255                if (!(tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)) 
     
    325308 
    326309        switch (bus->chip_id) { 
    327310        case 0x4312: 
     311        case 0x4716: 
     312                /* We do not touch the PLL and assume 
     313                 * the default crystal settings work out-of-the-box. */ 
     314                cc->pmu.crystalfreq = 20000; 
     315                break; 
    328316        case 0x4325: 
    329317                ssb_pmu1_pllinit_r0(cc, crystalfreq); 
    330318                break; 
    331319        case 0x4328: 
    332         case 0x5354: 
    333320                ssb_pmu0_pllinit_r0(cc, crystalfreq); 
    334321                break; 
     322        case 0x5354: 
     323                ssb_pmu0_pllinit_r0(cc, crystalfreq ? crystalfreq : 25000); 
     324                break; 
    335325        default: 
    336326                ssb_printk(KERN_ERR PFX 
    337327                           "ERROR: PLL init unknown for device %04X\n", 
     
    405395        }, 
    406396}; 
    407397 
     398u32 ssb_pmu5_clock(struct ssb_chipcommon *cc, u32 m) 
     399{ 
     400        u32 tmp, div, ndiv, fdiv, p1, p2, fc; 
     401        u32 pll0 = 12; 
     402 
     403        tmp = ssb_chipco_pll_read(cc, pll0 + SSB_PMU5_PLL_P1P2_OFF); 
     404        p1 = (tmp & SSB_PMU5_PLL_P1_MASK) >> SSB_PMU5_PLL_P1_SHIFT; 
     405        p2 = (tmp & SSB_PMU5_PLL_P2_MASK) >> SSB_PMU5_PLL_P2_SHIFT; 
     406 
     407        tmp = ssb_chipco_pll_read(cc, pll0 + SSB_PMU5_PLL_M14_OFF); 
     408        div = (tmp >> ((m - 1) * SSB_PMU5_PLL_MDIV_WIDTH)) & SSB_PMU5_PLL_MDIV_MASK; 
     409 
     410        tmp = ssb_chipco_pll_read(cc, pll0 + SSB_PMU5_PLL_NM5_OFF); 
     411        ndiv = (tmp & SSB_PMU5_PLL_NDIV_MASK) >> SSB_PMU5_PLL_NDIV_SHIFT; 
     412 
     413        tmp = ssb_chipco_pll_read(cc, pll0 + SSB_PMU5_PLL_FMAB_OFF); 
     414        fdiv = tmp & SSB_PMU5_PLL_FDIV_MASK; 
     415 
     416        /* Do calculation in Mhz */ 
     417        fc = cc->pmu.crystalfreq / 1000; 
     418        fc = (ndiv * fc) + ((fdiv * fc) / (1 << 24)); 
     419        fc = (p1 * fc) / p2; 
     420         
     421        printk("%s: p1=%d, p2=%d, ndiv=%d(0x%x), fdiv=%d(0x%x), m%d=%d; fc=%d, clock=%d\n", 
     422               __FUNCTION__, p1, p2, ndiv, ndiv, fdiv, fdiv, m, div, fc, fc / div); 
     423 
     424        /* Return clock in Hertz */ 
     425        return ((fc / div) * 1000000); 
     426} 
     427 
    408428static void ssb_pmu_resources_init(struct ssb_chipcommon *cc) 
    409429{ 
    410430        struct ssb_bus *bus = cc->dev->bus; 
     
    422442                 * max_msk = 0x7FFFF 
    423443                 */ 
    424444                break; 
     445        case 0x4716: 
     446                break; 
    425447        case 0x4325: 
    426448                /* Power OTP down later. */ 
    427449                min_msk = (1 << SSB_PMURES_4325_CBUCK_BURST) | 
  • drivers/ssb/driver_mipscore.c

    old new  
    4949 
    5050static inline u32 ssb_irqflag(struct ssb_device *dev) 
    5151{ 
    52         u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG); 
    53         if (tpsflag) 
    54                 return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
    55         else 
    56                 /* not irq supported */ 
    57                 return 0x3f; 
    58 } 
    59  
    60 static struct ssb_device *find_device(struct ssb_device *rdev, int irqflag) 
    61 { 
    62         struct ssb_bus *bus = rdev->bus; 
    63         int i; 
    64         for (i = 0; i < bus->nr_devices; i++) { 
    65                 struct ssb_device *dev; 
    66                 dev = &(bus->devices[i]); 
    67                 if (ssb_irqflag(dev) == irqflag) 
    68                         return dev; 
     52        if (dev->bus->is_ai_bus) { 
     53                return (ssb_ai_read32(dev, SSB_AI_oobselouta30) & 0x1f); 
     54        } else { 
     55                u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG); 
     56                if (tpsflag) 
     57                        return tpsflag & SSB_TPSFLAG_BPFLAG; 
     58                else 
     59                        /* not irq supported */ 
     60                        return 0x3f; 
    6961        } 
    70         return NULL; 
    7162} 
    7263 
    7364/* Get the MIPS IRQ assignment for a specified device. 
     
    8778        irqflag = ssb_irqflag(dev); 
    8879        if (irqflag == 0x3f) 
    8980                return 6; 
    90         ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG); 
    91         for (irq = 1; irq <= 4; irq++) { 
    92                 tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]); 
    93                 if (tmp == irqflag) 
    94                         break; 
    95         } 
    96         if (irq == 5) { 
    97                 if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)) 
    98                         irq = 0; 
     81        if (mdev->id.coreid == SSB_DEV_MIPS_74K) { 
     82                for (irq = 1; irq <= 4; irq++) { 
     83                        if (ssb_read32(mdev, SSB_MIPS74K_INT_CONTROL(irq)) & (1 << irqflag)) 
     84                                break; 
     85                } 
     86                if (irq == 5) 
     87                        irq = 0; 
     88        } else { 
     89                ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG); 
     90                for (irq = 1; irq <= 4; irq++) { 
     91                        tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]); 
     92                        if (tmp == irqflag) 
     93                                break; 
     94                } 
     95                if (irq == 5) { 
     96                        if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)) 
     97                                irq = 0; 
     98                } 
    9999        } 
    100100 
    101101        return irq; 
    102102} 
    103103 
    104 static void clear_irq(struct ssb_bus *bus, unsigned int irq) 
     104static void clear_irq(struct ssb_bus *bus, unsigned int irq, u32 irqflag) 
    105105{ 
    106106        struct ssb_device *dev = bus->mipscore.dev; 
    107  
    108         /* Clear the IRQ in the MIPScore backplane registers */ 
    109         if (irq == 0) { 
    110                 ssb_write32(dev, SSB_INTVEC, 0); 
    111         } else { 
    112                 ssb_write32(dev, SSB_IPSFLAG, 
    113                             ssb_read32(dev, SSB_IPSFLAG) | 
    114                             ipsflag_irq_mask[irq]); 
     107         
     108        if (irq == 5) 
     109                return; 
     110 
     111        if (dev->id.coreid == SSB_DEV_MIPS_74K) { 
     112                if (irq == 0) 
     113                        ssb_write32(dev, SSB_MIPS74K_INT_CONTROL(0), 
     114                                                ssb_read32(dev, SSB_MIPS74K_INT_CONTROL(0)) & ~(1 << irqflag)); 
     115                else 
     116                        ssb_write32(dev, SSB_MIPS74K_INT_CONTROL(irq), 0); 
     117        } else { /* Clear the IRQ in the MIPScore backplane registers */ 
     118                if (irq == 0) { 
     119                        ssb_write32(dev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(dev, SSB_INTVEC))); 
     120                } else { 
     121                        ssb_write32(dev, SSB_IPSFLAG, 
     122                                        ssb_read32(dev, SSB_IPSFLAG) | 
     123                                        ipsflag_irq_mask[irq]); 
     124                } 
    115125        } 
    116126} 
    117127 
     
    125135        BUG_ON(oldirq == 6); 
    126136 
    127137        dev->irq = irq + 2; 
     138         
     139        if (irq == oldirq) 
     140                return; 
    128141 
    129142        /* clear the old irq */ 
    130         if (oldirq == 0) 
    131                 ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC))); 
    132         else if (oldirq != 5) 
    133                 clear_irq(bus, oldirq); 
    134  
    135         /* assign the new one */ 
    136         if (irq == 0) { 
    137                 ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC))); 
    138         } else { 
    139                 u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG); 
    140                 if ((ipsflag & ipsflag_irq_mask[irq]) != ipsflag_irq_mask[irq]) { 
    141                         u32 oldipsflag = (ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]; 
    142                         struct ssb_device *olddev = find_device(dev, oldipsflag); 
    143                         if (olddev) 
     143        clear_irq(bus, irq, irqflag); 
     144         
     145        /* make sure, the new irq is unused */ 
     146        if (irq != 0) { 
     147                int i; 
     148                for (i = 0; i < bus->nr_devices; i++) { 
     149                        struct ssb_device *olddev = &(bus->devices[i]); 
     150                        if (ssb_mips_irq(olddev) == irq) { 
    144151                                set_irq(olddev, 0); 
     152                                break; 
     153                        } 
     154                } 
     155        } 
     156         
     157        /* set new irq */ 
     158        if (mdev->id.coreid == SSB_DEV_MIPS_74K) { 
     159                if (irq == 0) 
     160                        ssb_write32(mdev, SSB_MIPS74K_INT_CONTROL(0), 
     161                                                ssb_read32(mdev,SSB_MIPS74K_INT_CONTROL(0)) | 1 << irqflag); 
     162                else 
     163                        ssb_write32(mdev, SSB_MIPS74K_INT_CONTROL(irq), 1 << irqflag); 
     164        } else { 
     165                if (irq == 0) { 
     166                        ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC))); 
     167                } else { 
     168                        u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG); 
     169                        irqflag <<= ipsflag_irq_shift[irq]; 
     170                        irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]); 
     171                        ssb_write32(mdev, SSB_IPSFLAG, irqflag); 
    145172                } 
    146                 irqflag <<= ipsflag_irq_shift[irq]; 
    147                 irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]); 
    148                 ssb_write32(mdev, SSB_IPSFLAG, irqflag); 
    149173        } 
    150174        ssb_dprintk(KERN_INFO PFX 
    151175                    "set_irq: core 0x%04x, irq %d => %d\n", 
     
    208232        struct ssb_bus *bus = mcore->dev->bus; 
    209233        u32 pll_type, n, m, rate = 0; 
    210234 
     235        switch (bus->chip_id) { 
     236                case 0x5365: 
     237                        return 200000000; 
     238                case 0x5354: 
     239                        return 240000000; 
     240                case 0x4716: 
     241                        return ssb_pmu5_clock(&mcore->dev->bus->chipco, SSB_PMU5_MAINPLL_CPU); 
     242        } 
     243 
    211244        if (bus->extif.dev) { 
    212245                ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m); 
    213246        } else if (bus->chipco.dev) { 
     
    215248        } else 
    216249                return 0; 
    217250 
    218         if ((pll_type == SSB_PLLTYPE_5) || (bus->chip_id == 0x5365)) { 
     251        if (pll_type == SSB_PLLTYPE_5) 
    219252                rate = 200000000; 
    220         } else if (bus->chip_id == 0x5354) { 
    221                 rate = 240000000; 
    222         } else { 
     253        else 
    223254                rate = ssb_calc_clock_rate(pll_type, n, m); 
    224         } 
    225255 
    226256        if (pll_type == SSB_PLLTYPE_6) { 
    227257                rate *= 2; 
     
    254284                ssb_chipco_timing_init(&bus->chipco, ns); 
    255285 
    256286        /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */ 
    257         for (irq = 2, i = 0; i < bus->nr_devices; i++) { 
     287        if (bus->chip_id == 0x4716) 
     288                irq = 1; 
     289        else 
     290                irq = 2; 
     291         
     292        for (i = 0; i < bus->nr_devices; i++) { 
    258293                int mips_irq; 
    259294                dev = &(bus->devices[i]); 
    260295                mips_irq = ssb_mips_irq(dev); 
     
    277312                case SSB_DEV_ETHERNET_GBIT: 
    278313                case SSB_DEV_80211: 
    279314                case SSB_DEV_USB20_HOST: 
     315                case SSB_DEV_ETHERNET_GBIT2: 
    280316                        /* These devices get their own IRQ line if available, the rest goes on IRQ0 */ 
    281317                        if (irq <= 4) { 
    282318                                set_irq(dev, irq++); 
  • drivers/ssb/driver_pcicore.c

    old new  
    412412{ 
    413413        /* Disable PCI interrupts. */ 
    414414        ssb_write32(pc->dev, SSB_INTVEC, 0); 
     415 
     416        ssb_device_disable(pc->dev, 0); 
    415417} 
    416418 
    417419void ssb_pcicore_init(struct ssb_pcicore *pc) 
     
    427429 
    428430#ifdef CONFIG_SSB_PCICORE_HOSTMODE 
    429431        pc->hostmode = pcicore_is_in_hostmode(pc); 
     432        if (pc->hostmode && pc->dev->id.coreid == SSB_DEV_PCIE) { 
     433                printk(KERN_WARNING "Disabling SSB PCI-E host due to code brokeness\n"); 
     434                pc->hostmode = 0; 
     435        } 
    430436        if (pc->hostmode) 
    431437                ssb_pcicore_init_hostmode(pc); 
    432438#endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
  • drivers/ssb/main.c

    old new  
    717717#endif 
    718718}; 
    719719 
     720void ssb_ai_write32(struct ssb_device *dev, u16 offset, u32 value) 
     721{ 
     722        struct ssb_bus *bus = dev->bus; 
     723         
     724        offset += dev->core_index * SSB_CORE_SIZE; 
     725        return writel(value, bus->ai_mmio + offset); 
     726} 
     727 
     728u32 ssb_ai_read32(struct ssb_device *dev, u16 offset) 
     729{ 
     730        struct ssb_bus *bus = dev->bus; 
     731         
     732        offset += dev->core_index * SSB_CORE_SIZE; 
     733        return readl(bus->ai_mmio + offset); 
     734} 
     735 
    720736static int ssb_fetch_invariants(struct ssb_bus *bus, 
    721737                                ssb_invariants_func_t get_invariants) 
    722738{ 
     
    10551071        u32 plltype; 
    10561072        u32 clkctl_n, clkctl_m; 
    10571073 
     1074        switch (bus->chip_id) { 
     1075                case 0x5365: 
     1076                        return 100000000; 
     1077                case 0x5354: 
     1078                        return 120000000; 
     1079                case 0x4716: 
     1080                        return ssb_pmu5_clock(&bus->chipco, SSB_PMU5_MAINPLL_SBB); 
     1081        } 
     1082 
    10581083        if (ssb_extif_available(&bus->extif)) 
    10591084                ssb_extif_get_clockcontrol(&bus->extif, &plltype, 
    10601085                                           &clkctl_n, &clkctl_m); 
     
    10641089        else 
    10651090                return 0; 
    10661091 
    1067         if (bus->chip_id == 0x5365) { 
    1068                 rate = 100000000; 
    1069         } else if (bus->chip_id == 0x5354) { 
    1070                 rate = 120000000; 
    1071         } else { 
    1072                 rate = ssb_calc_clock_rate(plltype, clkctl_n, clkctl_m); 
    1073                 if (plltype == SSB_PLLTYPE_3) /* 25Mhz, 2 dividers */ 
    1074                         rate /= 2; 
    1075         } 
     1092        rate = ssb_calc_clock_rate(plltype, clkctl_n, clkctl_m); 
     1093        if (plltype == SSB_PLLTYPE_3) /* 25Mhz, 2 dividers */ 
     1094                rate /= 2; 
    10761095 
    10771096        return rate; 
    10781097} 
     
    11031122 
    11041123int ssb_device_is_enabled(struct ssb_device *dev) 
    11051124{ 
    1106         u32 val; 
    1107         u32 reject; 
     1125        if (dev->bus->is_ai_bus) { 
     1126                return (ssb_ai_read32(dev, SSB_AI_RESETCTRL) & SSB_AI_RESETCTRL_RESET) == 0; 
     1127        } else { 
     1128                u32 val; 
     1129                u32 reject; 
    11081130 
    1109         reject = ssb_tmslow_reject_bitmask(dev); 
    1110         val = ssb_read32(dev, SSB_TMSLOW); 
    1111         val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | reject; 
     1131                reject = ssb_tmslow_reject_bitmask(dev); 
     1132                val = ssb_read32(dev, SSB_TMSLOW); 
     1133                val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | reject; 
    11121134 
    1113         return (val == SSB_TMSLOW_CLOCK); 
     1135                return (val == SSB_TMSLOW_CLOCK); 
     1136        } 
    11141137} 
    11151138EXPORT_SYMBOL(ssb_device_is_enabled); 
    11161139 
     
    11261149        udelay(1); 
    11271150} 
    11281151 
     1152static void ssb_ai_ioctl_write(struct ssb_device *dev, u32 flags) 
     1153{ 
     1154        u32 dummy; 
     1155        ssb_ai_write32(dev, SSB_AI_IOCTRL, flags); 
     1156        dummy = ssb_ai_read32(dev, SSB_AI_IOCTRL); 
     1157        udelay(1); 
     1158} 
     1159 
    11291160void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags) 
    11301161{ 
    11311162        u32 val; 
    11321163 
    11331164        ssb_device_disable(dev, core_specific_flags); 
    1134         ssb_write32(dev, SSB_TMSLOW, 
    1135                     SSB_TMSLOW_RESET | SSB_TMSLOW_CLOCK | 
    1136                     SSB_TMSLOW_FGC | core_specific_flags); 
    1137         ssb_flush_tmslow(dev); 
    1138  
    1139         /* Clear SERR if set. This is a hw bug workaround. */ 
    1140         if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_SERR) 
    1141                 ssb_write32(dev, SSB_TMSHIGH, 0); 
    1142  
    1143         val = ssb_read32(dev, SSB_IMSTATE); 
    1144         if (val & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO)) { 
    1145                 val &= ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO); 
    1146                 ssb_write32(dev, SSB_IMSTATE, val); 
    1147         } 
    1148  
    1149         ssb_write32(dev, SSB_TMSLOW, 
    1150                     SSB_TMSLOW_CLOCK | SSB_TMSLOW_FGC | 
    1151                     core_specific_flags); 
    1152         ssb_flush_tmslow(dev); 
    1153  
    1154         ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_CLOCK | 
    1155                     core_specific_flags); 
    1156         ssb_flush_tmslow(dev); 
     1165         
     1166        if (dev->bus->is_ai_bus) { 
     1167                ssb_ai_ioctl_write(dev, core_specific_flags | SSB_CF_FGC | SSB_CF_CLOCK_EN); 
     1168                ssb_ai_write32(dev, SSB_AI_RESETCTRL, 0); 
     1169                udelay(1); 
     1170 
     1171                ssb_ai_ioctl_write(dev, core_specific_flags | SSB_CF_CLOCK_EN); 
     1172        } else { 
     1173                ssb_write32(dev, SSB_TMSLOW, 
     1174                                SSB_TMSLOW_RESET | SSB_TMSLOW_CLOCK | 
     1175                                SSB_TMSLOW_FGC | core_specific_flags); 
     1176                ssb_flush_tmslow(dev); 
     1177 
     1178                /* Clear SERR if set. This is a hw bug workaround. */ 
     1179                if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_SERR) 
     1180                        ssb_write32(dev, SSB_TMSHIGH, 0); 
     1181 
     1182                val = ssb_read32(dev, SSB_IMSTATE); 
     1183                if (val & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO)) { 
     1184                        val &= ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO); 
     1185                        ssb_write32(dev, SSB_IMSTATE, val); 
     1186                } 
     1187 
     1188                ssb_write32(dev, SSB_TMSLOW, 
     1189                                SSB_TMSLOW_CLOCK | SSB_TMSLOW_FGC | 
     1190                                core_specific_flags); 
     1191                ssb_flush_tmslow(dev); 
     1192 
     1193                ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_CLOCK | 
     1194                                core_specific_flags); 
     1195                ssb_flush_tmslow(dev); 
     1196        } 
    11571197} 
    11581198EXPORT_SYMBOL(ssb_device_enable); 
    11591199 
     
    11851225 
    11861226void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
    11871227{ 
    1188         u32 reject; 
     1228        if (dev->bus->is_ai_bus) { 
     1229                if (ssb_ai_read32(dev, SSB_AI_RESETCTRL) & SSB_AI_RESETCTRL_RESET) 
     1230                        return; 
     1231                ssb_ai_ioctl_write(dev, core_specific_flags); 
     1232                udelay(9); 
     1233                ssb_ai_write32(dev, SSB_AI_RESETCTRL, SSB_AI_RESETCTRL_RESET); 
     1234                udelay(1); 
     1235        } else { 
     1236                u32 reject; 
    11891237 
    1190         if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
    1191                 return; 
     1238                if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
     1239                        return; 
    11921240 
    1193         reject = ssb_tmslow_reject_bitmask(dev); 
    1194         ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
    1195         ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
    1196         ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
    1197         ssb_write32(dev, SSB_TMSLOW, 
    1198                     SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
    1199                     reject | SSB_TMSLOW_RESET | 
    1200                     core_specific_flags); 
    1201         ssb_flush_tmslow(dev); 
    1202  
    1203         ssb_write32(dev, SSB_TMSLOW, 
    1204                     reject | SSB_TMSLOW_RESET | 
    1205                     core_specific_flags); 
    1206         ssb_flush_tmslow(dev); 
     1241                reject = ssb_tmslow_reject_bitmask(dev); 
     1242                ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     1243                ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
     1244                ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     1245                ssb_write32(dev, SSB_TMSLOW, 
     1246                                SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     1247                                reject | SSB_TMSLOW_RESET | 
     1248                                core_specific_flags); 
     1249                ssb_flush_tmslow(dev); 
     1250 
     1251                ssb_write32(dev, SSB_TMSLOW, 
     1252                                reject | SSB_TMSLOW_RESET | 
     1253                                core_specific_flags); 
     1254                ssb_flush_tmslow(dev); 
     1255        } 
    12071256} 
    12081257EXPORT_SYMBOL(ssb_device_disable); 
    12091258 
  • drivers/ssb/scan.c

    old new  
    88 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org> 
    99 * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch> 
    1010 * Copyright (C) 2006 Broadcom Corporation. 
     11 * Copyright (C) 2010 Bernhard Loos <bernhardloos@googlemail.com> 
    1112 * 
    1213 * Licensed under the GNU/GPL. See COPYING for details. 
    1314 */ 
     
    2425 
    2526#include "ssb_private.h" 
    2627 
    27  
    2828const char *ssb_core_name(u16 coreid) 
    2929{ 
    3030        switch (coreid) { 
     
    9292                return "ARM 1176"; 
    9393        case SSB_DEV_ARM_7TDMI: 
    9494                return "ARM 7TDMI"; 
     95        case SSB_DEV_ETHERNET_GBIT2: 
     96                return "Gigabit MAC"; 
     97        case SSB_DEV_MIPS_74K: 
     98                return "MIPS 74k"; 
     99        case SSB_DEV_DDR_CTRLR: 
     100                return "DDR1/2 memory controller"; 
     101        case SSB_DEV_I2S: 
     102                return "I2S"; 
    95103        } 
    96104        return "UNKNOWN"; 
    97105} 
     
    150158        case 0x4710: 
    151159        case 0x4610: 
    152160        case 0x4704: 
     161        case 0x4716: 
    153162                return 9; 
    154163        default: 
    155164                ssb_printk(KERN_ERR PFX 
     
    207216        case SSB_BUSTYPE_SSB: 
    208217        case SSB_BUSTYPE_PCMCIA: 
    209218                iounmap(bus->mmio); 
     219                if (bus->ai_mmio) 
     220                        iounmap(bus->ai_mmio); 
    210221                break; 
    211222        case SSB_BUSTYPE_PCI: 
    212223#ifdef CONFIG_SSB_PCIHOST 
     
    267278        return 0; 
    268279} 
    269280 
     281static u32 
     282get_erom_ent(struct ssb_bus *bus, u32 **eromptr, u32 mask, u32 match) 
     283{ 
     284        u32 ent; 
     285 
     286        while (1) { 
     287                ent = readl(*eromptr); 
     288                (*eromptr)++; 
     289 
     290                if (mask == 0) 
     291                        break; 
     292 
     293                if ((ent & SSB_EROM_VALID) == 0) 
     294                        continue; 
     295 
     296                if (ent == (SSB_EROM_END | SSB_EROM_VALID)) 
     297                        break; 
     298 
     299                if ((ent & mask) == match) 
     300                        break; 
     301        } 
     302        return ent; 
     303} 
     304 
     305static u32 
     306get_adress_space_descriptor(struct ssb_bus *bus, u32 **eromptr, uint st, u32 *addrl, u32 *sizel) 
     307{ 
     308        u32 asd, sz, szd, expect; 
     309         
     310        expect = SSB_EROM_ASD | st; 
     311        if (st == SSB_EROM_ASD_ST_SWRAP) 
     312                expect |= 1 << SSB_EROM_ASD_SP_SHIFT; 
     313         
     314        asd = get_erom_ent(bus, eromptr, SSB_EROM_ASD_SP_MASK | SSB_EROM_TAG | SSB_EROM_ASD_ST_MASK, expect); 
     315 
     316        *addrl = asd & SSB_EROM_ASD_ADDR_MASK; 
     317 
     318        /* *addrh = get_erom_ent(sih, eromptr, 0, 0);  
     319           64bit addresses are not supported */ 
     320        BUG_ON(asd & SSB_EROM_ASD_AG32); 
     321 
     322        sz = asd & SSB_EROM_ASD_SZ_MASK; 
     323        if (sz == SSB_EROM_ASD_SZ_SZD) { 
     324                szd = get_erom_ent(bus, eromptr, 0, 0); 
     325                *sizel = szd & SSB_EROM_ASD_SZ_MASK; 
     326        } else 
     327                *sizel = SSB_EROM_ASD_SZ_BASE << (sz >> SSB_EROM_ASD_SZ_SHIFT); 
     328 
     329        return asd; 
     330} 
     331 
    270332int ssb_bus_scan(struct ssb_bus *bus, 
    271333                 unsigned long baseaddr) 
    272334{ 
    273335        int err = -ENOMEM; 
    274336        void __iomem *mmio; 
    275         u32 idhi, cc, rev, tmp; 
     337        u32 idhi, tmp; 
    276338        int dev_i, i; 
    277339        struct ssb_device *dev; 
    278340        int nr_80211_cores = 0; 
     341        bool have_chipcommon = true; 
     342        u32 __iomem *eromptr = NULL; 
     343        u32 __iomem *eromend = (void *) -1; 
    279344 
    280345        mmio = ssb_ioremap(bus, baseaddr); 
    281346        if (!mmio) 
     
    286351        if (err) 
    287352                goto err_unmap; 
    288353 
    289         idhi = scan_read32(bus, 0, SSB_IDHIGH); 
    290         cc = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT; 
    291         rev = (idhi & SSB_IDHIGH_RCLO); 
    292         rev |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT; 
     354        if (bus->bustype != SSB_BUSTYPE_SSB) { 
     355                idhi = scan_read32(bus, 0, SSB_IDHIGH); 
     356                if (((idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT) != SSB_DEV_CHIPCOMMON) 
     357                        have_chipcommon = false; 
     358        } 
    293359 
    294360        bus->nr_devices = 0; 
    295         if (cc == SSB_DEV_CHIPCOMMON) { 
     361        /* this may break, if the first core isn't a chipcommon core, 
     362           but we need to know, if this is an ai bus or not. It should 
     363           only fail for older SDIOs (?) */ 
     364        if (have_chipcommon) { 
    296365                tmp = scan_read32(bus, 0, SSB_CHIPCO_CHIPID); 
    297366 
    298367                bus->chip_id = (tmp & SSB_CHIPCO_IDMASK); 
     
    300369                                SSB_CHIPCO_REVSHIFT; 
    301370                bus->chip_package = (tmp & SSB_CHIPCO_PACKMASK) >> 
    302371                                    SSB_CHIPCO_PACKSHIFT; 
    303                 if (rev >= 4) { 
     372                bus->is_ai_bus = !!(tmp & SSB_CHIPCO_TYPE_MASK); 
     373                if (bus->chip_rev >= 4) { 
    304374                        bus->nr_devices = (tmp & SSB_CHIPCO_NRCORESMASK) >> 
    305375                                          SSB_CHIPCO_NRCORESSHIFT; 
    306376                } 
     
    330400                /* Now that we know the number of cores, 
    331401                 * remap the whole IO space for all cores. 
    332402                 */ 
    333                 err = -ENOMEM; 
    334403                iounmap(mmio); 
    335404                mmio = ioremap(baseaddr, SSB_CORE_SIZE * bus->nr_devices); 
    336405                if (!mmio) 
     
    338407                bus->mmio = mmio; 
    339408        } 
    340409 
     410        if (bus->is_ai_bus) { 
     411                mmio = ioremap(SSB_AI_BASE, SSB_CORE_SIZE * bus->nr_devices); 
     412                if (!mmio) 
     413                        goto err_unmap; 
     414                bus->ai_mmio = mmio; 
     415 
     416                eromptr = ioremap(scan_read32(bus, 0, SSB_CHIPCO_EROM), SSB_CORE_SIZE); 
     417                if (!eromptr) 
     418                        goto err_unmap; 
     419                 
     420                eromend = eromptr + SSB_CORE_SIZE / sizeof(u32); 
     421        } 
     422         
     423        err = -EIO; 
     424         
    341425        /* Fetch basic information about each core/device */ 
    342         for (i = 0, dev_i = 0; i < bus->nr_devices; i++) { 
     426        i = 0; 
     427        dev_i = 0; 
     428        while ((i < bus->nr_devices) && (eromptr < eromend)) { 
    343429                err = scan_switchcore(bus, i); 
    344430                if (err) 
    345431                        goto err_unmap; 
    346432                dev = &(bus->devices[dev_i]); 
    347433 
    348                 idhi = scan_read32(bus, i, SSB_IDHIGH); 
    349                 dev->id.coreid = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT; 
    350                 dev->id.revision = (idhi & SSB_IDHIGH_RCLO); 
    351                 dev->id.revision |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT; 
    352                 dev->id.vendor = (idhi & SSB_IDHIGH_VC) >> SSB_IDHIGH_VC_SHIFT; 
    353                 dev->core_index = i; 
     434                if (bus->is_ai_bus) { 
     435                        u32 cia, cib, asd, sizel, addrl, nmw; 
     436                         
     437                        cia = get_erom_ent(bus, &eromptr, SSB_EROM_TAG, SSB_EROM_CI); 
     438                        if (cia == (SSB_EROM_END | SSB_EROM_VALID)) { 
     439                                ssb_dprintk(KERN_INFO PFX "Found END of erom after %d cores\n", dev_i); 
     440                                if (dev_i != bus->nr_devices) { 
     441                                        ssb_printk(KERN_WARNING PFX "Expected %d cores but got %d\n", bus->nr_devices, dev_i); 
     442                                } 
     443                                break; 
     444                        } 
     445                        cib = get_erom_ent(bus, &eromptr, 0, 0); 
     446                        if ((cib & SSB_EROM_TAG) != SSB_EROM_CI) { 
     447                                ssb_printk(KERN_ERR PFX "CIA not followed by CIB\n"); 
     448                                goto error; 
     449                        } 
     450                         
     451                        dev->id.coreid = (cia & SSB_EROM_CIA_CID_MASK) >> SSB_EROM_CIA_CID_SHIFT; 
     452                        dev->id.vendor = (cia & SSB_EROM_CIA_MFG_MASK) >> SSB_EROM_CIA_MFG_SHIFT; 
     453                        dev->id.revision = (cib & SSB_EROM_CIB_REV_MASK) >> SSB_EROM_CIB_REV_SHIFT; 
     454                        dev->core_index = dev_i; 
     455 
     456                        nmw = cib & SSB_EROM_CIB_NMW_MASK; 
     457                        if (((dev->id.coreid == SSB_DEV_DEFAULT) && (dev->id.vendor == SSB_VENDOR_ARM)) || 
     458                                (nmw == 0 && (cib & SSB_EROM_CIB_NSW_MASK) == 0) || 
     459                                ((cib & SSB_EROM_CIB_NSP_MASK) == 0)) { 
     460                                continue; 
     461                        } 
     462 
     463                        /* see if it is a bridge */ 
     464                        if ((SSB_EROM_ASD_ST_MASK & get_erom_ent(bus, &eromptr, SSB_EROM_TAG, SSB_EROM_ASD)) == 
     465                                        SSB_EROM_ASD_ST_BRIDGE) 
     466                                continue;/* don't record bridges */ 
     467                        else 
     468                                eromptr--; 
     469 
     470                        /* First Slave Address Descriptor should be port 0: 
     471                         * the main register space for the core 
     472                         */ 
     473                        asd = get_adress_space_descriptor(bus, &eromptr, SSB_EROM_ASD_ST_SLAVE, &addrl, &sizel); 
     474                        if (sizel != SSB_CORE_SIZE || addrl != SSB_ENUM_BASE + SSB_CORE_SIZE * dev_i) { 
     475                                ssb_printk(KERN_ERR PFX "Malformed or unsupported register address space descriptor for core %d:\n" 
     476                                                                                "\texpected 0x%x, got 0x%x, size 0x%x\n", 
     477                                                                                dev_i, SSB_ENUM_BASE + SSB_CORE_SIZE * dev_i, addrl, sizel); 
     478                                goto error; 
     479                        } 
     480                         
     481                        if (nmw) 
     482                                asd = get_adress_space_descriptor(bus, &eromptr, SSB_EROM_ASD_ST_MWRAP, &addrl, &sizel); 
     483                        else 
     484                                asd = get_adress_space_descriptor(bus, &eromptr, SSB_EROM_ASD_ST_SWRAP, &addrl, &sizel); 
     485                         
     486                        if (sizel != SSB_CORE_SIZE || addrl != SSB_AI_BASE + SSB_CORE_SIZE * dev_i) { 
     487                                ssb_printk(KERN_ERR PFX "Malformed or unsupported ai address space descriptor for core %d:\n" 
     488                                                                                "\texpected 0x%x, got 0x%x, size 0x%x\n", 
     489                                                                                dev_i, SSB_AI_BASE + SSB_CORE_SIZE * dev_i, addrl, sizel); 
     490                                goto error; 
     491                        } 
     492                } else { 
     493                        idhi = scan_read32(bus, i, SSB_IDHIGH); 
     494                        dev->id.coreid = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT; 
     495                        dev->id.revision = (idhi & SSB_IDHIGH_RCLO); 
     496                        dev->id.revision |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT; 
     497                        dev->id.vendor = (idhi & SSB_IDHIGH_VC) >> SSB_IDHIGH_VC_SHIFT; 
     498                        dev->core_index = i; 
     499 
     500                        i++; 
     501                } 
     502 
    354503                dev->bus = bus; 
    355504                dev->ops = bus->ops; 
    356505 
    357                 ssb_dprintk(KERN_INFO PFX 
     506                ssb_printk(KERN_INFO PFX 
    358507                            "Core %d found: %s " 
    359508                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    360                             i, ssb_core_name(dev->id.coreid), 
     509                            dev->core_index, ssb_core_name(dev->id.coreid), 
    361510                            dev->id.coreid, dev->id.revision, dev->id.vendor); 
    362511 
    363512                switch (dev->id.coreid) { 
     
    391540                        break; 
    392541                case SSB_DEV_MIPS: 
    393542                case SSB_DEV_MIPS_3302: 
     543                case SSB_DEV_MIPS_74K: 
    394544#ifdef CONFIG_SSB_DRIVER_MIPS 
    395545                        if (bus->mipscore.dev) { 
    396546                                ssb_printk(KERN_WARNING PFX 
     
    429579                dev_i++; 
    430580        } 
    431581        bus->nr_devices = dev_i; 
     582         
     583        if (bus->is_ai_bus && eromptr >= eromend) 
     584                ssb_printk(KERN_ERR PFX "Reached end of erom without finding END"); 
    432585 
    433586        err = 0; 
    434587out: 
    435588        return err; 
     589error: 
     590        bus->nr_devices = 0; 
    436591err_unmap: 
    437592        ssb_iounmap(bus); 
    438         goto out; 
     593        return err; 
    439594} 
  • drivers/ssb/ssb_private.h

    old new  
    2929# define SSB_BUG_ON(x)          __ssb_do_nothing(unlikely(!!(x))) 
    3030#endif 
    3131 
     32u32 ssb_pmu5_clock(struct ssb_chipcommon *codev, u32 m); 
     33#define SSB_PMU5_MAINPLL_SBB    3 
     34#define SSB_PMU5_MAINPLL_CPU    1 
     35 
     36void ssb_ai_write32(struct ssb_device *dev, u16 offset, u32 value); 
     37u32 ssb_ai_read32(struct ssb_device *dev, u16 offset); 
    3238 
    3339/* pci.c */ 
    3440#ifdef CONFIG_SSB_PCIHOST 
  • include/linux/ssb/ssb.h

    old new  
    151151#define SSB_DEV_MINI_MACPHY     0x823 
    152152#define SSB_DEV_ARM_1176        0x824 
    153153#define SSB_DEV_ARM_7TDMI       0x825 
     154#define SSB_DEV_ETHERNET_GBIT2  0x82d 
     155#define SSB_DEV_MIPS_74K        0x82c 
     156#define SSB_DEV_DDR_CTRLR       0x82e 
     157#define SSB_DEV_I2S                     0x834 
     158#define SSB_DEV_DEFAULT         0xfff 
    154159 
    155160/* Vendor-ID values */ 
    156161#define SSB_VENDOR_BROADCOM     0x4243 
     162#define SSB_VENDOR_ARM          0x43b 
    157163 
    158164/* Some kernel subsystems poke with dev->drvdata, so we must use the 
    159165 * following ugly workaround to get from struct device to struct ssb_device */ 
     
    266272struct ssb_bus { 
    267273        /* The MMIO area. */ 
    268274        void __iomem *mmio; 
     275        void __iomem *ai_mmio; 
    269276 
    270277        const struct ssb_bus_ops *ops; 
    271278 
     
    280287        /* Lock for core and segment switching. 
    281288         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    282289        spinlock_t bar_lock; 
     290         
     291        bool is_ai_bus; 
    283292 
    284293        /* The bus this backplane is running on. */ 
    285294        enum ssb_bustype bustype; 
  • include/linux/ssb/ssb_driver_chipcommon.h

    old new  
    2323#define  SSB_CHIPCO_PACKSHIFT           20 
    2424#define  SSB_CHIPCO_NRCORESMASK         0x0F000000 
    2525#define  SSB_CHIPCO_NRCORESSHIFT        24 
     26#define  SSB_CHIPCO_TYPE_MASK           0xf0000000 
    2627#define SSB_CHIPCO_CAP                  0x0004          /* Capabilities */ 
    2728#define  SSB_CHIPCO_CAP_NRUART          0x00000003      /* # of UARTs */ 
    2829#define  SSB_CHIPCO_CAP_MIPSEB          0x00000004      /* MIPS in BigEndian Mode */ 
     
    169170#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV    0xFFFF0000      /* ClkDiv  (ILP = 1/(4+divisor)) */ 
    170171#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV_SHIFT      16 
    171172#define SSB_CHIPCO_CLKSTSTR             0x00C4          /* Rev >= 3 only */ 
     173#define SSB_CHIPCO_EROM                         0xFC 
    172174#define SSB_CHIPCO_PCMCIA_CFG           0x0100 
    173175#define SSB_CHIPCO_PCMCIA_MEMWAIT       0x0104 
    174176#define SSB_CHIPCO_PCMCIA_ATTRWAIT      0x0108 
     
    297299#define  SSB_PMU1_PLLCTL5_CLKDRV                0xFFFFFF00 /* clk drv */ 
    298300#define  SSB_PMU1_PLLCTL5_CLKDRV_SHIFT          8 
    299301 
     302/* PMU rev 5 (& 6) */ 
     303#define SSB_PMU5_PLL_P1P2_OFF           0 
     304#define  SSB_PMU5_PLL_P1_MASK           0x0f000000 
     305#define  SSB_PMU5_PLL_P1_SHIFT          24 
     306#define  SSB_PMU5_PLL_P2_MASK           0x00f00000 
     307#define  SSB_PMU5_PLL_P2_SHIFT          20 
     308#define SSB_PMU5_PLL_M14_OFF            1 
     309#define  SSB_PMU5_PLL_MDIV_MASK         0x000000ff 
     310#define  SSB_PMU5_PLL_MDIV_WIDTH        8 
     311#define SSB_PMU5_PLL_NM5_OFF            2 
     312#define  SSB_PMU5_PLL_NDIV_MASK         0xfff00000 
     313#define  SSB_PMU5_PLL_NDIV_SHIFT                20 
     314#define SSB_PMU5_PLL_FMAB_OFF           3 
     315#define  SSB_PMU5_PLL_MRAT_MASK         0xf0000000 
     316#define  SSB_PMU5_PLL_MRAT_SHIFT                28 
     317#define  SSB_PMU5_PLL_ABRAT_MASK                0x08000000 
     318#define  SSB_PMU5_PLL_ABRAT_SHIFT               27 
     319#define  SSB_PMU5_PLL_FDIV_MASK         0x07ffffff 
     320#define SSB_PMU5_PLL_PLLCTL_OFF         4 
     321#define SSB_PMU5_PLL_PCHI_OFF           5 
     322#define  SSB_PMU5_PLL_PCHI_MASK         0x0000003f 
     323 
    300324/* BCM4312 PLL resource numbers. */ 
    301325#define SSB_PMURES_4312_SWITCHER_BURST          0 
    302326#define SSB_PMURES_4312_SWITCHER_PWM            1 
  • include/linux/ssb/ssb_driver_mips.h

    old new  
    3030 
    3131extern unsigned int ssb_mips_irq(struct ssb_device *dev); 
    3232 
     33#define SSB_MIPS74K_INT_CONTROL(int)    (0x14 + (int)*4) 
    3334 
    3435#else /* CONFIG_SSB_DRIVER_MIPS */ 
    3536 
  • include/linux/ssb/ssb_regs.h

    old new  
    1111#define SSB_SDRAM_SWAPPED       0x10000000U     /* Byteswapped Physical SDRAM */ 
    1212#define SSB_ENUM_BASE           0x18000000U     /* Enumeration space base */ 
    1313#define SSB_ENUM_LIMIT          0x18010000U     /* Enumeration space limit */ 
     14#define SSB_AI_BASE             0x18100000 
    1415 
    1516#define SSB_FLASH2              0x1c000000U     /* Flash Region 2 (region 1 shadowed here) */ 
    1617#define SSB_FLASH2_SZ           0x02000000U     /* Size of Flash Region 2 */ 
     
    2627#define SSB_EUART               (SSB_EXTIF_BASE + 0x00800000) 
    2728#define SSB_LED                 (SSB_EXTIF_BASE + 0x00900000) 
    2829 
     30#define SSB_EROM_ASD_SZ_BASE 0x00001000 
    2931 
    3032/* Enumeration space constants */ 
    3133#define SSB_CORE_SIZE           0x1000  /* Size of a core MMIO area */ 
     
    452454#define SSB_ADM_BASE2                   0xFFFF0000      /* Type2 base address for the core */ 
    453455#define SSB_ADM_BASE2_SHIFT             16 
    454456 
     457/***** EROM defines for AI type busses *****/ 
     458#define SSB_EROM_VALID                  1 
     459#define SSB_EROM_END                    0xe 
     460#define SSB_EROM_TAG                    0xe 
     461/* Adress Space Descriptor */ 
     462#define SSB_EROM_ASD                    0x4 
     463#define SSB_EROM_ASD_SP_MASK    0x00000f00 
     464#define SSB_EROM_ASD_SP_SHIFT   8 
     465#define SSB_EROM_ASD_ST_MASK    0x000000c0 
     466#define SSB_EROM_ASD_ST_SLAVE   0x00000000 
     467#define SSB_EROM_ASD_ST_BRIDGE  0x00000040 
     468#define SSB_EROM_ASD_ST_MWRAP   0x000000c0 
     469#define SSB_EROM_ASD_ST_SWRAP   0x00000080 
     470#define SSB_EROM_ASD_ADDR_MASK  0xfffff000 
     471#define SSB_EROM_ASD_AG32               0x00000008 
     472#define SSB_EROM_ASD_SZ_MASK    0x00000030 
     473#define SSB_EROM_ASD_SZ_SZD             0x00000030 
     474#define SSB_EROM_ASD_SZ_SHIFT   4 
     475#define SSB_EROM_CI                             0 
     476#define SSB_EROM_CIA_CID_MASK   0x000fff00 
     477#define SSB_EROM_CIA_CID_SHIFT  8 
     478#define SSB_EROM_CIA_MFG_MASK   0xfff00000 
     479#define SSB_EROM_CIA_MFG_SHIFT  20 
     480#define SSB_EROM_CIB_REV_MASK   0xff000000 
     481#define SSB_EROM_CIB_REV_SHIFT  24 
     482#define SSB_EROM_CIB_NMW_MASK   0x0007c000 
     483#define SSB_EROM_CIB_NSW_MASK   0x00f80000 
     484#define SSB_EROM_CIB_NSP_MASK   0x00003e00 
     485 
     486/***** Registers of AI config space *****/ 
     487#define SSB_AI_RESETCTRL                0x800 /* maybe 0x804 for big endian */ 
     488#define  SSB_AI_RESETCTRL_RESET 1 
     489#define SSB_AI_IOCTRL                   0x408 /* maybe 0x40c for big endian */ 
     490#define SSB_CF_FGC                              0x0002 
     491#define SSB_CF_CLOCK_EN                 0x001 
     492#define SSB_AI_oobselouta30             0x100 
    455493 
    456494#endif /* LINUX_SSB_REGS_H_ */