Changeset 7691


Ignore:
Timestamp:
2007-06-21T22:10:50+02:00 (11 years ago)
Author:
noz
Message:

brcm43xx: update SSB driver

  • files/ now contains the wireless-dev tree version
  • patches/210-ssb_merge is nbd's subsequent changes
Location:
trunk/target/linux/brcm47xx-2.6
Files:
7 added
3 deleted
10 edited
3 copied
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/Kconfig

    r6502 r7691  
    7272          PCIcore hostmode operation (external PCI bus). 
    7373 
     74config SSB_DRIVER_MIPS 
     75        bool "SSB Broadcom MIPS core driver" 
     76        depends on SSB && MIPS 
     77        select SSB_SERIAL 
     78        help 
     79          Driver for the Sonics Silicon Backplane attached 
     80          Broadcom MIPS core. 
     81 
     82          If unsure, say N 
     83 
     84config SSB_DRIVER_EXTIF 
     85        bool "SSB Broadcom EXTIF core driver" 
     86        depends on SSB_DRIVER_MIPS 
     87        help 
     88          Driver for the Sonics Silicon Backplane attached 
     89          Broadcom EXTIF core. 
     90 
     91          If unsure, say N 
     92 
    7493endmenu 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/Makefile

    r6502 r7691  
    1 ssb-driver-chipcommon-y                         := driver_chipcommon/chipcommon.o 
    2 ssb-driver-mips-$(CONFIG_BCM947XX)      := driver_mips/mips.o 
    3 ssb-driver-pci-$(CONFIG_SSB_DRIVER_PCICORE)     := driver_pci/pcicore.o 
     1ssb-builtin-drivers-y                                   += driver_chipcommon.o 
     2ssb-builtin-drivers-$(CONFIG_SSB_DRIVER_MIPS)           += driver_mipscore.o 
     3ssb-builtin-drivers-$(CONFIG_SSB_DRIVER_PCICORE)        += driver_pcicore.o 
    44 
    5 ssb-$(CONFIG_SSB_PCIHOST)                       += pci.o 
    6 ssb-$(CONFIG_SSB_PCMCIAHOST)                    += pcmcia.o 
     5ssb-hostsupport-$(CONFIG_SSB_PCIHOST)                   += pci.o pcihost_wrapper.o 
     6ssb-hostsupport-$(CONFIG_SSB_PCMCIAHOST)                += pcmcia.o 
    77 
    88obj-$(CONFIG_SSB) += ssb.o 
    99 
    10 ssb-objs        := core.o scan.o \ 
    11                    $(ssb-y) $(ssb-m) \ 
    12                    $(ssb-driver-chipcommon-y) \ 
    13                    $(ssb-driver-mips-y) \ 
    14                    $(ssb-driver-pci-y) 
     10ssb-objs        := main.o scan.o \ 
     11                   $(ssb-hostsupport-y) $(ssb-builtin-drivers-y) 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/driver_chipcommon.c

    r7347 r7691  
    1313#include <linux/pci.h> 
    1414 
    15 #include "../ssb_private.h" 
     15#include "ssb_private.h" 
    1616 
    1717 
     
    4040} 
    4141 
    42  
    4342void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc, 
    4443                              enum ssb_clkmode mode) 
     
    9089        } 
    9190} 
    92 EXPORT_SYMBOL(ssb_chipco_set_clockmode); 
    9391 
    9492/* Get the Slow Clock Source */ 
     
    9997 
    10098        if (cc->dev->id.revision < 6) { 
    101                 if (bus->bustype == SSB_BUSTYPE_SSB /*TODO || 
    102                     bus->bustype == SSB_BUSTYPE_PCMCIA*/) 
     99                if (bus->bustype == SSB_BUSTYPE_SSB || 
     100                    bus->bustype == SSB_BUSTYPE_PCMCIA) 
    103101                        return SSB_CHIPCO_CLKSRC_XTALOS; 
    104102                if (bus->bustype == SSB_BUSTYPE_PCI) { 
     
    247245        if (!cc->dev) 
    248246                return; /* We don't have a ChipCommon */ 
     247        chipco_powercontrol_init(cc); 
    249248        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
     249        calc_fast_powerup_delay(cc); 
     250} 
     251 
     252void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state) 
     253{ 
     254        if (!cc->dev) 
     255                return; 
     256        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW); 
     257} 
     258 
     259void ssb_chipco_resume(struct ssb_chipcommon *cc) 
     260{ 
     261        if (!cc->dev) 
     262                return; 
    250263        chipco_powercontrol_init(cc); 
    251         calc_fast_powerup_delay(cc); 
    252 } 
    253  
    254 void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state) 
    255 { 
    256         if (!cc->dev) 
    257                 return; 
    258         ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW); 
    259 } 
    260  
    261 void ssb_chipco_resume(struct ssb_chipcommon *cc) 
    262 { 
    263         if (!cc->dev) 
    264                 return; 
    265264        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    266         chipco_powercontrol_init(cc); 
    267 } 
    268  
    269 void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, u32 chip_id, u32 *rate, 
    270                              u32 *plltype, u32 *n, u32 *m) 
    271 { 
    272         *rate = 0; 
    273         *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N); 
    274         *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT); 
    275         switch (*plltype) { 
    276                 case SSB_PLLTYPE_2: 
    277                 case SSB_PLLTYPE_4: 
    278                 case SSB_PLLTYPE_6: 
    279                 case SSB_PLLTYPE_7: 
    280                         *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS); 
    281                         break; 
    282                 case SSB_PLLTYPE_5: 
    283                         *rate = 200000000; 
    284                         break; 
    285                 case SSB_PLLTYPE_3: 
    286                         /* 5350 uses m2 to control mips */ 
    287                         *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2); 
    288                         break; 
    289                 default: 
    290                         *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB); 
    291                         break; 
    292         } 
    293  
    294         if (*rate == 0 && chip_id == 0x5365) 
    295                 *rate = 200000000; 
    296265} 
    297266 
     
    351320        } 
    352321} 
     322 
    353323 
    354324#ifdef CONFIG_SSB_SERIAL 
     
    431401} 
    432402#endif /* CONFIG_SSB_SERIAL */ 
    433  
    434 /* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */ 
    435 int 
    436 ssb_chipco_watchdog(struct ssb_chipcommon *cc, uint ticks) 
    437 { 
    438         /* instant NMI */ 
    439         chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks); 
    440         return 0; 
    441 } 
    442 EXPORT_SYMBOL(ssb_chipco_watchdog); 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/driver_mipscore.c

    r7347 r7691  
    55 * Copyright 2005, Broadcom Corporation 
    66 * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
    7  * Copyright 2006, 2007, Felix Fietkau <nbd@openwrt.org> 
    87 * 
    98 * Licensed under the GNU/GPL. See COPYING for details. 
     
    1716#include <asm/time.h> 
    1817 
    19 #include "../ssb_private.h" 
    20  
    21 #define mips_read32(mcore, offset) ssb_read32((mcore)->dev, offset) 
    22 #define mips_write32(mcore, offset, value) ssb_write32((mcore)->dev, offset, value) 
    23 #define extif_read32(extif, offset) ssb_read32((extif)->dev, offset) 
    24 #define extif_write32(extif, offset, value) ssb_write32((extif)->dev, offset, value) 
     18#include "ssb_private.h" 
     19 
     20 
     21static inline u32 mips_read32(struct ssb_mipscore *mcore, 
     22                              u16 offset) 
     23{ 
     24        return ssb_read32(mcore->dev, offset); 
     25} 
     26 
     27static inline void mips_write32(struct ssb_mipscore *mcore, 
     28                                u16 offset, 
     29                                u32 value) 
     30{ 
     31        ssb_write32(mcore->dev, offset, value); 
     32} 
    2533 
    2634static const u32 ipsflag_irq_mask[] = { 
     
    110118} 
    111119 
    112 static int ssb_extif_serial_init(struct ssb_extif *dev, struct ssb_serial_port *ports) 
    113 { 
     120/* XXX: leave here or move into separate extif driver? */ 
     121static int ssb_extif_serial_init(struct ssb_device *dev, struct ssb_serial_ports *ports) 
     122{ 
     123 
     124} 
     125 
     126 
     127static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
     128{ 
     129        struct ssb_bus *bus = mcore->dev->bus; 
     130 
    114131        //TODO if (EXTIF available 
    115132#if 0 
     
    146163 
    147164#endif 
    148  
    149 } 
    150  
    151  
    152 static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
    153 { 
    154         struct ssb_bus *bus = mcore->dev->bus; 
    155  
    156165        if (bus->extif.dev) 
    157166                mcore->nr_serial_ports = ssb_extif_serial_init(&bus->extif, mcore->serial_ports); 
     
    166175        struct ssb_bus *bus = mcore->dev->bus; 
    167176 
    168         mcore->flash_buswidth = 2; 
    169177        if (bus->chipco.dev) { 
    170178                mcore->flash_window = 0x1c000000; 
    171                 mcore->flash_window_size = 0x02000000; 
    172                 if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG) 
    173                                 & SSB_CHIPCO_CFG_DS16) == 0) 
    174                         mcore->flash_buswidth = 1; 
     179                mcore->flash_window_size = 0x800000; 
    175180        } else { 
    176181                mcore->flash_window = 0x1fc00000; 
    177                 mcore->flash_window_size = 0x00400000; 
    178         } 
    179 } 
    180  
    181 static void ssb_extif_timing_init(struct ssb_extif *extif, u32 ns) 
    182 { 
    183         u32 tmp; 
    184  
    185         /* Initialize extif so we can get to the LEDs and external UART */ 
    186         extif_write32(extif, SSB_EXTIF_PROG_CFG, SSB_EXTCFG_EN); 
    187          
    188         /* Set timing for the flash */ 
    189         tmp  = ceildiv(10, ns) << SSB_PROG_WCNT_3_SHIFT; 
    190         tmp |= ceildiv(40, ns) << SSB_PROG_WCNT_1_SHIFT; 
    191         tmp |= ceildiv(120, ns); 
    192         extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp); 
    193  
    194         /* Set programmable interface timing for external uart */ 
    195         tmp  = ceildiv(10, ns) << SSB_PROG_WCNT_3_SHIFT; 
    196         tmp |= ceildiv(20, ns) << SSB_PROG_WCNT_2_SHIFT; 
    197         tmp |= ceildiv(100, ns) << SSB_PROG_WCNT_1_SHIFT; 
    198         tmp |= ceildiv(120, ns); 
    199         extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp); 
    200 } 
    201  
    202 static inline void ssb_extif_get_clockcontrol(struct ssb_extif *extif, 
    203                                  u32 *pll_type, u32 *n, u32 *m) 
    204 { 
    205         *pll_type = SSB_PLLTYPE_1; 
    206         *n = extif_read32(extif, SSB_EXTIF_CLOCK_N); 
    207         *m = extif_read32(extif, SSB_EXTIF_CLOCK_SB); 
    208 } 
    209  
    210 u32 ssb_cpu_clock(struct ssb_mipscore *mcore) 
    211 { 
    212         struct ssb_bus *bus = mcore->dev->bus; 
    213         u32 pll_type, n, m, rate = 0; 
    214  
    215         if (bus->extif.dev) { 
    216                 ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m); 
    217         } else if (bus->chipco.dev) { 
    218                 ssb_chipco_get_clockcpu(&bus->chipco, bus->chip_id, &rate, 
    219                         &pll_type, &n, &m); 
    220         } else 
    221                 return 0; 
    222  
    223         if (rate == 0) 
    224                 rate = ssb_calc_clock_rate(pll_type, n, m); 
    225  
    226         if (pll_type == SSB_PLLTYPE_6) 
    227                 rate *= 2; 
    228  
    229         return rate; 
     182                mcore->flash_window_size = 0x400000; 
     183        } 
     184} 
     185 
     186 
     187static void ssb_cpu_clock(struct ssb_mipscore *mcore) 
     188{ 
    230189} 
    231190 
     
    247206        ns = 1000000000 / hz; 
    248207 
    249         if (bus->extif.dev) 
    250                 ssb_extif_timing_init(&bus->extif, ns); 
    251         else if (bus->chipco.dev) 
     208//TODO 
     209#if 0 
     210        if (have EXTIF) { 
     211                /* Initialize extif so we can get to the LEDs and external UART */ 
     212                W_REG(&eir->prog_config, CF_EN); 
     213 
     214                /* Set timing for the flash */ 
     215                tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */ 
     216                tmp = tmp | (CEIL(40, ns) << FW_W1_SHIFT); /* W1 = 40nS */ 
     217                tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */ 
     218                W_REG(&eir->prog_waitcount, tmp);       /* 0x01020a0c for a 100Mhz clock */ 
     219 
     220                /* Set programmable interface timing for external uart */ 
     221                tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */ 
     222                tmp = tmp | (CEIL(20, ns) << FW_W2_SHIFT); /* W2 = 20nS */ 
     223                tmp = tmp | (CEIL(100, ns) << FW_W1_SHIFT); /* W1 = 100nS */ 
     224                tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */ 
     225                W_REG(&eir->prog_waitcount, tmp); 
     226        } 
     227        else... chipcommon 
     228#endif 
     229        if (bus->chipco.dev) 
    252230                ssb_chipco_timing_init(&bus->chipco, ns); 
    253231 
     
    279257        ssb_mips_flash_detect(mcore); 
    280258} 
    281  
    282 EXPORT_SYMBOL(ssb_mips_irq); 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/driver_pcicore.c

    r7347 r7691  
    1313#include <linux/delay.h> 
    1414 
    15 #include "../ssb_private.h" 
     15#include "ssb_private.h" 
     16 
    1617 
    1718static inline 
     
    9394        /* Enable PCI bridge BAR1 prefetch and burst */ 
    9495        pci_write_config_dword(dev, SSB_BAR1_CONTROL, 3); 
    95  
    96         /* Make sure our latency is high enough to handle the devices behind us */ 
    97         pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xa8); 
    9896} 
    9997DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, ssb_fixup_pcibridge); 
     
    113111        if (unlikely(pc->cardbusmode && dev > 1)) 
    114112                goto out; 
    115         if (bus == 0) {//FIXME busnumber ok? 
     113        if (bus == 0) { 
    116114                /* Type 0 transaction */ 
    117115                if (unlikely(dev >= SSB_PCI_SLOT_MAX)) 
     
    165163                goto unmap; 
    166164        } 
    167          
     165 
     166        val = readl(mmio); 
    168167        val >>= (8 * (off & 3)); 
    169168 
     
    213212        switch (len) { 
    214213        case 1: 
     214                val = readl(mmio); 
    215215                val &= ~(0xFF << (8 * (off & 3))); 
    216216                val |= *((const u8 *)buf) << (8 * (off & 3)); 
    217217                break; 
    218218        case 2: 
     219                val = readl(mmio); 
    219220                val &= ~(0xFFFF << (8 * (off & 3))); 
    220221                val |= *((const u16 *)buf) << (8 * (off & 3)); 
     
    224225                break; 
    225226        } 
    226         writel(val, mmio); 
     227        writel(*((const u32 *)buf), mmio); 
    227228 
    228229        err = 0; 
     
    291292        u32 val; 
    292293 
    293         assert(!extpci_core); 
     294        if (extpci_core) { 
     295                WARN_ON(1); 
     296                return; 
     297        } 
    294298        extpci_core = pc; 
    295299 
     
    304308        val |= SSB_PCICORE_CTL_RST; /* Deassert RST# */ 
    305309        pcicore_write32(pc, SSB_PCICORE_CTL, val); 
    306         val = SSB_PCICORE_ARBCTL_INTERN; 
    307         pcicore_write32(pc, SSB_PCICORE_ARBCTL, val);  
    308310        udelay(1); 
    309311 
     
    322324        /* Enable PCI bridge BAR0 prefetch and burst */ 
    323325        val = PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY; 
    324         ssb_extpci_write_config(pc, 0, 0, 0, PCI_COMMAND, &val, 4); 
     326        ssb_extpci_write_config(pc, 0, 0, 0, PCI_COMMAND, &val, 2); 
     327        /* Clear error conditions */ 
     328        val = 0; 
     329        ssb_extpci_write_config(pc, 0, 0, 0, PCI_STATUS, &val, 2); 
    325330 
    326331        /* Enable PCI interrupts */ 
     
    332337         * to non-MIPS platform. */ 
    333338        set_io_port_base((unsigned long)ioremap_nocache(SSB_PCI_MEM, 0x04000000)); 
    334         mdelay(300); 
    335339        register_pci_controller(&ssb_pcicore_controller); 
    336340} 
     
    384388                return; 
    385389        bus = dev->bus; 
    386         ssb_device_enable(dev, 0); 
     390        if (!ssb_device_is_enabled(dev)) 
     391                ssb_device_enable(dev, 0); 
    387392 
    388393#ifdef CONFIG_SSB_PCICORE_HOSTMODE 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/main.c

    r7347 r7691  
    3636static DEFINE_MUTEX(buses_mutex); 
    3737 
    38 #define ssb_buses_lock() do {                   \ 
    39         if (!is_early_boot())                   \ 
    40                 mutex_lock(&buses_mutex);       \ 
    41                         } while (0) 
    42  
    43 #define ssb_buses_unlock() do {                 \ 
    44         if (!is_early_boot())                   \ 
    45                 mutex_unlock(&buses_mutex);     \ 
    46                         } while (0) 
    47  
     38static void ssb_buses_lock(void); 
     39static void ssb_buses_unlock(void); 
     40 
     41 
     42#ifdef CONFIG_SSB_PCIHOST 
     43struct ssb_bus * ssb_pci_dev_to_bus(struct pci_dev *pdev) 
     44{ 
     45        struct ssb_bus *bus; 
     46 
     47        ssb_buses_lock(); 
     48        list_for_each_entry(bus, &buses, list) { 
     49                if (bus->bustype == SSB_BUSTYPE_PCI && 
     50                    bus->host_pci == pdev) 
     51                        goto found; 
     52        } 
     53        bus = NULL; 
     54found: 
     55        ssb_buses_unlock(); 
     56 
     57        return bus; 
     58} 
     59#endif /* CONFIG_SSB_PCIHOST */ 
    4860 
    4961static struct ssb_device * ssb_device_get(struct ssb_device *dev) 
    5062{ 
    5163        if (dev) 
    52                 get_device(&dev->dev); 
     64                get_device(dev->dev); 
    5365        return dev; 
    5466} 
     
    5769{ 
    5870        if (dev) 
    59                 put_device(&dev->dev); 
    60 } 
    61  
    62 static void ssb_bus_resume(struct ssb_bus *bus) 
    63 { 
    64 printk("SSB BUS RESUME\n"); 
     71                put_device(dev->dev); 
     72} 
     73 
     74static int ssb_bus_resume(struct ssb_bus *bus) 
     75{ 
     76        int err; 
     77 
    6578        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     79        err = ssb_pcmcia_init(bus); 
     80        if (err) { 
     81                /* No need to disable XTAL, as we don't have one on PCMCIA. */ 
     82                return err; 
     83        } 
    6684        ssb_chipco_resume(&bus->chipco); 
     85 
     86        return 0; 
    6787} 
    6888 
     
    7494        int err = 0; 
    7595 
    76 printk("SSB DEV RESUME\n"); 
    7796        bus = ssb_dev->bus; 
    78         if (bus->suspend_cnt == bus->nr_devices) 
    79                 ssb_bus_resume(bus); 
     97        if (bus->suspend_cnt == bus->nr_devices) { 
     98                err = ssb_bus_resume(bus); 
     99                if (err) 
     100                        return err; 
     101        } 
    80102        bus->suspend_cnt--; 
    81103        if (dev->driver) { 
     
    92114static void ssb_bus_suspend(struct ssb_bus *bus, pm_message_t state) 
    93115{ 
    94 printk("SSB BUS SUSPEND\n"); 
    95 //      ssb_chipco_suspend(&bus->chipco, state); 
    96 //      ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     116        ssb_chipco_suspend(&bus->chipco, state); 
     117        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     118 
     119        /* Reset HW state information in memory, so that HW is 
     120         * completely reinitialized on resume. */ 
     121        bus->mapped_device = NULL; 
     122#ifdef CONFIG_SSB_DRIVER_PCICORE 
     123        bus->pcicore.setup_done = 0; 
     124#endif 
    97125} 
    98126 
     
    104132        int err = 0; 
    105133 
    106 printk("SSB DEV SUSPEND\n"); 
    107134        if (dev->driver) { 
    108135                ssb_drv = drv_to_ssb_drv(dev->driver); 
     
    123150        return err; 
    124151} 
     152 
     153#ifdef CONFIG_SSB_PCIHOST 
     154int ssb_devices_freeze(struct ssb_bus *bus) 
     155{ 
     156        struct ssb_device *dev; 
     157        struct ssb_driver *drv; 
     158        int err = 0; 
     159        int i; 
     160        pm_message_t state = PMSG_FREEZE; 
     161 
     162        for (i = 0; i < bus->nr_devices; i++) { 
     163                dev = &(bus->devices[i]); 
     164                if (!dev->dev->driver) 
     165                        continue; 
     166                if (!device_is_registered(dev->dev)) 
     167                        continue; 
     168                drv = drv_to_ssb_drv(dev->dev->driver); 
     169                if (drv && drv->suspend) { 
     170                        err = drv->suspend(dev, state); 
     171                        if (err) 
     172                                goto out; 
     173                } 
     174        } 
     175out: 
     176        return err; 
     177} 
     178 
     179int ssb_devices_thaw(struct ssb_bus *bus) 
     180{ 
     181        struct ssb_device *dev; 
     182        struct ssb_driver *drv; 
     183        int err = 0; 
     184        int i; 
     185 
     186        for (i = 0; i < bus->nr_devices; i++) { 
     187                dev = &(bus->devices[i]); 
     188                if (!dev->dev->driver) 
     189                        continue; 
     190                if (!device_is_registered(dev->dev)) 
     191                        continue; 
     192                drv = drv_to_ssb_drv(dev->dev->driver); 
     193                if (drv && drv->resume) { 
     194                        err = drv->resume(dev); 
     195                        if (err) 
     196                                goto out; 
     197                } 
     198        } 
     199out: 
     200        return err; 
     201} 
     202#endif /* CONFIG_SSB_PCIHOST */ 
    125203 
    126204static void ssb_device_shutdown(struct device *dev) 
     
    194272} 
    195273 
    196 struct bus_type ssb_bustype = { 
     274static struct bus_type ssb_bustype = { 
    197275        .name           = NULL, /* Intentionally NULL to indicate early boot */ 
    198276        .match          = ssb_bus_match, 
     
    206284#define is_early_boot()         (ssb_bustype.name == NULL) 
    207285 
     286static void ssb_buses_lock(void) 
     287{ 
     288        if (!is_early_boot()) 
     289                mutex_lock(&buses_mutex); 
     290} 
     291 
     292static void ssb_buses_unlock(void) 
     293{ 
     294        if (!is_early_boot()) 
     295                mutex_unlock(&buses_mutex); 
     296} 
     297 
     298static void ssb_devices_unregister(struct ssb_bus *bus) 
     299{ 
     300        struct ssb_device *sdev; 
     301        int i; 
     302 
     303        for (i = bus->nr_devices - 1; i >= 0; i--) { 
     304                sdev = &(bus->devices[i]); 
     305                if (sdev->dev) 
     306                        device_unregister(sdev->dev); 
     307        } 
     308} 
     309 
    208310void ssb_bus_unregister(struct ssb_bus *bus) 
    209311{ 
    210         struct ssb_device *dev; 
    211         int i; 
    212  
    213312        ssb_buses_lock(); 
    214         for (i = bus->nr_devices - 1; i >= 0; i--) { 
    215                 dev = &(bus->devices[i]); 
    216                 device_unregister(&dev->dev); 
    217         } 
     313        ssb_devices_unregister(bus); 
    218314        list_del(&bus->list); 
    219315        ssb_buses_unlock(); 
    220316 
     317        /* ssb_pcmcia_exit(bus); */ 
     318        ssb_pci_exit(bus); 
    221319        ssb_iounmap(bus); 
    222320} 
     
    225323static void ssb_release_dev(struct device *dev) 
    226324{ 
    227         /* Nothing, devices are allocated together with struct ssb_bus. */ 
     325        struct __ssb_dev_wrapper *devwrap; 
     326 
     327        devwrap = container_of(dev, struct __ssb_dev_wrapper, dev); 
     328        kfree(devwrap); 
     329} 
     330 
     331static int ssb_devices_register(struct ssb_bus *bus) 
     332{ 
     333        struct ssb_device *sdev; 
     334        struct device *dev; 
     335        struct __ssb_dev_wrapper *devwrap; 
     336        int i, err = 0; 
     337        int dev_idx = 0; 
     338 
     339        for (i = 0; i < bus->nr_devices; i++) { 
     340                sdev = &(bus->devices[i]); 
     341 
     342                /* We don't register SSB-system devices to the kernel, 
     343                 * as the drivers for them are built into SSB. */ 
     344                switch (sdev->id.coreid) { 
     345                case SSB_DEV_CHIPCOMMON: 
     346                case SSB_DEV_PCI: 
     347                case SSB_DEV_PCIE: 
     348                case SSB_DEV_PCMCIA: 
     349                case SSB_DEV_MIPS: 
     350                case SSB_DEV_MIPS_3302: 
     351                case SSB_DEV_EXTIF: 
     352                        continue; 
     353                } 
     354 
     355                devwrap = kzalloc(sizeof(*devwrap), GFP_KERNEL); 
     356                if (!devwrap) { 
     357                        ssb_printk(KERN_ERR PFX 
     358                                   "Could not allocate device\n"); 
     359                        err = -ENOMEM; 
     360                        goto error; 
     361                } 
     362                dev = &devwrap->dev; 
     363                devwrap->sdev = sdev; 
     364 
     365                dev->release = ssb_release_dev; 
     366                dev->bus = &ssb_bustype; 
     367                snprintf(dev->bus_id, sizeof(dev->bus_id), 
     368                         "ssb%d:%d", bus->busnumber, dev_idx); 
     369 
     370                switch (bus->bustype) { 
     371                case SSB_BUSTYPE_PCI: 
     372#ifdef CONFIG_SSB_PCIHOST 
     373                        sdev->irq = bus->host_pci->irq; 
     374                        dev->parent = &bus->host_pci->dev; 
     375#endif 
     376                        break; 
     377                case SSB_BUSTYPE_PCMCIA: 
     378#ifdef CONFIG_SSB_PCMCIAHOST 
     379                        dev->parent = &bus->host_pcmcia->dev; 
     380#endif 
     381                        break; 
     382                case SSB_BUSTYPE_SSB: 
     383                        break; 
     384                } 
     385 
     386                sdev->dev = dev; 
     387                err = device_register(dev); 
     388                if (err) { 
     389                        ssb_printk(KERN_ERR PFX 
     390                                   "Could not register %s\n", 
     391                                   dev->bus_id); 
     392                        /* Set dev to NULL to not unregister 
     393                         * dev on error unwinding. */ 
     394                        sdev->dev = NULL; 
     395                        kfree(devwrap); 
     396                        goto error; 
     397                } 
     398                dev_idx++; 
     399        } 
     400 
     401        return 0; 
     402error: 
     403        /* Unwind the already registered devices. */ 
     404        ssb_devices_unregister(bus); 
     405        return err; 
    228406} 
    229407 
     
    232410{ 
    233411        struct ssb_bus *bus, *n; 
    234         struct ssb_device *dev; 
    235         int i, err; 
     412        int err = 0; 
     413        int drop_them_all = 0; 
    236414 
    237415        list_for_each_entry_safe(bus, n, &attach_queue, list) { 
     416                if (drop_them_all) { 
     417                        list_del(&bus->list); 
     418                        continue; 
     419                } 
     420                /* Can't init the PCIcore in ssb_bus_register(), as that 
     421                 * is too early in boot for embedded systems 
     422                 * (no udelay() available). So do it here in attach stage. 
     423                 */ 
    238424                ssb_pcicore_init(&bus->pcicore); 
    239                 for (i = 0; i < bus->nr_devices; i++) { 
    240                         dev = &(bus->devices[i]); 
    241  
    242                         dev->dev.release = ssb_release_dev; 
    243                         err = device_register(&dev->dev); 
    244                         if (err) { 
    245                                 ssb_printk(KERN_ERR PFX 
    246                                            "Could not register %s\n", 
    247                                            dev->dev.bus_id); 
    248                         } 
     425 
     426                err = ssb_devices_register(bus); 
     427                if (err) { 
     428                        drop_them_all = 1; 
     429                        list_del(&bus->list); 
     430                        continue; 
    249431                } 
    250432                list_move_tail(&bus->list, &buses); 
    251433        } 
    252         return 0; 
     434 
     435        return err; 
    253436} 
    254437 
     
    307490{ 
    308491        int err; 
    309  
    310         ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "); 
    311         switch (bus->bustype) { 
    312         case SSB_BUSTYPE_SSB: 
    313                 ssb_printk("address 0x%08lX\n", baseaddr); 
    314                 break; 
    315         case SSB_BUSTYPE_PCI: 
    316 #ifdef CONFIG_SSB_PCIHOST 
    317                 ssb_printk("PCI device %s\n", bus->host_pci->dev.bus_id); 
    318 #endif 
    319                 break; 
    320         case SSB_BUSTYPE_PCMCIA: 
    321 #ifdef CONFIG_SSB_PCMCIAHOST 
    322                 ssb_printk("PCMCIA device %s\n", bus->host_pcmcia->devname); 
    323 #endif 
    324                 break; 
    325         } 
    326492 
    327493        spin_lock_init(&bus->bar_lock); 
     
    347513        err = ssb_pcmcia_init(bus); 
    348514        if (err) 
    349                 goto err_unmap; 
     515                goto err_pci_exit; 
    350516 
    351517        /* Initialize basic system devices (if available) */ 
     
    369535err_dequeue: 
    370536        list_del(&bus->list); 
     537/* err_pcmcia_exit: */ 
     538/*      ssb_pcmcia_exit(bus); */ 
     539err_pci_exit: 
     540        ssb_pci_exit(bus); 
    371541err_unmap: 
    372542        ssb_iounmap(bus); 
     
    374544        ssb_buses_unlock(); 
    375545        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
    376         goto out; 
     546        return err; 
    377547} 
    378548 
     
    388558 
    389559        err = ssb_bus_register(bus, 0); 
     560        if (!err) { 
     561                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     562                           "PCI device %s\n", host_pci->dev.bus_id); 
     563        } 
    390564 
    391565        return err; 
     
    408582 
    409583        err = ssb_bus_register(bus, baseaddr); 
     584        if (!err) { 
     585                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     586                           "PCMCIA device %s\n", pcmcia_dev->devname); 
     587        } 
    410588 
    411589        return err; 
     
    423601        bus->ops = &ssb_ssb_ops; 
    424602        fill_sprom(&bus->sprom); 
     603 
    425604        err = ssb_bus_register(bus, baseaddr); 
     605        if (!err) { 
     606                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found at " 
     607                           "address 0x%08lX\n", baseaddr); 
     608        } 
    426609 
    427610        return err; 
     
    604787EXPORT_SYMBOL(ssb_clockspeed); 
    605788 
     789static u32 ssb_tmslow_reject_bitmask(struct ssb_device *dev) 
     790{ 
     791        /* The REJECT bit changed position in TMSLOW between 
     792         * Backplane revisions. */ 
     793        switch (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV) { 
     794        case SSB_IDLOW_SSBREV_22: 
     795                return SSB_TMSLOW_REJECT_22; 
     796        case SSB_IDLOW_SSBREV_23: 
     797                return SSB_TMSLOW_REJECT_23; 
     798        default: 
     799                assert(0); 
     800        } 
     801        return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     802} 
     803 
    606804int ssb_device_is_enabled(struct ssb_device *dev) 
    607805{ 
    608806        u32 val; 
    609  
     807        u32 reject; 
     808 
     809        reject = ssb_tmslow_reject_bitmask(dev); 
    610810        val = ssb_read32(dev, SSB_TMSLOW); 
    611         val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | SSB_TMSLOW_REJECT; 
     811        val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | reject; 
    612812 
    613813        return (val == SSB_TMSLOW_CLOCK); 
     
    678878void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
    679879{ 
     880        u32 reject; 
     881 
    680882        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
    681883                return; 
    682884 
    683         ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_REJECT | SSB_TMSLOW_CLOCK); 
    684         ssb_wait_bit(dev, SSB_TMSLOW, SSB_TMSLOW_REJECT, 1000, 1); 
     885        reject = ssb_tmslow_reject_bitmask(dev); 
     886        ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     887        ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
    685888        ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
    686889        ssb_write32(dev, SSB_TMSLOW, 
    687890                    SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
    688                     SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET | 
     891                    reject | SSB_TMSLOW_RESET | 
    689892                    core_specific_flags); 
    690893        /* flush */ 
     
    693896 
    694897        ssb_write32(dev, SSB_TMSLOW, 
    695                     SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET | 
     898                    reject | SSB_TMSLOW_RESET | 
    696899                    core_specific_flags); 
    697900        /* flush */ 
     
    716919int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask) 
    717920{ 
    718         struct device *dev = &ssb_dev->dev; 
     921        struct device *dev = ssb_dev->dev; 
    719922 
    720923#ifdef CONFIG_SSB_PCIHOST 
     
    729932} 
    730933EXPORT_SYMBOL(ssb_dma_set_mask); 
     934 
     935int ssb_bus_may_powerdown(struct ssb_bus *bus) 
     936{ 
     937        struct ssb_chipcommon *cc; 
     938        int err; 
     939 
     940        /* On buses where more than one core may be working 
     941         * at a time, we must not powerdown stuff if there are 
     942         * still cores that may want to run. */ 
     943        if (bus->bustype == SSB_BUSTYPE_SSB) 
     944                return 0; 
     945 
     946        cc = &bus->chipco; 
     947        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW); 
     948        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     949        if (err) 
     950                goto error; 
     951 
     952        return 0; 
     953error: 
     954        ssb_printk(KERN_ERR PFX "Bus powerdown failed\n"); 
     955        return err; 
     956} 
     957EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     958 
     959int ssb_bus_powerup(struct ssb_bus *bus, int dynamic_pctl) 
     960{ 
     961        struct ssb_chipcommon *cc; 
     962        int err; 
     963        enum ssb_clkmode mode; 
     964 
     965        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     966        if (err) 
     967                goto error; 
     968        cc = &bus->chipco; 
     969        mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     970        ssb_chipco_set_clockmode(cc, mode); 
     971 
     972        return 0; 
     973error: 
     974        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     975        return err; 
     976} 
     977EXPORT_SYMBOL(ssb_bus_powerup); 
    731978 
    732979u32 ssb_admatch_base(u32 adm) 
     
    7941041        err = ssb_attach_queued_buses(); 
    7951042        ssb_buses_unlock(); 
     1043        if (err) 
     1044                bus_unregister(&ssb_bustype); 
    7961045 
    7971046        return err; 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/pci.c

    r6502 r7691  
    122122                                if (err) 
    123123                                        goto err_pci; 
    124                                 msleep(2); 
     124                                msleep(5); 
    125125                        } 
    126126                } 
     
    239239        for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) 
    240240                sprom[i] = readw(bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     241} 
     242 
     243static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom) 
     244{ 
     245        struct pci_dev *pdev = bus->host_pci; 
     246        int i, err; 
     247        u32 spromctl; 
     248 
     249        ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n"); 
     250        err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl); 
     251        if (err) 
     252                goto err_ctlreg; 
     253        spromctl |= SSB_SPROMCTL_WE; 
     254        err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl); 
     255        if (err) 
     256                goto err_ctlreg; 
     257        ssb_printk(KERN_NOTICE PFX "[ 0%%"); 
     258        msleep(500); 
     259        for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) { 
     260                if (i == SSB_SPROMSIZE_WORDS / 4) 
     261                        ssb_printk("25%%"); 
     262                else if (i == SSB_SPROMSIZE_WORDS / 2) 
     263                        ssb_printk("50%%"); 
     264                else if (i == (SSB_SPROMSIZE_WORDS / 4) * 3) 
     265                        ssb_printk("75%%"); 
     266                else if (i % 2) 
     267                        ssb_printk("."); 
     268                writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     269                mmiowb(); 
     270                msleep(20); 
     271        } 
     272        err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl); 
     273        if (err) 
     274                goto err_ctlreg; 
     275        spromctl &= ~SSB_SPROMCTL_WE; 
     276        err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl); 
     277        if (err) 
     278                goto err_ctlreg; 
     279        msleep(500); 
     280        ssb_printk("100%% ]\n"); 
     281        ssb_printk(KERN_NOTICE PFX "SPROM written.\n"); 
     282 
     283        return 0; 
     284err_ctlreg: 
     285        ssb_printk(KERN_ERR PFX "Could not access SPROM control register.\n"); 
     286        return err; 
    241287} 
    242288 
     
    473519}; 
    474520 
     521static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len) 
     522{ 
     523        int i, pos = 0; 
     524 
     525        for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) { 
     526                pos += snprintf(buf + pos, buf_len - pos - 1, 
     527                                "%04X", swab16(sprom[i]) & 0xFFFF); 
     528        } 
     529        pos += snprintf(buf + pos, buf_len - pos - 1, "\n"); 
     530 
     531        return pos + 1; 
     532} 
     533 
     534static int hex2sprom(u16 *sprom, const char *dump, size_t len) 
     535{ 
     536        char tmp[5] = { 0 }; 
     537        int cnt = 0; 
     538        unsigned long parsed; 
     539 
     540        if (len < SSB_SPROMSIZE_BYTES * 2) 
     541                return -EINVAL; 
     542 
     543        while (cnt < SSB_SPROMSIZE_WORDS) { 
     544                memcpy(tmp, dump, 4); 
     545                dump += 4; 
     546                parsed = simple_strtoul(tmp, NULL, 16); 
     547                sprom[cnt++] = swab16((u16)parsed); 
     548        } 
     549 
     550        return 0; 
     551} 
     552 
     553static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev, 
     554                                       struct device_attribute *attr, 
     555                                       char *buf) 
     556{ 
     557        struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev); 
     558        struct ssb_bus *bus; 
     559        u16 *sprom; 
     560        int err = -ENODEV; 
     561        ssize_t count = 0; 
     562 
     563        bus = ssb_pci_dev_to_bus(pdev); 
     564        if (!bus) 
     565                goto out; 
     566        err = -ENOMEM; 
     567        sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL); 
     568        if (!sprom) 
     569                goto out; 
     570 
     571        err = -ERESTARTSYS; 
     572        if (mutex_lock_interruptible(&bus->pci_sprom_mutex)) 
     573                goto out_kfree; 
     574        sprom_do_read(bus, sprom); 
     575        mutex_unlock(&bus->pci_sprom_mutex); 
     576 
     577        count = sprom2hex(sprom, buf, PAGE_SIZE); 
     578        err = 0; 
     579 
     580out_kfree: 
     581        kfree(sprom); 
     582out: 
     583        return err ? err : count; 
     584} 
     585 
     586static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev, 
     587                                        struct device_attribute *attr, 
     588                                        const char *buf, size_t count) 
     589{ 
     590        struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev); 
     591        struct ssb_bus *bus; 
     592        u16 *sprom; 
     593        int res = 0, err = -ENODEV; 
     594 
     595        bus = ssb_pci_dev_to_bus(pdev); 
     596        if (!bus) 
     597                goto out; 
     598        err = -ENOMEM; 
     599        sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL); 
     600        if (!sprom) 
     601                goto out; 
     602        err = hex2sprom(sprom, buf, count); 
     603        if (err) { 
     604                err = -EINVAL; 
     605                goto out_kfree; 
     606        } 
     607        err = sprom_check_crc(sprom); 
     608        if (err) { 
     609                err = -EINVAL; 
     610                goto out_kfree; 
     611        } 
     612 
     613        err = -ERESTARTSYS; 
     614        if (mutex_lock_interruptible(&bus->pci_sprom_mutex)) 
     615                goto out_kfree; 
     616        err = ssb_devices_freeze(bus); 
     617        if (err) { 
     618                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
     619                goto out_unlock; 
     620        } 
     621        res = sprom_do_write(bus, sprom); 
     622        err = ssb_devices_thaw(bus); 
     623        if (err) 
     624                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
     625out_unlock: 
     626        mutex_unlock(&bus->pci_sprom_mutex); 
     627out_kfree: 
     628        kfree(sprom); 
     629out: 
     630        if (res) 
     631                return res; 
     632        return err ? err : count; 
     633} 
     634 
     635static DEVICE_ATTR(ssb_sprom, 0600, 
     636                   ssb_pci_attr_sprom_show, 
     637                   ssb_pci_attr_sprom_store); 
     638 
     639void ssb_pci_exit(struct ssb_bus *bus) 
     640{ 
     641        struct pci_dev *pdev; 
     642 
     643        if (bus->bustype != SSB_BUSTYPE_PCI) 
     644                return; 
     645 
     646        pdev = bus->host_pci; 
     647        device_remove_file(&pdev->dev, &dev_attr_ssb_sprom); 
     648} 
     649 
    475650int ssb_pci_init(struct ssb_bus *bus) 
    476651{ 
     652        struct pci_dev *pdev; 
     653        int err; 
     654 
    477655        if (bus->bustype != SSB_BUSTYPE_PCI) 
    478656                return 0; 
    479         return ssb_pci_sprom_get(bus); 
    480 } 
     657 
     658        pdev = bus->host_pci; 
     659        mutex_init(&bus->pci_sprom_mutex); 
     660        err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom); 
     661        if (err) 
     662                goto out; 
     663        err = ssb_pci_sprom_get(bus); 
     664        if (err) 
     665                goto err_remove_sprom_file; 
     666 
     667out: 
     668        return err; 
     669err_remove_sprom_file: 
     670        device_remove_file(&pdev->dev, &dev_attr_ssb_sprom); 
     671        return err; 
     672} 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/scan.c

    r6502 r7691  
    1717#include <linux/pci.h> 
    1818#include <asm/io.h> 
     19 
     20#ifdef CONFIG_SSB_PCMCIAHOST 
     21# include <pcmcia/cs_types.h> 
     22# include <pcmcia/cs.h> 
     23# include <pcmcia/cistpl.h> 
     24# include <pcmcia/ds.h> 
     25#endif 
    1926 
    2027#include "ssb_private.h" 
     
    223230} 
    224231 
     232static int we_support_multiple_80211_cores(struct ssb_bus *bus) 
     233{ 
     234        /* More than one 802.11 core is only supported by special chips. 
     235         * There are chips with two 802.11 cores, but with dangling 
     236         * pins on the second core. Be careful and reject them here. 
     237         */ 
     238 
     239#ifdef CONFIG_SSB_PCIHOST 
     240        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     241                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     242                    bus->host_pci->device == 0x4324) 
     243                        return 1; 
     244        } 
     245#endif /* CONFIG_SSB_PCIHOST */ 
     246        return 0; 
     247} 
     248 
    225249int ssb_bus_scan(struct ssb_bus *bus, 
    226250                 unsigned long baseaddr) 
     
    229253        void __iomem *mmio; 
    230254        u32 idhi, cc, rev, tmp; 
    231         int i; 
     255        int dev_i, i; 
    232256        struct ssb_device *dev; 
     257        int nr_80211_cores = 0; 
    233258 
    234259        mmio = ssb_ioremap(bus, baseaddr); 
     
    294319 
    295320        /* Fetch basic information about each core/device */ 
    296         for (i = 0; i < bus->nr_devices; i++) { 
     321        for (i = 0, dev_i = 0; i < bus->nr_devices; i++) { 
    297322                err = scan_switchcore(bus, i); 
    298323                if (err) 
    299324                        goto err_unmap; 
    300                 dev = &(bus->devices[i]); 
     325                dev = &(bus->devices[dev_i]); 
    301326 
    302327                idhi = scan_read32(bus, i, SSB_IDHIGH); 
     
    307332                dev->core_index = i; 
    308333                dev->bus = bus; 
    309                 if ((dev->bus->bustype == SSB_BUSTYPE_PCI) && (bus->host_pci)) 
    310                         dev->irq = bus->host_pci->irq; 
     334                dev->ops = bus->ops; 
    311335 
    312336                ssb_dprintk(KERN_INFO PFX 
     
    316340                            dev->id.coreid, dev->id.revision, dev->id.vendor); 
    317341 
    318                 dev->dev.bus = &ssb_bustype; 
    319                 snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 
    320                          "ssb%02x:%02x", bus->busnumber, i); 
    321  
    322342                switch (dev->id.coreid) { 
     343                case SSB_DEV_80211: 
     344                        nr_80211_cores++; 
     345                        if (nr_80211_cores > 1) { 
     346                                if (!we_support_multiple_80211_cores(bus)) { 
     347                                        ssb_dprintk(KERN_INFO PFX "Ignoring additional " 
     348                                                    "802.11 core\n"); 
     349                                        continue; 
     350                                } 
     351                        } 
     352                        break; 
    323353                case SSB_DEV_EXTIF: 
    324 #ifdef CONFIG_BCM947XX 
     354#ifdef CONFIG_SSB_DRIVER_EXTIF 
    325355                        if (bus->extif.dev) { 
    326356                                ssb_printk(KERN_WARNING PFX 
     
    341371                case SSB_DEV_MIPS: 
    342372                case SSB_DEV_MIPS_3302: 
    343 #ifdef CONFIG_BCM947XX 
     373#ifdef CONFIG_SSB_DRIVER_MIPS 
    344374                        if (bus->mipscore.dev) { 
    345375                                ssb_printk(KERN_WARNING PFX 
     
    348378                        } 
    349379                        bus->mipscore.dev = dev; 
    350 #endif /* CONFIG_BCM947XX */ 
     380#endif /* CONFIG_SSB_DRIVER_MIPS */ 
    351381                        break; 
    352382                case SSB_DEV_PCI: 
     
    364394                        break; 
    365395                } 
    366         } 
     396 
     397                dev_i++; 
     398        } 
     399        bus->nr_devices = dev_i; 
     400 
    367401        err = 0; 
    368402out: 
  • trunk/target/linux/brcm47xx-2.6/files/drivers/ssb/ssb_private.h

    r6502 r7691  
    5454extern int ssb_pci_sprom_get(struct ssb_bus *bus); 
    5555extern void ssb_pci_get_boardtype(struct ssb_bus *bus); 
     56extern void ssb_pci_exit(struct ssb_bus *bus); 
    5657extern int ssb_pci_init(struct ssb_bus *bus); 
    5758extern const struct ssb_bus_ops ssb_pci_ops; 
     
    7980} 
    8081static inline void ssb_pci_get_boardtype(struct ssb_bus *bus) 
     82{ 
     83} 
     84static inline void ssb_pci_exit(struct ssb_bus *bus) 
    8185{ 
    8286} 
     
    129133 
    130134/* core.c */ 
    131 extern struct bus_type ssb_bustype; 
    132135extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
     136#ifdef CONFIG_SSB_PCIHOST 
     137extern int ssb_devices_freeze(struct ssb_bus *bus); 
     138extern int ssb_devices_thaw(struct ssb_bus *bus); 
     139extern struct ssb_bus * ssb_pci_dev_to_bus(struct pci_dev *pdev); 
     140#endif /* CONFIG_SSB_PCIHOST */ 
    133141 
    134142 
  • trunk/target/linux/brcm47xx-2.6/files/include/linux/ssb/ssb.h

    r6502 r7691  
    77#include <linux/types.h> 
    88#include <linux/spinlock.h> 
     9#ifdef CONFIG_SSB_PCIHOST 
     10# include <linux/pci.h> 
     11#endif 
    912 
    1013#include <linux/ssb/ssb_regs.h> 
     
    99102 
    100103 
     104struct ssb_device; 
     105/* Lowlevel read/write operations on the device MMIO. 
     106 * Internal, don't use that outside of ssb. */ 
     107struct ssb_bus_ops { 
     108        u16 (*read16)(struct ssb_device *dev, u16 offset); 
     109        u32 (*read32)(struct ssb_device *dev, u16 offset); 
     110        void (*write16)(struct ssb_device *dev, u16 offset, u16 value); 
     111        void (*write32)(struct ssb_device *dev, u16 offset, u32 value); 
     112}; 
     113 
     114 
    101115/* Core-ID values. */ 
    102116#define SSB_DEV_CHIPCOMMON      0x800 
     
    150164#define SSB_ANY_REV             0xFF 
    151165 
     166/* Some kernel subsystems poke with dev->drvdata, so we must use the 
     167 * following ugly workaround to get from struct device to struct ssb_device */ 
     168struct __ssb_dev_wrapper { 
     169        struct device dev; 
     170        struct ssb_device *sdev; 
     171}; 
    152172 
    153173struct ssb_device { 
    154         struct device dev; 
     174        /* Having a copy of the ops pointer in each dev struct 
     175         * is an optimization. */ 
     176        const struct ssb_bus_ops *ops; 
     177 
     178        struct device *dev; 
    155179        struct ssb_bus *bus; 
    156180        struct ssb_device_id id; 
     
    158182        u8 core_index; 
    159183        unsigned int irq; 
     184 
     185        /* Internal-only stuff follows. */ 
    160186        void *drvdata;          /* Per-device data */ 
    161187        void *devtypedata;      /* Per-devicetype (eg 802.11) data */ 
    162188}; 
    163 #define dev_to_ssb_dev(_dev) container_of(_dev, struct ssb_device, dev) 
     189 
     190/* Go from struct device to struct ssb_device. */ 
     191static inline 
     192struct ssb_device * dev_to_ssb_dev(struct device *dev) 
     193{ 
     194        struct __ssb_dev_wrapper *wrap = container_of(dev, struct __ssb_dev_wrapper, dev); 
     195        return wrap->sdev; 
     196} 
    164197 
    165198/* Device specific user data */ 
     
    182215        return dev->devtypedata; 
    183216} 
    184  
    185 struct ssb_bus_ops { 
    186         u16 (*read16)(struct ssb_device *dev, u16 offset); 
    187         u32 (*read32)(struct ssb_device *dev, u16 offset); 
    188         void (*write16)(struct ssb_device *dev, u16 offset, u16 value); 
    189         void (*write32)(struct ssb_device *dev, u16 offset, u32 value); 
    190 }; 
    191217 
    192218 
     
    219245        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
    220246        SSB_BUSTYPE_PCMCIA,     /* SSB is connected to PCMCIA bus */ 
    221         //TODO SSB_BUSTYPE_JTAG, 
    222247}; 
    223248 
     
    239264#define SSB_CHIPPACK_BCM4712L   0       /* Large 340pin 4712 */ 
    240265 
    241 static inline u16 ssb_read16(struct ssb_device *dev, u16 offset); 
    242 static inline u32 ssb_read32(struct ssb_device *dev, u16 offset); 
    243 static inline void ssb_write16(struct ssb_device *dev, u16 offset, u16 value); 
    244 static inline void ssb_write32(struct ssb_device *dev, u16 offset, u32 value); 
    245 static inline u32 ssb_write32_masked(struct ssb_device *dev, u16 offset, u32 mask, u32 value); 
    246  
    247266#include <linux/ssb/ssb_driver_chipcommon.h> 
    248267#include <linux/ssb/ssb_driver_mips.h> 
     
    269288        /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
    270289        struct pcmcia_device *host_pcmcia; 
     290 
     291#ifdef CONFIG_SSB_PCIHOST 
     292        struct mutex pci_sprom_mutex; 
     293#endif 
    271294 
    272295        /* ID information about the PCB. */ 
     
    329352 
    330353 
     354/* Device MMIO register read/write functions. */ 
    331355static inline u16 ssb_read16(struct ssb_device *dev, u16 offset) 
    332356{ 
    333         return dev->bus->ops->read16(dev, offset); 
     357        return dev->ops->read16(dev, offset); 
    334358} 
    335359static inline u32 ssb_read32(struct ssb_device *dev, u16 offset) 
    336360{ 
    337         return dev->bus->ops->read32(dev, offset); 
     361        return dev->ops->read32(dev, offset); 
    338362} 
    339363static inline void ssb_write16(struct ssb_device *dev, u16 offset, u16 value) 
    340364{ 
    341         dev->bus->ops->write16(dev, offset, value); 
     365        dev->ops->write16(dev, offset, value); 
    342366} 
    343367static inline void ssb_write32(struct ssb_device *dev, u16 offset, u32 value) 
    344368{ 
    345         dev->bus->ops->write32(dev, offset, value); 
    346 } 
    347  
    348 static inline u32 ssb_write32_masked(struct ssb_device *dev, 
    349                                   u16 offset, 
    350                                   u32 mask, 
    351                                   u32 value) 
    352 { 
    353         value &= mask; 
    354         value |= ssb_read32(dev, offset) & ~mask; 
    355         ssb_write32(dev, offset, value); 
    356         return value; 
     369        dev->ops->write32(dev, offset, value); 
    357370} 
    358371 
     
    367380 
    368381 
     382#ifdef CONFIG_SSB_PCIHOST 
     383/* PCI-host wrapper driver */ 
     384extern int ssb_pcihost_register(struct pci_driver *driver); 
     385static inline void ssb_pcihost_unregister(struct pci_driver *driver) 
     386{ 
     387        pci_unregister_driver(driver); 
     388} 
     389#endif /* CONFIG_SSB_PCIHOST */ 
     390 
     391 
     392/* Bus-Power handling functions. */ 
     393extern int ssb_bus_may_powerdown(struct ssb_bus *bus); 
     394extern int ssb_bus_powerup(struct ssb_bus *bus, int dynamic_pctl); 
     395 
     396 
    369397/* Various helper functions */ 
    370398extern u32 ssb_admatch_base(u32 adm); 
  • trunk/target/linux/brcm47xx-2.6/files/include/linux/ssb/ssb_driver_chipcommon.h

    r6639 r7691  
    125125#define SSB_CHIPCO_GPIOOUTEN            0x0068 
    126126#define SSB_CHIPCO_GPIOCTL              0x006C 
    127 #define SSB_CHIPCO_GPIOINTPOL           0x0070 
    128 #define SSB_CHIPCO_GPIOINTMASK          0x0074 
     127#define SSB_CHIPCO_GPIOPOL              0x0070 
     128#define SSB_CHIPCO_GPIOIRQ              0x0074 
    129129#define SSB_CHIPCO_WATCHDOG             0x0080 
    130130#define SSB_CHIPCO_GPIOTIMER            0x0088          /* LED powersave (corerev >= 16) */ 
     
    365365extern void ssb_chipco_resume(struct ssb_chipcommon *cc); 
    366366 
    367 extern void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, u32 chip_id, 
    368         u32 *rate, u32 *plltype, u32 *n, u32 *m); 
    369367extern void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    370368                                        u32 *plltype, u32 *n, u32 *m); 
     
    381379                                     enum ssb_clkmode mode); 
    382380 
    383  
    384 /* GPIO functions */ 
    385 static inline u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, 
    386                                      u32 mask) 
    387 { 
    388         return ssb_read32(cc->dev, SSB_CHIPCO_GPIOIN) & mask; 
    389 } 
    390  
    391 static inline u32 ssb_chipco_gpio_out(struct ssb_chipcommon *cc, 
    392                                      u32 mask, u32 value) 
    393 { 
    394         return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOOUT, mask, value); 
    395 } 
    396  
    397 static inline u32 ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, 
    398                                      u32 mask, u32 value) 
    399 { 
    400         return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOOUTEN, mask, value); 
    401 } 
    402  
    403 static inline u32 ssb_chipco_gpio_control(struct ssb_chipcommon *cc, 
    404                                      u32 mask, u32 value) 
    405 { 
    406         return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOCTL, mask, value); 
    407 } 
    408  
    409 static inline u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, 
    410                                      u32 mask, u32 value) 
    411 { 
    412         return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOINTMASK, mask, value); 
    413 } 
    414  
    415 static inline u32 ssb_chipco_gpio_polarity(struct ssb_chipcommon *cc, 
    416                                      u32 mask, u32 value) 
    417 { 
    418         return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOINTPOL, mask, value); 
    419 } 
    420 /* TODO: GPIO reservation */ 
    421  
    422 extern int ssb_chipco_watchdog(struct ssb_chipcommon *cc, uint ticks); 
    423  
    424381#ifdef CONFIG_SSB_SERIAL 
    425382extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc, 
  • trunk/target/linux/brcm47xx-2.6/files/include/linux/ssb/ssb_driver_extif.h

    r6502 r7691  
    160160 
    161161 
    162 /* GPIO functions */ 
    163 static inline u32 ssb_extif_gpio_in(struct ssb_extif *extif, 
    164                                      u32 mask) 
    165 { 
    166         return ssb_read32(extif->dev, SSB_EXTIF_GPIO_IN) & mask; 
    167 } 
    168  
    169 static inline u32 ssb_extif_gpio_out(struct ssb_extif *extif, 
    170                                      u32 mask, u32 value) 
    171 { 
    172         return ssb_write32_masked(extif->dev, SSB_EXTIF_GPIO_OUT(0), mask, value); 
    173 } 
    174  
    175 static inline u32 ssb_extif_gpio_outen(struct ssb_extif *extif, 
    176                                      u32 mask, u32 value) 
    177 { 
    178         return ssb_write32_masked(extif->dev, SSB_EXTIF_GPIO_OUTEN(0), mask, value); 
    179 } 
    180  
    181 static inline u32 ssb_extif_gpio_polarity(struct ssb_extif *extif, 
    182                                      u32 mask, u32 value) 
    183 { 
    184         return ssb_write32_masked(extif->dev, SSB_EXTIF_GPIO_INTPOL, mask, value); 
    185 } 
    186  
    187 static inline u32 ssb_extif_gpio_intmask(struct ssb_extif *extif, 
    188                                      u32 mask, u32 value) 
    189 { 
    190         return ssb_write32_masked(extif->dev, SSB_EXTIF_GPIO_INTMASK, mask, value); 
    191 } 
    192  
    193  
    194162#endif /* __KERNEL__ */ 
    195163#endif /* LINUX_SSB_EXTIFCORE_H_ */ 
  • trunk/target/linux/brcm47xx-2.6/files/include/linux/ssb/ssb_driver_mips.h

    r6502 r7691  
    44#ifdef __KERNEL__ 
    55 
    6 #ifdef CONFIG_BCM947XX 
     6#ifdef CONFIG_SSB_DRIVER_MIPS 
    77 
    88struct ssb_device; 
     
    2323        struct ssb_serial_port serial_ports[4]; 
    2424 
    25         int flash_buswidth; 
    2625        u32 flash_window; 
    2726        u32 flash_window_size; 
     
    2928 
    3029extern void ssb_mipscore_init(struct ssb_mipscore *mcore); 
    31 extern u32 ssb_cpu_clock(struct ssb_mipscore *mcore); 
     30 
    3231extern unsigned int ssb_mips_irq(struct ssb_device *dev); 
    3332 
    3433 
    35 #else /* CONFIG_BCM947XX */ 
     34#else /* CONFIG_SSB_DRIVER_MIPS */ 
    3635 
    3736struct ssb_mipscore { 
     
    4342} 
    4443 
    45 #endif /* CONFIG_BCM947XX */ 
     44#endif /* CONFIG_SSB_DRIVER_MIPS */ 
    4645 
    4746#endif /* __KERNEL__ */ 
  • trunk/target/linux/brcm47xx-2.6/files/include/linux/ssb/ssb_regs.h

    r6502 r7691  
    9797#define SSB_TMSLOW              0x0F98     /* SB Target State Low */ 
    9898#define  SSB_TMSLOW_RESET       0x00000001 /* Reset */ 
    99 #define  SSB_TMSLOW_REJECT      0x00000002 /* Reject */ 
     99#define  SSB_TMSLOW_REJECT_22   0x00000002 /* Reject (Backplane rev 2.2) */ 
     100#define  SSB_TMSLOW_REJECT_23   0x00000004 /* Reject (Backplane rev 2.3) */ 
    100101#define  SSB_TMSLOW_CLOCK       0x00010000 /* Clock Enable */ 
    101102#define  SSB_TMSLOW_FGC         0x00020000 /* Force Gated Clocks On */ 
Note: See TracChangeset for help on using the changeset viewer.