Changeset 9302


Ignore:
Timestamp:
2007-10-14T04:47:36+02:00 (9 years ago)
Author:
nbd
Message:

sync ssb with upstream

Location:
trunk/target/linux
Files:
2 added
16 deleted
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm47xx/config-2.6.23

    r9279 r9302  
    172172# CONFIG_PROC_KCORE is not set 
    173173# CONFIG_RTC is not set 
    174 # CONFIG_RTL8187 is not set 
    175174CONFIG_RWSEM_GENERIC_SPINLOCK=y 
    176175CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y 
     
    200199CONFIG_SSB_DRIVER_MIPS=y 
    201200CONFIG_SSB_DRIVER_PCICORE=y 
     201CONFIG_SSB_DRIVER_PCICORE_POSSIBLE=y 
    202202CONFIG_SSB_PCICORE_HOSTMODE=y 
    203203CONFIG_SSB_PCIHOST=y 
     204CONFIG_SSB_PCIHOST_POSSIBLE=y 
     205CONFIG_SSB_POSSIBLE=y 
    204206CONFIG_SSB_SERIAL=y 
    205207# CONFIG_SSB_SILENT is not set 
     
    214216# CONFIG_TOSHIBA_RBTX4938 is not set 
    215217CONFIG_TRAD_SIGNALS=y 
    216 # CONFIG_UNUSED_SYMBOLS is not set 
    217218# CONFIG_USB_CATC is not set 
    218219CONFIG_USB_EHCI_HCD=m 
     
    222223# CONFIG_USB_OHCI_BIG_ENDIAN_MMIO is not set 
    223224CONFIG_USB_OHCI_HCD=m 
    224 # CONFIG_USB_OHCI_HCD_SSB is not set 
    225225# CONFIG_USB_PEGASUS is not set 
    226226# CONFIG_USB_R8A66597_HCD is not set 
  • trunk/target/linux/brcm47xx/files/arch/mips/bcm947xx/setup.c

    r9279 r9302  
    5656 
    5757        /* Set the watchdog timer to reset immediately */ 
    58         ssb_chipco_watchdog(&ssb.chipco, 1); 
     58        ssb_chipco_watchdog_timer_set(&ssb.chipco, 1); 
    5959        while (1) 
    6060                cpu_relax(); 
     
    6565        /* Disable interrupts and watchdog and spin forever */ 
    6666        local_irq_disable(); 
    67         ssb_chipco_watchdog(&ssb.chipco, 0); 
     67        ssb_chipco_watchdog_timer_set(&ssb.chipco, 0); 
    6868        while (1) 
    6969                cpu_relax(); 
  • trunk/target/linux/brcm47xx/patches-2.6.23/210-ssb_fixes.patch

    r9279 r9302  
    1 Index: linux-2.6.22-rc5/drivers/ssb/driver_chipcommon.c 
    2 =================================================================== 
    3 --- linux-2.6.22-rc5.orig/drivers/ssb/driver_chipcommon.c       2007-06-21 23:04:38.000000000 +0100 
    4 +++ linux-2.6.22-rc5/drivers/ssb/driver_chipcommon.c    2007-06-24 20:07:15.000000000 +0100 
    5 @@ -264,6 +264,31 @@ 
    6         ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    7  } 
    8   
    9 +/* TODO: These two functions are a clear candidate for merging, but one gets 
    10 + * the processor clock, and the other gets the bus clock. 
    11 + */ 
    12 +void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, 
    13 +                             u32 *plltype, u32 *n, u32 *m) 
    14 +{ 
    15 +       *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N); 
    16 +       *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT); 
    17 +       switch (*plltype) { 
    18 +               case SSB_PLLTYPE_2: 
    19 +               case SSB_PLLTYPE_4: 
    20 +               case SSB_PLLTYPE_6: 
    21 +               case SSB_PLLTYPE_7: 
    22 +                       *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS); 
    23 +                       break; 
    24 +               case SSB_PLLTYPE_3: 
    25 +                       /* 5350 uses m2 to control mips */ 
    26 +                       *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2); 
    27 +                       break; 
    28 +               default: 
    29 +                       *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB); 
    30 +                       break; 
    31 +       } 
    32 +} 
    33 + 
    34  void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    35                                  u32 *plltype, u32 *n, u32 *m) 
    36  { 
    37 @@ -400,3 +425,13 @@ 
    38         return nr_ports; 
    39  } 
    40  #endif /* CONFIG_SSB_SERIAL */ 
    41 + 
    42 +/* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */ 
    43 +int 
    44 +ssb_chipco_watchdog(struct ssb_chipcommon *cc, uint ticks) 
    45 +{ 
    46 +       /* instant NMI */ 
    47 +       chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks); 
    48 +       return 0; 
    49 +} 
    50 +EXPORT_SYMBOL(ssb_chipco_watchdog); 
    51 Index: linux-2.6.22-rc5/drivers/ssb/driver_mipscore.c 
    52 =================================================================== 
    53 --- linux-2.6.22-rc5.orig/drivers/ssb/driver_mipscore.c 2007-06-10 16:44:31.000000000 +0100 
    54 +++ linux-2.6.22-rc5/drivers/ssb/driver_mipscore.c      2007-06-24 20:48:52.000000000 +0100 
    55 @@ -4,6 +4,7 @@ 
    56   * 
    57   * Copyright 2005, Broadcom Corporation 
    58   * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de> 
    59 + * Copyright 2006, 2007, Felix Fietkau <nbd@openwrt.org> 
    60   * 
    61   * Licensed under the GNU/GPL. See COPYING for details. 
    62   */ 
    63 @@ -31,6 +32,16 @@ 
    64         ssb_write32(mcore->dev, offset, value); 
    65  } 
    66   
    67 +static inline u32 extif_read32(struct ssb_extif *extif, u16 offset) 
    68 +{ 
    69 +       return ssb_read32(extif->dev, offset); 
    70 +} 
    71 + 
    72 +static inline void extif_write32(struct ssb_extif *extif, u16 offset, u32 value) 
    73 +{ 
    74 +       ssb_write32(extif->dev, offset, value); 
    75 +} 
    76 + 
    77  static const u32 ipsflag_irq_mask[] = { 
    78         0, 
    79         SSB_IPSFLAG_IRQ1, 
    80 @@ -118,9 +129,9 @@ 
    81  } 
    82   
    83  /* XXX: leave here or move into separate extif driver? */ 
    84 -static int ssb_extif_serial_init(struct ssb_device *dev, struct ssb_serial_ports *ports) 
    85 +static int ssb_extif_serial_init(struct ssb_extif *dev, struct ssb_serial_port *ports) 
    86  { 
    87 - 
    88 +       return 0; 
    89  } 
    90   
    91   
    92 @@ -174,23 +185,76 @@ 
    93  { 
    94         struct ssb_bus *bus = mcore->dev->bus; 
    95   
    96 +       mcore->flash_buswidth = 2; 
    97         if (bus->chipco.dev) { 
    98                 mcore->flash_window = 0x1c000000; 
    99 -               mcore->flash_window_size = 0x800000; 
    100 +               mcore->flash_window_size = 0x02000000; 
    101 +               if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG) 
    102 +                              & SSB_CHIPCO_CFG_DS16) == 0) 
    103 +                       mcore->flash_buswidth = 1; 
    104         } else { 
    105                 mcore->flash_window = 0x1fc00000; 
    106 -               mcore->flash_window_size = 0x400000; 
    107 +               mcore->flash_window_size = 0x00400000; 
    108         } 
    109  } 
    110   
    111 +static void ssb_extif_timing_init(struct ssb_extif *extif, u32 ns) 
    112 +{ 
    113 +       u32 tmp; 
    114 + 
    115 +       /* Initialize extif so we can get to the LEDs and external UART */ 
    116 +       extif_write32(extif, SSB_EXTIF_PROG_CFG, SSB_EXTCFG_EN); 
    117 + 
    118 +       /* Set timing for the flash */ 
    119 +       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT; 
    120 +       tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT; 
    121 +       tmp |= DIV_ROUND_UP(120, ns); 
    122 +       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp); 
    123 + 
    124 +       /* Set programmable interface timing for external uart */ 
    125 +       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT; 
    126 +       tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT; 
    127 +       tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT; 
    128 +       tmp |= DIV_ROUND_UP(120, ns); 
    129 +       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp); 
    130 +} 
    131   
    132 -static void ssb_cpu_clock(struct ssb_mipscore *mcore) 
    133 +static inline void ssb_extif_get_clockcontrol(struct ssb_extif *extif, 
    134 +                                              u32 *pll_type, u32 *n, u32 *m) 
    135  { 
    136 +       *pll_type = SSB_PLLTYPE_1; 
    137 +       *n = extif_read32(extif, SSB_EXTIF_CLOCK_N); 
    138 +       *m = extif_read32(extif, SSB_EXTIF_CLOCK_SB); 
    139  } 
    140   
    141 -void ssb_mipscore_init(struct ssb_mipscore *mcore) 
    142 +u32 ssb_cpu_clock(struct ssb_mipscore *mcore) 
    143  { 
    144         struct ssb_bus *bus = mcore->dev->bus; 
    145 +       u32 pll_type, n, m, rate = 0; 
    146 + 
    147 +       if (bus->extif.dev) { 
    148 +               ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m); 
    149 +       } else if (bus->chipco.dev) { 
    150 +               ssb_chipco_get_clockcpu(&bus->chipco, &pll_type, &n, &m); 
    151 +       } else 
    152 +               return 0; 
    153 + 
    154 +       if ((pll_type == SSB_PLLTYPE_5) || (bus->chip_id == 0x5365)) { 
    155 +               rate = 200000000; 
    156 +       } else { 
    157 +               rate = ssb_calc_clock_rate(pll_type, n, m); 
    158 +       } 
    159 + 
    160 +       if (pll_type == SSB_PLLTYPE_6) { 
    161 +               rate *= 2; 
    162 +       } 
    163 + 
    164 +       return rate; 
    165 +} 
    166 + 
    167 +void ssb_mipscore_init(struct ssb_mipscore *mcore) 
    168 +{ 
    169 +       struct ssb_bus *bus; 
    170         struct ssb_device *dev; 
    171         unsigned long hz, ns; 
    172         unsigned int irq, i; 
    173 @@ -198,6 +262,8 @@ 
    174         if (!mcore->dev) 
    175                 return; /* We don't have a MIPS core */ 
    176   
    177 +       bus = mcore->dev->bus; 
    178 + 
    179         ssb_dprintk(KERN_INFO PFX "Initializing MIPS core...\n"); 
    180   
    181         hz = ssb_clockspeed(bus); 
    182 @@ -205,28 +271,9 @@ 
    183                 hz = 100000000; 
    184         ns = 1000000000 / hz; 
    185   
    186 -//TODO 
    187 -#if 0 
    188 -       if (have EXTIF) { 
    189 -               /* Initialize extif so we can get to the LEDs and external UART */ 
    190 -               W_REG(&eir->prog_config, CF_EN); 
    191 - 
    192 -               /* Set timing for the flash */ 
    193 -               tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */ 
    194 -               tmp = tmp | (CEIL(40, ns) << FW_W1_SHIFT); /* W1 = 40nS */ 
    195 -               tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */ 
    196 -               W_REG(&eir->prog_waitcount, tmp);       /* 0x01020a0c for a 100Mhz clock */ 
    197 - 
    198 -               /* Set programmable interface timing for external uart */ 
    199 -               tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */ 
    200 -               tmp = tmp | (CEIL(20, ns) << FW_W2_SHIFT); /* W2 = 20nS */ 
    201 -               tmp = tmp | (CEIL(100, ns) << FW_W1_SHIFT); /* W1 = 100nS */ 
    202 -               tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */ 
    203 -               W_REG(&eir->prog_waitcount, tmp); 
    204 -       } 
    205 -       else... chipcommon 
    206 -#endif 
    207 -       if (bus->chipco.dev) 
    208 +       if (bus->extif.dev) 
    209 +               ssb_extif_timing_init(&bus->extif, ns); 
    210 +       else if (bus->chipco.dev) 
    211                 ssb_chipco_timing_init(&bus->chipco, ns); 
    212   
    213         /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */ 
    214 @@ -256,3 +303,5 @@ 
     1Index: linux-2.6.23/drivers/ssb/driver_mipscore.c 
     2=================================================================== 
     3--- linux-2.6.23.orig/drivers/ssb/driver_mipscore.c     2007-10-14 04:32:45.793470742 +0200 
     4+++ linux-2.6.23/drivers/ssb/driver_mipscore.c  2007-10-14 04:33:25.155713862 +0200 
     5@@ -222,3 +222,5 @@ 
    2156        ssb_mips_serial_init(mcore); 
    2167        ssb_mips_flash_detect(mcore); 
     
    2189+ 
    21910+EXPORT_SYMBOL(ssb_mips_irq); 
    220 Index: linux-2.6.22-rc5/include/linux/ssb/ssb_driver_chipcommon.h 
    221 =================================================================== 
    222 --- linux-2.6.22-rc5.orig/include/linux/ssb/ssb_driver_chipcommon.h     2007-06-10 16:44:47.000000000 +0100 
    223 +++ linux-2.6.22-rc5/include/linux/ssb/ssb_driver_chipcommon.h  2007-06-24 20:07:15.000000000 +0100 
    224 @@ -364,6 +364,8 @@ 
    225  extern void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state); 
    226  extern void ssb_chipco_resume(struct ssb_chipcommon *cc); 
    227   
    228 +extern void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, 
    229 +                                    u32 *plltype, u32 *n, u32 *m); 
    230  extern void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    231                                         u32 *plltype, u32 *n, u32 *m); 
    232  extern void ssb_chipco_timing_init(struct ssb_chipcommon *cc, 
    233 @@ -378,6 +380,46 @@ 
    234  extern void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc, 
    235                                      enum ssb_clkmode mode); 
    236   
     11Index: linux-2.6.23/include/linux/ssb/ssb_driver_chipcommon.h 
     12=================================================================== 
     13--- linux-2.6.23.orig/include/linux/ssb/ssb_driver_chipcommon.h 2007-10-14 04:32:45.817472111 +0200 
     14+++ linux-2.6.23/include/linux/ssb/ssb_driver_chipcommon.h      2007-10-14 04:33:25.159714091 +0200 
     15@@ -382,11 +382,45 @@ 
     16 extern void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, 
     17                                          u32 ticks); 
     18  
     19-u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask); 
    23720+/* GPIO functions */ 
    23821+static inline u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, 
     
    24124+       return ssb_read32(cc->dev, SSB_CHIPCO_GPIOIN) & mask; 
    24225+} 
    243 + 
     26  
     27-void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value); 
    24428+static inline u32 ssb_chipco_gpio_out(struct ssb_chipcommon *cc, 
    24529+                                      u32 mask, u32 value) 
     
    24731+       return ssb_write32_masked(cc->dev, SSB_CHIPCO_GPIOOUT, mask, value); 
    24832+} 
    249 + 
     33  
     34-void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value); 
    25035+static inline u32 ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, 
    25136+                                        u32 mask, u32 value) 
     
    27459+ 
    27560+extern int ssb_chipco_watchdog(struct ssb_chipcommon *cc, uint ticks); 
    276 + 
     61  
    27762 #ifdef CONFIG_SSB_SERIAL 
    27863 extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc, 
    279                                   struct ssb_serial_port *ports); 
    280 Index: linux-2.6.22-rc5/include/linux/ssb/ssb_driver_extif.h 
    281 =================================================================== 
    282 --- linux-2.6.22-rc5.orig/include/linux/ssb/ssb_driver_extif.h  2007-06-10 16:44:47.000000000 +0100 
    283 +++ linux-2.6.22-rc5/include/linux/ssb/ssb_driver_extif.h       2007-06-24 20:07:15.000000000 +0100 
    284 @@ -158,6 +158,36 @@ 
    285  /* watchdog */ 
     64Index: linux-2.6.23/include/linux/ssb/ssb_driver_extif.h 
     65=================================================================== 
     66--- linux-2.6.23.orig/include/linux/ssb/ssb_driver_extif.h      2007-10-14 04:32:45.821472339 +0200 
     67+++ linux-2.6.23/include/linux/ssb/ssb_driver_extif.h   2007-10-14 04:33:25.167714544 +0200 
     68@@ -153,7 +153,6 @@ 
    28669 #define SSB_EXTIF_WATCHDOG_CLK         48000000        /* Hz */ 
     70  
     71  
     72- 
     73 #ifdef CONFIG_SSB_DRIVER_EXTIF 
     74  
     75 struct ssb_extif { 
     76@@ -171,17 +170,42 @@ 
     77 extern void ssb_extif_timing_init(struct ssb_extif *extif, 
     78                                  unsigned long ns); 
     79  
     80-u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask); 
     81- 
     82-void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value); 
     83- 
     84-void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value); 
     85- 
     86 #ifdef CONFIG_SSB_SERIAL 
     87 extern int ssb_extif_serial_init(struct ssb_extif *extif, 
     88                                 struct ssb_serial_port *ports); 
     89 #endif /* CONFIG_SSB_SERIAL */ 
    28790  
    28891+/* GPIO functions */ 
     
    316119+       return ssb_write32_masked(extif->dev, SSB_EXTIF_GPIO_INTMASK, mask, value); 
    317120+} 
    318   
    319  #endif /* __KERNEL__ */ 
    320  #endif /* LINUX_SSB_EXTIFCORE_H_ */ 
    321 Index: linux-2.6.22-rc5/include/linux/ssb/ssb_driver_mips.h 
    322 =================================================================== 
    323 --- linux-2.6.22-rc5.orig/include/linux/ssb/ssb_driver_mips.h   2007-06-10 16:44:47.000000000 +0100 
    324 +++ linux-2.6.22-rc5/include/linux/ssb/ssb_driver_mips.h        2007-06-24 20:07:15.000000000 +0100 
    325 @@ -22,11 +22,13 @@ 
    326         int nr_serial_ports; 
    327         struct ssb_serial_port serial_ports[4]; 
    328   
    329 +       int flash_buswidth; 
    330         u32 flash_window; 
    331         u32 flash_window_size; 
    332  }; 
    333   
    334  extern void ssb_mipscore_init(struct ssb_mipscore *mcore); 
    335 +extern u32 ssb_cpu_clock(struct ssb_mipscore *mcore); 
    336   
    337  extern unsigned int ssb_mips_irq(struct ssb_device *dev); 
    338   
    339 Index: linux-2.6.22-rc5/include/linux/ssb/ssb.h 
    340 =================================================================== 
    341 --- linux-2.6.22-rc5.orig/include/linux/ssb/ssb.h       2007-06-24 19:49:56.000000000 +0100 
    342 +++ linux-2.6.22-rc5/include/linux/ssb/ssb.h    2007-06-24 20:07:15.000000000 +0100 
    343 @@ -270,6 +270,12 @@ 
     121+ 
     122  
     123 #else /* CONFIG_SSB_DRIVER_EXTIF */ 
     124 /* extif disabled */ 
     125Index: linux-2.6.23/include/linux/ssb/ssb.h 
     126=================================================================== 
     127--- linux-2.6.23.orig/include/linux/ssb/ssb.h   2007-10-14 04:32:45.833473010 +0200 
     128+++ linux-2.6.23/include/linux/ssb/ssb.h        2007-10-14 04:33:25.171714773 +0200 
     129@@ -255,6 +255,12 @@ 
    344130 #define SSB_CHIPPACK_BCM4712M  2       /* Medium 225pin 4712 */ 
    345131 #define SSB_CHIPPACK_BCM4712L  0       /* Large 340pin 4712 */ 
     
    354140 #include <linux/ssb/ssb_driver_mips.h> 
    355141 #include <linux/ssb/ssb_driver_extif.h> 
    356 @@ -388,6 +394,16 @@ 
     142@@ -385,6 +391,16 @@ 
    357143        dev->ops->write32(dev, offset, value); 
    358144 } 
     
    371157 /* Translation (routing) bits that need to be ORed to DMA 
    372158  * addresses before they are given to a device. */ 
     159Index: linux-2.6.23/drivers/ssb/driver_chipcommon.c 
     160=================================================================== 
     161--- linux-2.6.23.orig/drivers/ssb/driver_chipcommon.c   2007-10-14 04:32:45.797470966 +0200 
     162+++ linux-2.6.23/drivers/ssb/driver_chipcommon.c        2007-10-14 04:33:25.175715001 +0200 
     163@@ -351,21 +351,6 @@ 
     164        chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks); 
     165 } 
     166  
     167-u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask) 
     168-{ 
     169-       return chipco_read32(cc, SSB_CHIPCO_GPIOIN) & mask; 
     170-} 
     171- 
     172-void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     173-{ 
     174-       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value); 
     175-} 
     176- 
     177-void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     178-{ 
     179-       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value); 
     180-} 
     181- 
     182 #ifdef CONFIG_SSB_SERIAL 
     183 int ssb_chipco_serial_init(struct ssb_chipcommon *cc, 
     184                           struct ssb_serial_port *ports) 
     185Index: linux-2.6.23/drivers/ssb/driver_extif.c 
     186=================================================================== 
     187--- linux-2.6.23.orig/drivers/ssb/driver_extif.c        2007-10-14 04:32:45.809471640 +0200 
     188+++ linux-2.6.23/drivers/ssb/driver_extif.c     2007-10-14 04:33:25.179715231 +0200 
     189@@ -110,20 +110,4 @@ 
     190        *m = extif_read32(extif, SSB_EXTIF_CLOCK_SB); 
     191 } 
     192  
     193-u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask) 
     194-{ 
     195-       return extif_read32(extif, SSB_EXTIF_GPIO_IN) & mask; 
     196-} 
     197- 
     198-void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value) 
     199-{ 
     200-       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUT(0), 
     201-                                  mask, value); 
     202-} 
     203- 
     204-void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value) 
     205-{ 
     206-       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUTEN(0), 
     207-                                  mask, value); 
     208-} 
     209  
     210Index: linux-2.6.23/include/linux/mod_devicetable.h 
     211=================================================================== 
     212--- linux-2.6.23.orig/include/linux/mod_devicetable.h   2007-10-14 04:35:22.102378272 +0200 
     213+++ linux-2.6.23/include/linux/mod_devicetable.h        2007-10-14 04:34:41.172045787 +0200 
     214@@ -340,4 +340,19 @@ 
     215 #define PA_HVERSION_ANY_ID     0xffff 
     216 #define PA_SVERSION_ANY_ID     0xffffffff 
     217  
     218+/* SSB core, see drivers/ssb/ */ 
     219+struct ssb_device_id { 
     220+       __u16   vendor; 
     221+       __u16   coreid; 
     222+       __u8    revision; 
     223+}; 
     224+#define SSB_DEVICE(_vendor, _coreid, _revision)  \ 
     225+       { .vendor = _vendor, .coreid = _coreid, .revision = _revision, } 
     226+#define SSB_DEVTABLE_END  \ 
     227+       { 0, }, 
     228+ 
     229+#define SSB_ANY_VENDOR         0xFFFF 
     230+#define SSB_ANY_ID             0xFFFF 
     231+#define SSB_ANY_REV            0xFF 
     232+ 
     233 #endif /* LINUX_MOD_DEVICETABLE_H */ 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/Kconfig

    r7691 r9302  
    11menu "Sonics Silicon Backplane" 
     2 
     3config SSB_POSSIBLE 
     4        bool 
     5        depends on HAS_IOMEM 
     6        default y 
    27 
    38config SSB 
    49        tristate "Sonics Silicon Backplane support" 
    5         depends on EXPERIMENTAL 
     10        depends on SSB_POSSIBLE 
    611        help 
    7           Support for the Sonics Silicon Backplane bus 
     12          Support for the Sonics Silicon Backplane bus. 
     13          You only need to enable this option, if you are 
     14          configuring a kernel for an embedded system with 
     15          this bus. 
     16          It will be auto-selected if needed in other 
     17          environments. 
    818 
    9           The module will be called ssb 
     19          The module will be called ssb. 
    1020 
    11           If unsure, say M 
     21          If unsure, say N. 
     22 
     23config SSB_PCIHOST_POSSIBLE 
     24        bool 
     25        depends on SSB && PCI 
     26        default y 
    1227 
    1328config SSB_PCIHOST 
    1429        bool "Support for SSB on PCI-bus host" 
    15         depends on SSB && PCI 
     30        depends on SSB_PCIHOST_POSSIBLE 
    1631        default y 
    1732        help 
     
    2136          If unsure, say Y 
    2237 
     38config SSB_PCMCIAHOST_POSSIBLE 
     39        bool 
     40        depends on SSB && PCMCIA && EXPERIMENTAL 
     41        default y 
     42 
    2343config SSB_PCMCIAHOST 
    24         bool "Support for SSB on PCMCIA-bus host" 
    25         depends on SSB && PCMCIA 
     44        bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)" 
     45        depends on SSB_PCMCIAHOST_POSSIBLE 
    2646        help 
    2747          Support for a Sonics Silicon Backplane on top 
     
    3252config SSB_SILENT 
    3353        bool "No SSB kernel messages" 
    34         depends on SSB 
     54        depends on SSB && EMBEDDED 
    3555        help 
    3656          This option turns off all Sonics Silicon Backplane printks. 
     
    5676        # ChipCommon and ExtIf serial support routines. 
    5777 
     78config SSB_DRIVER_PCICORE_POSSIBLE 
     79        bool 
     80        depends on SSB_PCIHOST 
     81        default y 
     82 
    5883config SSB_DRIVER_PCICORE 
    5984        bool "SSB PCI core driver" 
    60         depends on SSB && SSB_PCIHOST 
    61         default y 
     85        depends on SSB_DRIVER_PCICORE_POSSIBLE 
    6286        help 
    6387          Driver for the Sonics Silicon Backplane attached 
     
    6791 
    6892config SSB_PCICORE_HOSTMODE 
    69         bool "Hostmode support for SSB PCI core" 
    70         depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS 
     93        bool "Hostmode support for SSB PCI core (EXPERIMENTAL)" 
     94        depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS && EXPERIMENTAL 
    7195        help 
    7296          PCIcore hostmode operation (external PCI bus). 
    7397 
    7498config SSB_DRIVER_MIPS 
    75         bool "SSB Broadcom MIPS core driver" 
    76         depends on SSB && MIPS 
     99        bool "SSB Broadcom MIPS core driver (EXPERIMENTAL)" 
     100        depends on SSB && MIPS && EXPERIMENTAL 
    77101        select SSB_SERIAL 
    78102        help 
     
    83107 
    84108config SSB_DRIVER_EXTIF 
    85         bool "SSB Broadcom EXTIF core driver" 
    86         depends on SSB_DRIVER_MIPS 
     109        bool "SSB Broadcom EXTIF core driver (EXPERIMENTAL)" 
     110        depends on SSB_DRIVER_MIPS && EXPERIMENTAL 
    87111        help 
    88112          Driver for the Sonics Silicon Backplane attached 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/Makefile

    r7691 r9302  
    1 ssb-builtin-drivers-y                                   += driver_chipcommon.o 
    2 ssb-builtin-drivers-$(CONFIG_SSB_DRIVER_MIPS)           += driver_mipscore.o 
    3 ssb-builtin-drivers-$(CONFIG_SSB_DRIVER_PCICORE)        += driver_pcicore.o 
     1# core 
     2ssb-y                                   += main.o scan.o 
    43 
    5 ssb-hostsupport-$(CONFIG_SSB_PCIHOST)                   += pci.o pcihost_wrapper.o 
    6 ssb-hostsupport-$(CONFIG_SSB_PCMCIAHOST)                += pcmcia.o 
     4# host support 
     5ssb-$(CONFIG_SSB_PCIHOST)               += pci.o pcihost_wrapper.o 
     6ssb-$(CONFIG_SSB_PCMCIAHOST)            += pcmcia.o 
    77 
    8 obj-$(CONFIG_SSB) += ssb.o 
     8# built-in drivers 
     9ssb-y                                   += driver_chipcommon.o 
     10ssb-$(CONFIG_SSB_DRIVER_MIPS)           += driver_mipscore.o 
     11ssb-$(CONFIG_SSB_DRIVER_EXTIF)          += driver_extif.o 
     12ssb-$(CONFIG_SSB_DRIVER_PCICORE)        += driver_pcicore.o 
    913 
    10 ssb-objs        := main.o scan.o \ 
    11                    $(ssb-hostsupport-y) $(ssb-builtin-drivers-y) 
     14# b43 pci-ssb-bridge driver 
     15# Not strictly a part of SSB, but kept here for convenience 
     16ssb-$(CONFIG_SSB_PCIHOST)               += b43_pci_bridge.o 
     17 
     18obj-$(CONFIG_SSB)                       += ssb.o 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/driver_chipcommon.c

    r7732 r9302  
    1717 
    1818/* Clock sources */ 
    19 enum { 
     19enum ssb_clksrc { 
    2020        /* PCI clock */ 
    2121        SSB_CHIPCO_CLKSRC_PCI, 
     
    3838{ 
    3939        ssb_write32(cc->dev, offset, value); 
     40} 
     41 
     42static inline void chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset, 
     43                                         u32 mask, u32 value) 
     44{ 
     45        value &= mask; 
     46        value |= chipco_read32(cc, offset) & ~mask; 
     47        chipco_write32(cc, offset, value); 
    4048} 
    4149 
     
    8694                break; 
    8795        default: 
    88                 assert(0); 
     96                SSB_WARN_ON(1); 
    8997        } 
    9098} 
    9199 
    92100/* Get the Slow Clock Source */ 
    93 static int chipco_pctl_get_slowclksrc(struct ssb_chipcommon *cc) 
     101static enum ssb_clksrc chipco_pctl_get_slowclksrc(struct ssb_chipcommon *cc) 
    94102{ 
    95103        struct ssb_bus *bus = cc->dev->bus; 
    96         u32 tmp = 0; 
     104        u32 uninitialized_var(tmp); 
    97105 
    98106        if (cc->dev->id.revision < 6) { 
     
    124132static int chipco_pctl_clockfreqlimit(struct ssb_chipcommon *cc, int get_max) 
    125133{ 
    126         int limit; 
    127         int clocksrc; 
    128         int divisor; 
     134        int uninitialized_var(limit); 
     135        enum ssb_clksrc clocksrc; 
     136        int divisor = 1; 
    129137        u32 tmp; 
    130138 
     
    139147                        break; 
    140148                default: 
    141                         assert(0); 
    142                         divisor = 1; 
     149                        SSB_WARN_ON(1); 
    143150                } 
    144151        } else if (cc->dev->id.revision < 10) { 
    145152                switch (clocksrc) { 
    146153                case SSB_CHIPCO_CLKSRC_LOPWROS: 
    147                         divisor = 1; 
    148154                        break; 
    149155                case SSB_CHIPCO_CLKSRC_XTALOS: 
     
    153159                        divisor *= 4; 
    154160                        break; 
    155                 default: 
    156                         assert(0); 
    157                         divisor = 1; 
    158161                } 
    159162        } else { 
     
    182185                        limit = 25000000; 
    183186                break; 
    184         default: 
    185                 assert(0); 
    186                 limit = 0; 
    187187        } 
    188188        limit /= divisor; 
     
    236236        pll_on_delay = chipco_read32(cc, SSB_CHIPCO_PLLONDELAY); 
    237237        tmp = (((pll_on_delay + 2) * 1000000) + (minfreq - 1)) / minfreq; 
    238         assert((tmp & ~0xFFFF) == 0); 
     238        SSB_WARN_ON(tmp & ~0xFFFF); 
    239239 
    240240        cc->fast_pwrup_delay = tmp; 
     
    265265} 
    266266 
     267/* Get the processor clock */ 
     268void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, 
     269                             u32 *plltype, u32 *n, u32 *m) 
     270{ 
     271        *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N); 
     272        *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT); 
     273        switch (*plltype) { 
     274        case SSB_PLLTYPE_2: 
     275        case SSB_PLLTYPE_4: 
     276        case SSB_PLLTYPE_6: 
     277        case SSB_PLLTYPE_7: 
     278                *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS); 
     279                break; 
     280        case SSB_PLLTYPE_3: 
     281                /* 5350 uses m2 to control mips */ 
     282                *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2); 
     283                break; 
     284        default: 
     285                *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB); 
     286                break; 
     287        } 
     288} 
     289 
     290/* Get the bus clock */ 
    267291void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    268292                                 u32 *plltype, u32 *n, u32 *m) 
     
    321345} 
    322346 
     347/* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */ 
     348void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks) 
     349{ 
     350        /* instant NMI */ 
     351        chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks); 
     352} 
     353 
     354u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask) 
     355{ 
     356        return chipco_read32(cc, SSB_CHIPCO_GPIOIN) & mask; 
     357} 
     358 
     359void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     360{ 
     361        chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value); 
     362} 
     363 
     364void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     365{ 
     366        chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value); 
     367} 
    323368 
    324369#ifdef CONFIG_SSB_SERIAL 
     
    353398                        /* Internal backplane clock */ 
    354399                        baud_base = ssb_clockspeed(bus); 
    355                         div = 2; /* Minimum divisor */ 
    356                         chipco_write32(cc, SSB_CHIPCO_CLKDIV, 
    357                                        (chipco_read32(cc, SSB_CHIPCO_CLKDIV) 
    358                                         & ~SSB_CHIPCO_CLKDIV_UART) | div); 
     400                        div = chipco_read32(cc, SSB_CHIPCO_CLKDIV) 
     401                              & SSB_CHIPCO_CLKDIV_UART; 
    359402                } else { 
    360403                        /* Fixed internal backplane clock */ 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/driver_mipscore.c

    r7691 r9302  
    1414#include <linux/serial_core.h> 
    1515#include <linux/serial_reg.h> 
    16 #include <asm/time.h> 
     16#include <linux/time.h> 
    1717 
    1818#include "ssb_private.h" 
     
    118118} 
    119119 
    120 /* XXX: leave here or move into separate extif driver? */ 
    121 static int ssb_extif_serial_init(struct ssb_device *dev, struct ssb_serial_ports *ports) 
    122 { 
    123  
    124 } 
    125  
    126  
    127120static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
    128121{ 
    129122        struct ssb_bus *bus = mcore->dev->bus; 
    130123 
    131         //TODO if (EXTIF available 
    132 #if 0 
    133                 extifregs_t *eir = (extifregs_t *) regs; 
    134                 sbconfig_t *sb; 
    135  
    136                 /* Determine external UART register base */ 
    137                 sb = (sbconfig_t *)((ulong) eir + SBCONFIGOFF); 
    138                 base = EXTIF_CFGIF_BASE(sb_base(R_REG(&sb->sbadmatch1))); 
    139  
    140                 /* Determine IRQ */ 
    141                 irq = sb_irq(sbh); 
    142  
    143                 /* Disable GPIO interrupt initially */ 
    144                 W_REG(&eir->gpiointpolarity, 0); 
    145                 W_REG(&eir->gpiointmask, 0); 
    146  
    147                 /* Search for external UARTs */ 
    148                 n = 2; 
    149                 for (i = 0; i < 2; i++) { 
    150                         regs = (void *) REG_MAP(base + (i * 8), 8); 
    151                         if (BCMINIT(serial_exists)(regs)) { 
    152                                 /* Set GPIO 1 to be the external UART IRQ */ 
    153                                 W_REG(&eir->gpiointmask, 2); 
    154                                 if (add) 
    155                                         add(regs, irq, 13500000, 0); 
    156                         } 
    157                 } 
    158  
    159                 /* Add internal UART if enabled */ 
    160                 if (R_REG(&eir->corecontrol) & CC_UE) 
    161                         if (add) 
    162                                 add((void *) &eir->uartdata, irq, sb_clock(sbh), 2); 
    163  
    164 #endif 
    165124        if (bus->extif.dev) 
    166125                mcore->nr_serial_ports = ssb_extif_serial_init(&bus->extif, mcore->serial_ports); 
     
    175134        struct ssb_bus *bus = mcore->dev->bus; 
    176135 
     136        mcore->flash_buswidth = 2; 
    177137        if (bus->chipco.dev) { 
    178138                mcore->flash_window = 0x1c000000; 
    179                 mcore->flash_window_size = 0x800000; 
     139                mcore->flash_window_size = 0x02000000; 
     140                if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG) 
     141                               & SSB_CHIPCO_CFG_DS16) == 0) 
     142                        mcore->flash_buswidth = 1; 
    180143        } else { 
    181144                mcore->flash_window = 0x1fc00000; 
    182                 mcore->flash_window_size = 0x400000; 
    183         } 
    184 } 
    185  
    186  
    187 static void ssb_cpu_clock(struct ssb_mipscore *mcore) 
    188 { 
     145                mcore->flash_window_size = 0x00400000; 
     146        } 
     147} 
     148 
     149u32 ssb_cpu_clock(struct ssb_mipscore *mcore) 
     150{ 
     151        struct ssb_bus *bus = mcore->dev->bus; 
     152        u32 pll_type, n, m, rate = 0; 
     153 
     154        if (bus->extif.dev) { 
     155                ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m); 
     156        } else if (bus->chipco.dev) { 
     157                ssb_chipco_get_clockcpu(&bus->chipco, &pll_type, &n, &m); 
     158        } else 
     159                return 0; 
     160 
     161        if ((pll_type == SSB_PLLTYPE_5) || (bus->chip_id == 0x5365)) { 
     162                rate = 200000000; 
     163        } else { 
     164                rate = ssb_calc_clock_rate(pll_type, n, m); 
     165        } 
     166 
     167        if (pll_type == SSB_PLLTYPE_6) { 
     168                rate *= 2; 
     169        } 
     170 
     171        return rate; 
    189172} 
    190173 
    191174void ssb_mipscore_init(struct ssb_mipscore *mcore) 
    192175{ 
    193         struct ssb_bus *bus = mcore->dev->bus; 
     176        struct ssb_bus *bus; 
    194177        struct ssb_device *dev; 
    195178        unsigned long hz, ns; 
     
    201184        ssb_dprintk(KERN_INFO PFX "Initializing MIPS core...\n"); 
    202185 
     186        bus = mcore->dev->bus; 
    203187        hz = ssb_clockspeed(bus); 
    204188        if (!hz) 
     
    206190        ns = 1000000000 / hz; 
    207191 
    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) 
     192        if (bus->extif.dev) 
     193                ssb_extif_timing_init(&bus->extif, ns); 
     194        else if (bus->chipco.dev) 
    230195                ssb_chipco_timing_init(&bus->chipco, ns); 
    231196 
     
    234199                dev = &(bus->devices[i]); 
    235200                dev->irq = ssb_mips_irq(dev) + 2; 
    236                 switch(dev->id.coreid) { 
    237                         case SSB_DEV_USB11_HOST: 
    238                                 /* shouldn't need a separate irq line for non-4710, most of them have a proper 
    239                                  * external usb controller on the pci */ 
    240                                 if ((bus->chip_id == 0x4710) && (irq <= 4)) { 
    241                                         set_irq(dev, irq++); 
    242                                         break; 
    243                                 } 
    244                         case SSB_DEV_PCI: 
    245                         case SSB_DEV_ETHERNET: 
    246                         case SSB_DEV_80211: 
    247                         case SSB_DEV_USB20_HOST: 
    248                                 /* These devices get their own IRQ line if available, the rest goes on IRQ0 */ 
    249                                 if (irq <= 4) { 
    250                                         set_irq(dev, irq++); 
    251                                         break; 
    252                                 } 
     201                switch (dev->id.coreid) { 
     202                case SSB_DEV_USB11_HOST: 
     203                        /* shouldn't need a separate irq line for non-4710, most of them have a proper 
     204                         * external usb controller on the pci */ 
     205                        if ((bus->chip_id == 0x4710) && (irq <= 4)) { 
     206                                set_irq(dev, irq++); 
     207                                break; 
     208                        } 
     209                        /* fallthrough */ 
     210                case SSB_DEV_PCI: 
     211                case SSB_DEV_ETHERNET: 
     212                case SSB_DEV_80211: 
     213                case SSB_DEV_USB20_HOST: 
     214                        /* These devices get their own IRQ line if available, the rest goes on IRQ0 */ 
     215                        if (irq <= 4) { 
     216                                set_irq(dev, irq++); 
     217                                break; 
     218                        } 
    253219                } 
    254220        } 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/driver_pcicore.c

    r9281 r9302  
    3535 
    3636#include <asm/paccess.h> 
    37 /* Read the bus and catch bus exceptions. This is MIPS specific. */ 
    38 #define mips_busprobe(val, addr)        get_dbe((val), (addr)) 
     37/* Probe a 32bit value on the bus and catch bus exceptions. 
     38 * Returns nonzero on a bus exception. 
     39 * This is MIPS specific */ 
     40#define mips_busprobe32(val, addr)      get_dbe((val), ((u32 *)(addr))) 
    3941 
    4042/* Assume one-hot slot wiring */ 
     
    4648static struct ssb_pcicore *extpci_core; 
    4749 
    48 u32 pci_iobase = 0x100; 
    49 u32 pci_membase = SSB_PCI_DMA; 
     50static u32 ssb_pcicore_pcibus_iobase = 0x100; 
     51static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA; 
    5052 
    5153int pcibios_plat_dev_init(struct pci_dev *d) 
     
    5557        u32 *base; 
    5658 
    57         printk("PCI: Fixing up device %s\n", pci_name(d)); 
     59        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
     60                   pci_name(d)); 
    5861 
    5962        /* Fix up resource bases */ 
    6063        for (pos = 0; pos < 6; pos++) { 
    6164                res = &d->resource[pos]; 
    62                 base = ((res->flags & IORESOURCE_IO) ? &pci_iobase : &pci_membase); 
     65                if (res->flags & IORESOURCE_IO) 
     66                        base = &ssb_pcicore_pcibus_iobase; 
     67                else 
     68                        base = &ssb_pcicore_pcibus_membase; 
    6369                if (res->end) { 
    6470                        size = res->end - res->start + 1; 
     
    8692                return; 
    8793 
    88         printk("PCI: fixing up bridge\n"); 
     94        ssb_printk(KERN_INFO "PCI: fixing up bridge\n"); 
    8995 
    9096        /* Enable PCI bridge bus mastering and memory space */ 
     
    94100        /* Enable PCI bridge BAR1 prefetch and burst */ 
    95101        pci_write_config_dword(dev, SSB_BAR1_CONTROL, 3); 
     102 
     103        /* Make sure our latency is high enough to handle the devices behind us */ 
     104        pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xa8); 
    96105} 
    97106DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, ssb_fixup_pcibridge); 
    98107 
    99 int __init pcibios_map_irq(struct pci_dev *dev, u8 slot, u8 pin) 
     108int __init pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) 
    100109{ 
    101110        return ssb_mips_irq(extpci_core->dev) + 2; 
     
    148157        void __iomem *mmio; 
    149158 
    150         assert(pc->hostmode); 
     159        SSB_WARN_ON(!pc->hostmode); 
    151160        if (unlikely(len != 1 && len != 2 && len != 4)) 
    152161                goto out; 
     
    159168                goto out; 
    160169 
    161         if (mips_busprobe(val, (u32 *) mmio)) { 
     170        if (mips_busprobe32(val, mmio)) { 
    162171                val = 0xffffffff; 
    163172                goto unmap; 
     
    194203        void __iomem *mmio; 
    195204 
    196         assert(pc->hostmode); 
     205        SSB_WARN_ON(!pc->hostmode); 
    197206        if (unlikely(len != 1 && len != 2 && len != 4)) 
    198207                goto out; 
     
    205214                goto out; 
    206215 
    207         if (mips_busprobe(val, (u32 *) mmio)) { 
     216        if (mips_busprobe32(val, mmio)) { 
    208217                val = 0xffffffff; 
    209218                goto unmap; 
     
    225234                break; 
    226235        } 
    227         writel(*((const u32 *)buf), mmio); 
     236        writel(val, mmio); 
    228237 
    229238        err = 0; 
     
    270279        .name   = "SSB PCIcore external memory", 
    271280        .start  = SSB_PCI_DMA, 
    272         .end    = (u32)SSB_PCI_DMA + (u32)SSB_PCI_DMA_SZ - 1, 
     281        .end    = SSB_PCI_DMA + SSB_PCI_DMA_SZ - 1, 
    273282        .flags  = IORESOURCE_MEM, 
    274283}; 
     
    292301        u32 val; 
    293302 
    294         if (extpci_core) { 
    295                 WARN_ON(1); 
     303        if (WARN_ON(extpci_core)) 
    296304                return; 
    297         } 
    298305        extpci_core = pc; 
    299306 
     
    305312        val |= SSB_PCICORE_CTL_CLK; /* Clock on */ 
    306313        pcicore_write32(pc, SSB_PCICORE_CTL, val); 
    307         udelay(150); 
     314        udelay(150); /* Assertion time demanded by the PCI standard */ 
    308315        val |= SSB_PCICORE_CTL_RST; /* Deassert RST# */ 
    309316        pcicore_write32(pc, SSB_PCICORE_CTL, val); 
    310         udelay(1); 
    311  
    312         //TODO cardbus mode 
     317        val = SSB_PCICORE_ARBCTL_INTERN; 
     318        pcicore_write32(pc, SSB_PCICORE_ARBCTL, val); 
     319        udelay(1); /* Assertion time demanded by the PCI standard */ 
     320 
     321        /*TODO cardbus mode */ 
    313322 
    314323        /* 64MB I/O window */ 
     
    337346         * to non-MIPS platform. */ 
    338347        set_io_port_base((unsigned long)ioremap_nocache(SSB_PCI_MEM, 0x04000000)); 
     348        /* Give some time to the PCI controller to configure itself with the new 
     349         * values. Not waiting at this point causes crashes of the machine. */ 
     350        mdelay(10); 
    339351        register_pci_controller(&ssb_pcicore_controller); 
    340352} 
     
    365377                return 0; 
    366378 
    367         return !mips_busprobe(tmp, (u32 *) (bus->mmio + (pc->dev->core_index * SSB_CORE_SIZE))); 
     379        return !mips_busprobe32(tmp, (bus->mmio + (pc->dev->core_index * SSB_CORE_SIZE))); 
    368380} 
    369381#endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
     
    431443        v |= data; 
    432444        pcicore_write32(pc, mdio_data, v); 
     445        /* Wait for the device to complete the transaction */ 
    433446        udelay(10); 
    434447        for (i = 0; i < 10; i++) { 
     
    459472 
    460473        dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
    461         assert(dev); 
     474        if (WARN_ON(!dev)) 
     475                return; 
    462476        /* This forces an update of the cached registers. */ 
    463477        ssb_broadcast_value(dev, 0xFD8, 0); 
     
    497511 
    498512                intvec = ssb_read32(pdev, SSB_INTVEC); 
    499                 tmp = ssb_read32(dev, SSB_TPSFLAG); 
    500                 tmp &= SSB_TPSFLAG_BPFLAG; 
    501                 intvec |= tmp; 
     513                if ((bus->chip_id & 0xFF00) == 0x4400) { 
     514                        /* Workaround: On the BCM44XX the BPFLAG routing 
     515                         * bit is wrong. Use a hardcoded constant. */ 
     516                        intvec |= 0x00000002; 
     517                } else { 
     518                        tmp = ssb_read32(dev, SSB_TPSFLAG); 
     519                        tmp &= SSB_TPSFLAG_BPFLAG; 
     520                        intvec |= tmp; 
     521                } 
    502522                ssb_write32(pdev, SSB_INTVEC, intvec); 
    503523        } 
     
    526546                } 
    527547        } else { 
    528                 assert(pdev->id.coreid == SSB_DEV_PCIE); 
     548                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
    529549                //TODO: Better make defines for all these magic PCIE values. 
    530550                if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/main.c

    r7732 r9302  
    1414#include <linux/ssb/ssb.h> 
    1515#include <linux/ssb/ssb_regs.h> 
    16  
    17 #ifdef CONFIG_SSB_PCIHOST 
    18 # include <linux/pci.h> 
    19 #endif 
    20  
    21 #ifdef CONFIG_SSB_PCMCIAHOST 
    22 # include <pcmcia/cs_types.h> 
    23 # include <pcmcia/cs.h> 
    24 # include <pcmcia/cistpl.h> 
    25 # include <pcmcia/ds.h> 
    26 #endif 
     16#include <linux/dma-mapping.h> 
     17#include <linux/pci.h> 
     18 
     19#include <pcmcia/cs_types.h> 
     20#include <pcmcia/cs.h> 
     21#include <pcmcia/cistpl.h> 
     22#include <pcmcia/ds.h> 
    2723 
    2824 
     
    3127 
    3228 
     29/* Temporary list of yet-to-be-attached buses */ 
    3330static LIST_HEAD(attach_queue); 
     31/* List if running buses */ 
    3432static LIST_HEAD(buses); 
     33/* Software ID counter */ 
    3534static unsigned int next_busnumber; 
     35/* buses_mutes locks the two buslists and the next_busnumber. 
     36 * Don't lock this directly, but use ssb_buses_[un]lock() below. */ 
    3637static DEFINE_MUTEX(buses_mutex); 
     38 
     39/* There are differences in the codeflow, if the bus is 
     40 * initialized from early boot, as various needed services 
     41 * are not available early. This is a mechanism to delay 
     42 * these initializations to after early boot has finished. 
     43 * It's also used to avoid mutex locking, as that's not 
     44 * available and needed early. */ 
     45static bool ssb_is_early_boot = 1; 
    3746 
    3847static void ssb_buses_lock(void); 
     
    4150 
    4251#ifdef CONFIG_SSB_PCIHOST 
    43 struct ssb_bus * ssb_pci_dev_to_bus(struct pci_dev *pdev) 
     52struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev) 
    4453{ 
    4554        struct ssb_bus *bus; 
     
    5968#endif /* CONFIG_SSB_PCIHOST */ 
    6069 
    61 static struct ssb_device * ssb_device_get(struct ssb_device *dev) 
     70static struct ssb_device *ssb_device_get(struct ssb_device *dev) 
    6271{ 
    6372        if (dev) 
     
    123132        bus->pcicore.setup_done = 0; 
    124133#endif 
     134#ifdef CONFIG_SSB_DEBUG 
     135        bus->powered_up = 0; 
     136#endif 
    125137} 
    126138 
     
    160172        pm_message_t state = PMSG_FREEZE; 
    161173 
     174        /* First check that we are capable to freeze all devices. */ 
    162175        for (i = 0; i < bus->nr_devices; i++) { 
    163176                dev = &(bus->devices[i]); 
    164                 if (!dev->dev->driver) 
    165                         continue; 
    166                 if (!device_is_registered(dev->dev)) 
     177                if (!dev->dev || 
     178                    !dev->dev->driver || 
     179                    !device_is_registered(dev->dev)) 
    167180                        continue; 
    168181                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; 
     182                if (!drv) 
     183                        continue; 
     184                if (!drv->suspend) { 
     185                        /* Nope, can't suspend this one. */ 
     186                        return -EOPNOTSUPP; 
    173187                } 
    174188        } 
    175 out: 
     189        /* Now suspend all devices */ 
     190        for (i = 0; i < bus->nr_devices; i++) { 
     191                dev = &(bus->devices[i]); 
     192                if (!dev->dev || 
     193                    !dev->dev->driver || 
     194                    !device_is_registered(dev->dev)) 
     195                        continue; 
     196                drv = drv_to_ssb_drv(dev->dev->driver); 
     197                if (!drv) 
     198                        continue; 
     199                err = drv->suspend(dev, state); 
     200                if (err) { 
     201                        ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n", 
     202                                   dev->dev->bus_id); 
     203                        goto err_unwind; 
     204                } 
     205        } 
     206 
     207        return 0; 
     208err_unwind: 
     209        for (i--; i >= 0; i--) { 
     210                dev = &(bus->devices[i]); 
     211                if (!dev->dev || 
     212                    !dev->dev->driver || 
     213                    !device_is_registered(dev->dev)) 
     214                        continue; 
     215                drv = drv_to_ssb_drv(dev->dev->driver); 
     216                if (!drv) 
     217                        continue; 
     218                if (drv->resume) 
     219                        drv->resume(dev); 
     220        } 
    176221        return err; 
    177222} 
     
    181226        struct ssb_device *dev; 
    182227        struct ssb_driver *drv; 
    183         int err = 0; 
     228        int err; 
    184229        int i; 
    185230 
    186231        for (i = 0; i < bus->nr_devices; i++) { 
    187232                dev = &(bus->devices[i]); 
    188                 if (!dev->dev->driver) 
    189                         continue; 
    190                 if (!device_is_registered(dev->dev)) 
     233                if (!dev->dev || 
     234                    !dev->dev->driver || 
     235                    !device_is_registered(dev->dev)) 
    191236                        continue; 
    192237                drv = drv_to_ssb_drv(dev->dev->driver); 
    193                 if (drv && drv->resume) { 
    194                         err = drv->resume(dev); 
    195                         if (err) 
    196                                 goto out; 
     238                if (!drv) 
     239                        continue; 
     240                if (SSB_WARN_ON(!drv->resume)) 
     241                        continue; 
     242                err = drv->resume(dev); 
     243                if (err) { 
     244                        ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n", 
     245                                   dev->dev->bus_id); 
    197246                } 
    198247        } 
    199 out: 
    200         return err; 
     248 
     249        return 0; 
    201250} 
    202251#endif /* CONFIG_SSB_PCIHOST */ 
     
    272321} 
    273322 
     323static int ssb_device_uevent(struct device *dev, char **envp, int num_envp, 
     324                             char *buffer, int buffer_size) 
     325{ 
     326        struct ssb_device *ssb_dev = dev_to_ssb_dev(dev); 
     327        int ret, i = 0, length = 0; 
     328 
     329        if (!dev) 
     330                return -ENODEV; 
     331 
     332        ret = add_uevent_var(envp, num_envp, &i, 
     333                             buffer, buffer_size, &length, 
     334                             "MODALIAS=ssb:v%04Xid%04Xrev%02X", 
     335                             ssb_dev->id.vendor, ssb_dev->id.coreid, 
     336                             ssb_dev->id.revision); 
     337        envp[i] = NULL; 
     338 
     339        return ret; 
     340} 
     341 
    274342static struct bus_type ssb_bustype = { 
    275         .name           = NULL, /* Intentionally NULL to indicate early boot */ 
     343        .name           = "ssb", 
    276344        .match          = ssb_bus_match, 
    277345        .probe          = ssb_device_probe, 
     
    280348        .suspend        = ssb_device_suspend, 
    281349        .resume         = ssb_device_resume, 
     350        .uevent         = ssb_device_uevent, 
    282351}; 
    283352 
    284 #define is_early_boot()         (ssb_bustype.name == NULL) 
    285  
    286353static void ssb_buses_lock(void) 
    287354{ 
    288         if (!is_early_boot()) 
     355        /* See the comment at the ssb_is_early_boot definition */ 
     356        if (!ssb_is_early_boot) 
    289357                mutex_lock(&buses_mutex); 
    290358} 
     
    292360static void ssb_buses_unlock(void) 
    293361{ 
    294         if (!is_early_boot()) 
     362        /* See the comment at the ssb_is_early_boot definition */ 
     363        if (!ssb_is_early_boot) 
    295364                mutex_unlock(&buses_mutex); 
    296365} 
     
    422491                 * (no udelay() available). So do it here in attach stage. 
    423492                 */ 
     493                err = ssb_bus_powerup(bus, 0); 
     494                if (err) 
     495                        goto error; 
    424496                ssb_pcicore_init(&bus->pcicore); 
     497                ssb_bus_may_powerdown(bus); 
    425498 
    426499                err = ssb_devices_register(bus); 
     500error: 
    427501                if (err) { 
    428502                        drop_them_all = 1; 
     
    468542} 
    469543 
     544/* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */ 
    470545static const struct ssb_bus_ops ssb_ssb_ops = { 
    471546        .read16         = ssb_ssb_read16, 
     
    476551 
    477552static int ssb_fetch_invariants(struct ssb_bus *bus, 
    478                                 int (*get_invariants)(struct ssb_bus *bus, 
    479                                                       struct ssb_init_invariants *iv)) 
     553                                ssb_invariants_func_t get_invariants) 
    480554{ 
    481555        struct ssb_init_invariants iv; 
     
    493567 
    494568static int ssb_bus_register(struct ssb_bus *bus, 
    495                             int (*get_invariants)(struct ssb_bus *bus, 
    496                                                   struct ssb_init_invariants *iv), 
     569                            ssb_invariants_func_t get_invariants, 
    497570                            unsigned long baseaddr) 
    498571{ 
     
    523596 
    524597        /* Initialize basic system devices (if available) */ 
     598        err = ssb_bus_powerup(bus, 0); 
     599        if (err) 
     600                goto err_pcmcia_exit; 
    525601        ssb_chipcommon_init(&bus->chipco); 
    526602        ssb_mipscore_init(&bus->mipscore); 
    527603        err = ssb_fetch_invariants(bus, get_invariants); 
    528         if (err) 
     604        if (err) { 
     605                ssb_bus_may_powerdown(bus); 
    529606                goto err_pcmcia_exit; 
    530  
    531         /* Queue it for attach */ 
     607        } 
     608        ssb_bus_may_powerdown(bus); 
     609 
     610        /* Queue it for attach. 
     611         * See the comment at the ssb_is_early_boot definition. */ 
    532612        list_add_tail(&bus->list, &attach_queue); 
    533         if (!is_early_boot()) { 
     613        if (!ssb_is_early_boot) { 
    534614                /* This is not early boot, so we must attach the bus now */ 
    535615                err = ssb_attach_queued_buses(); 
     
    602682int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    603683                            unsigned long baseaddr, 
    604                             int (*get_invariants)(struct ssb_bus *bus, 
    605                                                   struct ssb_init_invariants *iv)) 
     684                            ssb_invariants_func_t get_invariants) 
    606685{ 
    607686        int err; 
     
    696775                n1 += SSB_CHIPCO_CLK_T2_BIAS; 
    697776                n2 += SSB_CHIPCO_CLK_T2_BIAS; 
    698                 assert((n1 >= 2) && (n1 <= 7)); 
    699                 assert((n2 >= 5) && (n2 <= 23)); 
     777                SSB_WARN_ON(!((n1 >= 2) && (n1 <= 7))); 
     778                SSB_WARN_ON(!((n2 >= 5) && (n2 <= 23))); 
    700779                break; 
    701780        case SSB_PLLTYPE_5: /* 25Mhz, 4 dividers */ 
    702781                return 100000000; 
    703782        default: 
    704                 assert(0); 
     783                SSB_WARN_ON(1); 
    705784        } 
    706785 
     
    751830                m2 += SSB_CHIPCO_CLK_T2M2_BIAS; 
    752831                m3 += SSB_CHIPCO_CLK_T2_BIAS; 
    753                 assert((m1 >= 2) && (m1 <= 7)); 
    754                 assert((m2 >= 3) && (m2 <= 10)); 
    755                 assert((m3 >= 2) && (m3 <= 7)); 
     832                SSB_WARN_ON(!((m1 >= 2) && (m1 <= 7))); 
     833                SSB_WARN_ON(!((m2 >= 3) && (m2 <= 10))); 
     834                SSB_WARN_ON(!((m3 >= 2) && (m3 <= 7))); 
    756835 
    757836                if (!(mc & SSB_CHIPCO_CLK_T2MC_M1BYP)) 
     
    763842                return clock; 
    764843        default: 
    765                 assert(0); 
     844                SSB_WARN_ON(1); 
    766845        } 
    767846        return 0; 
     
    775854        u32 clkctl_n, clkctl_m; 
    776855 
    777         //TODO if EXTIF: PLLTYPE == 1, read n from clockcontrol_n, m from clockcontrol_sb 
    778  
    779         if (bus->chipco.dev) { 
     856        if (ssb_extif_available(&bus->extif)) 
     857                ssb_extif_get_clockcontrol(&bus->extif, &plltype, 
     858                                           &clkctl_n, &clkctl_m); 
     859        else if (bus->chipco.dev) 
    780860                ssb_chipco_get_clockcontrol(&bus->chipco, &plltype, 
    781861                                            &clkctl_n, &clkctl_m); 
    782         } else 
     862        else 
    783863                return 0; 
    784864 
     
    805885                return SSB_TMSLOW_REJECT_23; 
    806886        default: 
    807                 assert(0); 
     887                WARN_ON(1); 
    808888        } 
    809889        return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     
    822902} 
    823903EXPORT_SYMBOL(ssb_device_is_enabled); 
     904 
     905static void ssb_flush_tmslow(struct ssb_device *dev) 
     906{ 
     907        /* Make _really_ sure the device has finished the TMSLOW 
     908         * register write transaction, as we risk running into 
     909         * a machine check exception otherwise. 
     910         * Do this by reading the register back to commit the 
     911         * PCI write and delay an additional usec for the device 
     912         * to react to the change. */ 
     913        ssb_read32(dev, SSB_TMSLOW); 
     914        udelay(1); 
     915} 
    824916 
    825917void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags) 
     
    831923                    SSB_TMSLOW_RESET | SSB_TMSLOW_CLOCK | 
    832924                    SSB_TMSLOW_FGC | core_specific_flags); 
    833         /* flush */ 
    834         ssb_read32(dev, SSB_TMSLOW); 
    835         udelay(1); 
     925        ssb_flush_tmslow(dev); 
    836926 
    837927        /* Clear SERR if set. This is a hw bug workaround. */ 
     
    848938                    SSB_TMSLOW_CLOCK | SSB_TMSLOW_FGC | 
    849939                    core_specific_flags); 
    850         /* flush */ 
    851         ssb_read32(dev, SSB_TMSLOW); 
    852         udelay(1); 
     940        ssb_flush_tmslow(dev); 
    853941 
    854942        ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_CLOCK | 
    855943                    core_specific_flags); 
    856         /* flush */ 
    857         ssb_read32(dev, SSB_TMSLOW); 
    858         udelay(1); 
     944        ssb_flush_tmslow(dev); 
    859945} 
    860946EXPORT_SYMBOL(ssb_device_enable); 
    861947 
     948/* Wait for a bit in a register to get set or unset. 
     949 * timeout is in units of ten-microseconds */ 
    862950static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
    863951                        int timeout, int set) 
     
    899987                    reject | SSB_TMSLOW_RESET | 
    900988                    core_specific_flags); 
    901         /* flush */ 
    902         ssb_read32(dev, SSB_TMSLOW); 
    903         udelay(1); 
     989        ssb_flush_tmslow(dev); 
    904990 
    905991        ssb_write32(dev, SSB_TMSLOW, 
    906992                    reject | SSB_TMSLOW_RESET | 
    907993                    core_specific_flags); 
    908         /* flush */ 
    909         ssb_read32(dev, SSB_TMSLOW); 
    910         udelay(1); 
     994        ssb_flush_tmslow(dev); 
    911995} 
    912996EXPORT_SYMBOL(ssb_device_disable); 
     
    914998u32 ssb_dma_translation(struct ssb_device *dev) 
    915999{ 
    916         switch(dev->bus->bustype) { 
     1000        switch (dev->bus->bustype) { 
    9171001        case SSB_BUSTYPE_SSB: 
    9181002                return 0; 
     
    9441028{ 
    9451029        struct ssb_chipcommon *cc; 
    946         int err; 
     1030        int err = 0; 
    9471031 
    9481032        /* On buses where more than one core may be working 
     
    9501034         * still cores that may want to run. */ 
    9511035        if (bus->bustype == SSB_BUSTYPE_SSB) 
    952                 return 0; 
     1036                goto out; 
    9531037 
    9541038        cc = &bus->chipco; 
     
    9571041        if (err) 
    9581042                goto error; 
    959  
    960         return 0; 
     1043out: 
     1044#ifdef CONFIG_SSB_DEBUG 
     1045        bus->powered_up = 0; 
     1046#endif 
     1047        return err; 
    9611048error: 
    9621049        ssb_printk(KERN_ERR PFX "Bus powerdown failed\n"); 
    963         return err; 
     1050        goto out; 
    9641051} 
    9651052EXPORT_SYMBOL(ssb_bus_may_powerdown); 
    9661053 
    967 int ssb_bus_powerup(struct ssb_bus *bus, int dynamic_pctl) 
     1054int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
    9681055{ 
    9691056        struct ssb_chipcommon *cc; 
     
    9781065        ssb_chipco_set_clockmode(cc, mode); 
    9791066 
     1067#ifdef CONFIG_SSB_DEBUG 
     1068        bus->powered_up = 1; 
     1069#endif 
    9801070        return 0; 
    9811071error: 
     
    9941084                break; 
    9951085        case SSB_ADM_TYPE1: 
    996                 assert(!(adm & SSB_ADM_NEG)); /* unsupported */ 
     1086                SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */ 
    9971087                base = (adm & SSB_ADM_BASE1); 
    9981088                break; 
    9991089        case SSB_ADM_TYPE2: 
    1000                 assert(!(adm & SSB_ADM_NEG)); /* unsupported */ 
     1090                SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */ 
    10011091                base = (adm & SSB_ADM_BASE2); 
    10021092                break; 
    10031093        default: 
    1004                 assert(0); 
     1094                SSB_WARN_ON(1); 
    10051095        } 
    10061096 
     
    10181108                break; 
    10191109        case SSB_ADM_TYPE1: 
    1020                 assert(!(adm & SSB_ADM_NEG)); /* unsupported */ 
     1110                SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */ 
    10211111                size = ((adm & SSB_ADM_SZ1) >> SSB_ADM_SZ1_SHIFT); 
    10221112                break; 
    10231113        case SSB_ADM_TYPE2: 
    1024                 assert(!(adm & SSB_ADM_NEG)); /* unsupported */ 
     1114                SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */ 
    10251115                size = ((adm & SSB_ADM_SZ2) >> SSB_ADM_SZ2_SHIFT); 
    10261116                break; 
    10271117        default: 
    1028                 assert(0); 
     1118                SSB_WARN_ON(1); 
    10291119        } 
    10301120        size = (1 << (size + 1)); 
     
    10381128        int err; 
    10391129 
    1040         ssb_bustype.name = "ssb"; 
     1130        /* See the comment at the ssb_is_early_boot definition */ 
     1131        ssb_is_early_boot = 0; 
    10411132        err = bus_register(&ssb_bustype); 
    10421133        if (err) 
     
    10521143                bus_unregister(&ssb_bustype); 
    10531144 
     1145        err = b43_pci_ssb_bridge_init(); 
     1146        if (err) { 
     1147                ssb_printk(KERN_ERR "Broadcom 43xx PCI-SSB-bridge " 
     1148                           "initialization failed"); 
     1149                /* don't fail SSB init because of this */ 
     1150                err = 0; 
     1151        } 
     1152 
    10541153        return err; 
    10551154} 
     
    10581157static void __exit ssb_modexit(void) 
    10591158{ 
     1159        b43_pci_ssb_bridge_exit(); 
    10601160        bus_unregister(&ssb_bustype); 
    10611161} 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/pci.c

    r7732 r9302  
    2424 
    2525 
     26/* Define the following to 1 to enable a printk on each coreswitch. */ 
     27#define SSB_VERBOSE_PCICORESWITCH_DEBUG         0 
     28 
     29 
     30/* Lowlevel coreswitching */ 
    2631int ssb_pci_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 
    2732{ 
     
    6166        unsigned long flags; 
    6267 
    63         ssb_dprintk(KERN_INFO PFX 
    64                     "Switching to %s core, index %d\n", 
    65                     ssb_core_name(dev->id.coreid), 
    66                     dev->core_index); 
     68#if SSB_VERBOSE_PCICORESWITCH_DEBUG 
     69        ssb_printk(KERN_INFO PFX 
     70                   "Switching to %s core, index %d\n", 
     71                   ssb_core_name(dev->id.coreid), 
     72                   dev->core_index); 
     73#endif 
    6774 
    6875        spin_lock_irqsave(&bus->bar_lock, flags); 
     
    7582} 
    7683 
     84/* Enable/disable the on board crystal oscillator and/or PLL. */ 
    7785int ssb_pci_xtal(struct ssb_bus *bus, u32 what, int turn_on) 
    7886{ 
     
    159167} 
    160168 
     169/* Get the word-offset for a SSB_SPROM_XXX define. */ 
    161170#define SPOFF(offset)   (((offset) - SSB_SPROM_BASE) / sizeof(u16)) 
     171/* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */ 
    162172#define SPEX(_outvar, _offset, _mask, _shift)   \ 
    163173        out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift)) 
     
    297307        for (i = 0; i < 3; i++) { 
    298308                v = in[SPOFF(SSB_SPROM1_IL0MAC) + i]; 
    299                 *(((u16 *)out->il0mac) + i) = cpu_to_be16(v); 
     309                *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v); 
    300310        } 
    301311        for (i = 0; i < 3; i++) { 
    302312                v = in[SPOFF(SSB_SPROM1_ET0MAC) + i]; 
    303                 *(((u16 *)out->et0mac) + i) = cpu_to_be16(v); 
     313                *(((__be16 *)out->et0mac) + i) = cpu_to_be16(v); 
    304314        } 
    305315        for (i = 0; i < 3; i++) { 
    306316                v = in[SPOFF(SSB_SPROM1_ET1MAC) + i]; 
    307                 *(((u16 *)out->et1mac) + i) = cpu_to_be16(v); 
     317                *(((__be16 *)out->et1mac) + i) = cpu_to_be16(v); 
    308318        } 
    309319        SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0); 
     
    343353        for (i = 0; i < 4; i++) { 
    344354                v = in[SPOFF(SSB_SPROM1_OEM) + i]; 
    345                 *(((u16 *)out->oem) + i) = cpu_to_le16(v); 
     355                *(((__le16 *)out->oem) + i) = cpu_to_le16(v); 
    346356        } 
    347357} 
     
    365375        for (i = 0; i < 4; i++) { 
    366376                v = in[SPOFF(SSB_SPROM2_CCODE) + i]; 
    367                 *(((u16 *)out->country_str) + i) = cpu_to_le16(v); 
     377                *(((__le16 *)out->country_str) + i) = cpu_to_le16(v); 
    368378        } 
    369379} 
     
    490500} 
    491501 
     502#ifdef CONFIG_SSB_DEBUG 
     503static int ssb_pci_assert_buspower(struct ssb_bus *bus) 
     504{ 
     505        if (likely(bus->powered_up)) 
     506                return 0; 
     507 
     508        printk(KERN_ERR PFX "FATAL ERROR: Bus powered down " 
     509               "while accessing PCI MMIO space\n"); 
     510        if (bus->power_warn_count <= 10) { 
     511                bus->power_warn_count++; 
     512                dump_stack(); 
     513        } 
     514 
     515        return -ENODEV; 
     516} 
     517#else /* DEBUG */ 
     518static inline int ssb_pci_assert_buspower(struct ssb_bus *bus) 
     519{ 
     520        return 0; 
     521} 
     522#endif /* DEBUG */ 
     523 
    492524static u16 ssb_pci_read16(struct ssb_device *dev, u16 offset) 
    493525{ 
    494526        struct ssb_bus *bus = dev->bus; 
    495527 
     528        if (unlikely(ssb_pci_assert_buspower(bus))) 
     529                return 0xFFFF; 
    496530        if (unlikely(bus->mapped_device != dev)) { 
    497531                if (unlikely(ssb_pci_switch_core(bus, dev))) 
    498532                        return 0xFFFF; 
    499533        } 
    500         return readw(bus->mmio + offset); 
     534        return ioread16(bus->mmio + offset); 
    501535} 
    502536 
     
    505539        struct ssb_bus *bus = dev->bus; 
    506540 
     541        if (unlikely(ssb_pci_assert_buspower(bus))) 
     542                return 0xFFFFFFFF; 
    507543        if (unlikely(bus->mapped_device != dev)) { 
    508544                if (unlikely(ssb_pci_switch_core(bus, dev))) 
    509545                        return 0xFFFFFFFF; 
    510546        } 
    511         return readl(bus->mmio + offset); 
     547        return ioread32(bus->mmio + offset); 
    512548} 
    513549 
     
    516552        struct ssb_bus *bus = dev->bus; 
    517553 
     554        if (unlikely(ssb_pci_assert_buspower(bus))) 
     555                return; 
    518556        if (unlikely(bus->mapped_device != dev)) { 
    519557                if (unlikely(ssb_pci_switch_core(bus, dev))) 
    520558                        return; 
    521559        } 
    522         writew(value, bus->mmio + offset); 
     560        iowrite16(value, bus->mmio + offset); 
    523561} 
    524562 
     
    527565        struct ssb_bus *bus = dev->bus; 
    528566 
     567        if (unlikely(ssb_pci_assert_buspower(bus))) 
     568                return; 
    529569        if (unlikely(bus->mapped_device != dev)) { 
    530570                if (unlikely(ssb_pci_switch_core(bus, dev))) 
    531571                        return; 
    532572        } 
    533         writel(value, bus->mmio + offset); 
    534 } 
    535  
     573        iowrite32(value, bus->mmio + offset); 
     574} 
     575 
     576/* Not "static", as it's used in main.c */ 
    536577const struct ssb_bus_ops ssb_pci_ops = { 
    537578        .read16         = ssb_pci_read16, 
     
    591632                goto out; 
    592633 
     634        /* Use interruptible locking, as the SPROM write might 
     635         * be holding the lock for several seconds. So allow userspace 
     636         * to cancel operation. */ 
    593637        err = -ERESTARTSYS; 
    594638        if (mutex_lock_interruptible(&bus->pci_sprom_mutex)) 
     
    633677        } 
    634678 
     679        /* Use interruptible locking, as the SPROM write might 
     680         * be holding the lock for several seconds. So allow userspace 
     681         * to cancel operation. */ 
    635682        err = -ERESTARTSYS; 
    636683        if (mutex_lock_interruptible(&bus->pci_sprom_mutex)) 
    637684                goto out_kfree; 
    638685        err = ssb_devices_freeze(bus); 
     686        if (err == -EOPNOTSUPP) { 
     687                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
     688                           "No suspend support. Is CONFIG_PM enabled?\n"); 
     689                goto out_unlock; 
     690        } 
    639691        if (err) { 
    640692                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/pcmcia.c

    r7732 r9302  
    2222 
    2323 
     24/* Define the following to 1 to enable a printk on each coreswitch. */ 
     25#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG              0 
     26 
     27 
    2428int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus, 
    2529                              u8 coreidx) 
     
    9296        unsigned long flags; 
    9397 
    94         ssb_dprintk(KERN_INFO PFX 
    95                     "Switching to %s core, index %d\n", 
    96                     ssb_core_name(dev->id.coreid), 
    97                     dev->core_index); 
     98#if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 
     99        ssb_printk(KERN_INFO PFX 
     100                   "Switching to %s core, index %d\n", 
     101                   ssb_core_name(dev->id.coreid), 
     102                   dev->core_index); 
     103#endif 
    98104 
    99105        spin_lock_irqsave(&bus->bar_lock, flags); 
     
    113119        int res, err = 0; 
    114120 
    115         assert(seg == 0 || seg == 1); 
     121        SSB_WARN_ON((seg != 0) && (seg != 1)); 
    116122        reg.Offset = 0x34; 
    117123        reg.Function = 0; 
     
    146152} 
    147153 
     154/* These are the main device register access functions. 
     155 * do_select_core is inline to have the likely hotpath inline. 
     156 * All unlikely codepaths are out-of-line. */ 
    148157static inline int do_select_core(struct ssb_bus *bus, 
    149158                                 struct ssb_device *dev, 
     
    177186                return 0xFFFF; 
    178187        x = readw(bus->mmio + offset); 
    179 //printk("R16 0x%04X, 0x%04X\n", offset, x); 
     188 
    180189        return x; 
    181190} 
     
    189198                return 0xFFFFFFFF; 
    190199        x = readl(bus->mmio + offset); 
    191 //printk("R32 0x%04X, 0x%08X\n", offset, x); 
     200 
    192201        return x; 
    193202} 
     
    199208        if (unlikely(do_select_core(bus, dev, &offset))) 
    200209                return; 
    201 //printk("W16 0x%04X, 0x%04X\n", offset, value); 
    202210        writew(value, bus->mmio + offset); 
    203211} 
     
    209217        if (unlikely(do_select_core(bus, dev, &offset))) 
    210218                return; 
    211 //printk("W32 0x%04X, 0x%08X\n", offset, value); 
    212219        readw(bus->mmio + offset); 
    213220        writew(value >> 16, bus->mmio + offset + 2); 
     
    216223} 
    217224 
     225/* Not "static", as it's used in main.c */ 
    218226const struct ssb_bus_ops ssb_pcmcia_ops = { 
    219227        .read16         = ssb_pcmcia_read16, 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/scan.c

    r7732 r9302  
    1616#include <linux/ssb/ssb_regs.h> 
    1717#include <linux/pci.h> 
    18 #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 
     18#include <linux/io.h> 
     19 
     20#include <pcmcia/cs_types.h> 
     21#include <pcmcia/cs.h> 
     22#include <pcmcia/cistpl.h> 
     23#include <pcmcia/ds.h> 
    2624 
    2725#include "ssb_private.h" 
    2826 
    2927 
    30 const char * ssb_core_name(u16 coreid) 
     28const char *ssb_core_name(u16 coreid) 
    3129{ 
    3230        switch (coreid) { 
     
    206204                pci_iounmap(bus->host_pci, bus->mmio); 
    207205#else 
    208                 assert(0); /* Can't reach this code. */ 
     206                SSB_BUG_ON(1); /* Can't reach this code. */ 
    209207#endif 
    210208                break; 
     
    214212} 
    215213 
    216 static void __iomem * ssb_ioremap(struct ssb_bus *bus, 
    217                                   unsigned long baseaddr) 
     214static void __iomem *ssb_ioremap(struct ssb_bus *bus, 
     215                                 unsigned long baseaddr) 
    218216{ 
    219217        void __iomem *mmio = NULL; 
     
    230228                mmio = pci_iomap(bus->host_pci, 0, ~0UL); 
    231229#else 
    232                 assert(0); /* Can't reach this code. */ 
     230                SSB_BUG_ON(1); /* Can't reach this code. */ 
    233231#endif 
    234232                break; 
  • trunk/target/linux/generic-2.6/files/drivers/ssb/ssb_private.h

    r7732 r9302  
    44#include <linux/ssb/ssb.h> 
    55#include <linux/types.h> 
    6 #include <asm/io.h> 
    76 
    87 
     
    1716/* dprintk: Debugging printk; vanishes for non-debug compilation */ 
    1817#ifdef CONFIG_SSB_DEBUG 
    19 # define ssb_dprintk(fmt, x...) ssb_printk(fmt ,##x) 
     18# define ssb_dprintk(fmt, x...) ssb_printk(fmt , ##x) 
    2019#else 
    2120# define ssb_dprintk(fmt, x...) do { /* nothing */ } while (0) 
    2221#endif 
    2322 
    24 /* printkl: Rate limited printk */ 
    25 #define ssb_printkl(fmt, x...)  do {            \ 
    26         if (printk_ratelimit())                 \ 
    27                 ssb_printk(fmt ,##x);           \ 
    28                                 } while (0) 
    29  
    30 /* dprintkl: Rate limited debugging printk */ 
    3123#ifdef CONFIG_SSB_DEBUG 
    32 # define ssb_dprintkl                   ssb_printkl 
     24# define SSB_WARN_ON(x)         WARN_ON(x) 
     25# define SSB_BUG_ON(x)          BUG_ON(x) 
    3326#else 
    34 # define ssb_dprintkl(fmt, x...)        do { /* nothing */ } while (0) 
     27static inline int __ssb_do_nothing(int x) { return x; } 
     28# define SSB_WARN_ON(x)         __ssb_do_nothing(unlikely(!!(x))) 
     29# define SSB_BUG_ON(x)          __ssb_do_nothing(unlikely(!!(x))) 
    3530#endif 
    36  
    37 #define assert(cond)    do {                                            \ 
    38         if (unlikely(!(cond))) {                                        \ 
    39                 ssb_dprintk(KERN_ERR PFX "BUG: Assertion failed (%s) "  \ 
    40                             "at: %s:%d:%s()\n",                         \ 
    41                             #cond, __FILE__, __LINE__, __func__);       \ 
    42         }                                                               \ 
    43                        } while (0) 
    4431 
    4532 
     
    121108 
    122109/* scan.c */ 
    123 extern const char * ssb_core_name(u16 coreid); 
     110extern const char *ssb_core_name(u16 coreid); 
    124111extern int ssb_bus_scan(struct ssb_bus *bus, 
    125112                        unsigned long baseaddr); 
     
    129116/* core.c */ 
    130117extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
    131 #ifdef CONFIG_SSB_PCIHOST 
    132118extern int ssb_devices_freeze(struct ssb_bus *bus); 
    133119extern int ssb_devices_thaw(struct ssb_bus *bus); 
    134 extern struct ssb_bus * ssb_pci_dev_to_bus(struct pci_dev *pdev); 
     120extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
     121 
     122/* b43_pci_bridge.c */ 
     123#ifdef CONFIG_SSB_PCIHOST 
     124extern int __init b43_pci_ssb_bridge_init(void); 
     125extern void __exit b43_pci_ssb_bridge_exit(void); 
     126#else /* CONFIG_SSB_PCIHOST */ 
     127static inline int b43_pci_ssb_bridge_init(void) 
     128{ 
     129        return 0; 
     130} 
     131static inline void b43_pci_ssb_bridge_exit(void) 
     132{ 
     133} 
    135134#endif /* CONFIG_SSB_PCIHOST */ 
    136135 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb.h

    r7732 r9302  
    11#ifndef LINUX_SSB_H_ 
    22#define LINUX_SSB_H_ 
    3 #ifdef __KERNEL__ 
    43 
    54#include <linux/device.h> 
     
    76#include <linux/types.h> 
    87#include <linux/spinlock.h> 
    9 #ifdef CONFIG_SSB_PCIHOST 
    10 # include <linux/pci.h> 
    11 #endif 
     8#include <linux/pci.h> 
     9#include <linux/mod_devicetable.h> 
    1210 
    1311#include <linux/ssb/ssb_regs.h> 
     
    157155#define SSB_VENDOR_BROADCOM     0x4243 
    158156 
    159 struct ssb_device_id { 
    160         u16 vendor; 
    161         u16 coreid; 
    162         u8 revision; 
    163 }; 
    164 #define SSB_DEVICE(_vendor, _coreid, _revision)  \ 
    165         { .vendor = _vendor, .coreid = _coreid, .revision = _revision, } 
    166 #define SSB_DEVTABLE_END  \ 
    167         { 0, }, 
    168  
    169 #define SSB_ANY_VENDOR          0xFFFF 
    170 #define SSB_ANY_ID              0xFFFF 
    171 #define SSB_ANY_REV             0xFF 
    172  
    173157/* Some kernel subsystems poke with dev->drvdata, so we must use the 
    174158 * following ugly workaround to get from struct device to struct ssb_device */ 
     
    199183struct ssb_device * dev_to_ssb_dev(struct device *dev) 
    200184{ 
    201         struct __ssb_dev_wrapper *wrap = container_of(dev, struct __ssb_dev_wrapper, dev); 
     185        struct __ssb_dev_wrapper *wrap; 
     186        wrap = container_of(dev, struct __ssb_dev_wrapper, dev); 
    202187        return wrap->sdev; 
    203188} 
     
    297282 
    298283#ifdef CONFIG_SSB_PCIHOST 
     284        /* Mutex to protect the SPROM writing. */ 
    299285        struct mutex pci_sprom_mutex; 
    300286#endif 
     
    334320        struct ssb_sprom sprom; 
    335321 
    336         /* Internal. */ 
     322        /* Internal-only stuff follows. Do not touch. */ 
    337323        struct list_head list; 
     324#ifdef CONFIG_SSB_DEBUG 
     325        /* Is the bus already powered up? */ 
     326        bool powered_up; 
     327        int power_warn_count; 
     328#endif /* DEBUG */ 
    338329}; 
    339330 
     
    343334        struct ssb_sprom sprom; 
    344335}; 
     336/* Type of function to fetch the invariants. */ 
     337typedef int (*ssb_invariants_func_t)(struct ssb_bus *bus, 
     338                                     struct ssb_init_invariants *iv); 
    345339 
    346340/* Register a SSB system bus. get_invariants() is called after the 
     
    350344extern int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    351345                                   unsigned long baseaddr, 
    352                                    int (*get_invariants)(struct ssb_bus *bus, 
    353                                                          struct ssb_init_invariants *iv)); 
     346                                   ssb_invariants_func_t get_invariants); 
    354347#ifdef CONFIG_SSB_PCIHOST 
    355348extern int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     
    366359extern u32 ssb_clockspeed(struct ssb_bus *bus); 
    367360 
     361/* Is the device enabled in hardware? */ 
    368362int ssb_device_is_enabled(struct ssb_device *dev); 
     363/* Enable a device and pass device-specific SSB_TMSLOW flags. 
     364 * If no device-specific flags are available, use 0. */ 
    369365void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags); 
     366/* Disable a device in hardware and pass SSB_TMSLOW flags (if any). */ 
    370367void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags); 
    371368 
     
    409406 
    410407 
    411 /* Bus-Power handling functions. */ 
     408/* If a driver is shutdown or suspended, call this to signal 
     409 * that the bus may be completely powered down. SSB will decide, 
     410 * if it's really time to power down the bus, based on if there 
     411 * are other devices that want to run. */ 
    412412extern int ssb_bus_may_powerdown(struct ssb_bus *bus); 
    413 extern int ssb_bus_powerup(struct ssb_bus *bus, int dynamic_pctl); 
     413/* Before initializing and enabling a device, call this to power-up the bus. 
     414 * If you want to allow use of dynamic-power-control, pass the flag. 
     415 * Otherwise static always-on powercontrol will be used. */ 
     416extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
    414417 
    415418 
     
    419422 
    420423 
    421 #endif /* __KERNEL__ */ 
    422424#endif /* LINUX_SSB_H_ */ 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_chipcommon.h

    r7691 r9302  
    1313 * Licensed under the GPL version 2. See COPYING for details. 
    1414 */ 
    15 #ifdef __KERNEL__ 
    1615 
    1716/** ChipCommon core registers. **/ 
     
    365364extern void ssb_chipco_resume(struct ssb_chipcommon *cc); 
    366365 
     366extern void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc, 
     367                                    u32 *plltype, u32 *n, u32 *m); 
    367368extern void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc, 
    368369                                        u32 *plltype, u32 *n, u32 *m); 
     
    379380                                     enum ssb_clkmode mode); 
    380381 
     382extern void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, 
     383                                          u32 ticks); 
     384 
     385u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask); 
     386 
     387void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value); 
     388 
     389void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value); 
     390 
    381391#ifdef CONFIG_SSB_SERIAL 
    382392extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc, 
     
    384394#endif /* CONFIG_SSB_SERIAL */ 
    385395 
    386 #endif /* __KERNEL__ */ 
    387396#endif /* LINUX_SSB_CHIPCO_H_ */ 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_extif.h

    r7691 r9302  
    2020#ifndef LINUX_SSB_EXTIFCORE_H_ 
    2121#define LINUX_SSB_EXTIFCORE_H_ 
    22  
    23 #ifdef __KERNEL__ 
    24  
    25 struct ssb_extif { 
    26         struct ssb_device *dev; 
    27 }; 
    2822 
    2923/* external interface address space */ 
     
    160154 
    161155 
    162 #endif /* __KERNEL__ */ 
     156 
     157#ifdef CONFIG_SSB_DRIVER_EXTIF 
     158 
     159struct ssb_extif { 
     160        struct ssb_device *dev; 
     161}; 
     162 
     163static inline bool ssb_extif_available(struct ssb_extif *extif) 
     164{ 
     165        return (extif->dev != NULL); 
     166} 
     167 
     168extern void ssb_extif_get_clockcontrol(struct ssb_extif *extif, 
     169                                       u32 *plltype, u32 *n, u32 *m); 
     170 
     171extern void ssb_extif_timing_init(struct ssb_extif *extif, 
     172                                  unsigned long ns); 
     173 
     174u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask); 
     175 
     176void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value); 
     177 
     178void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value); 
     179 
     180#ifdef CONFIG_SSB_SERIAL 
     181extern int ssb_extif_serial_init(struct ssb_extif *extif, 
     182                                 struct ssb_serial_port *ports); 
     183#endif /* CONFIG_SSB_SERIAL */ 
     184 
     185 
     186#else /* CONFIG_SSB_DRIVER_EXTIF */ 
     187/* extif disabled */ 
     188 
     189struct ssb_extif { 
     190}; 
     191 
     192static inline bool ssb_extif_available(struct ssb_extif *extif) 
     193{ 
     194        return 0; 
     195} 
     196 
     197static inline 
     198void ssb_extif_get_clockcontrol(struct ssb_extif *extif, 
     199                                u32 *plltype, u32 *n, u32 *m) 
     200{ 
     201} 
     202 
     203#endif /* CONFIG_SSB_DRIVER_EXTIF */ 
    163204#endif /* LINUX_SSB_EXTIFCORE_H_ */ 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_mips.h

    r7691 r9302  
    11#ifndef LINUX_SSB_MIPSCORE_H_ 
    22#define LINUX_SSB_MIPSCORE_H_ 
    3  
    4 #ifdef __KERNEL__ 
    53 
    64#ifdef CONFIG_SSB_DRIVER_MIPS 
     
    2321        struct ssb_serial_port serial_ports[4]; 
    2422 
     23        u8 flash_buswidth; 
    2524        u32 flash_window; 
    2625        u32 flash_window_size; 
     
    2827 
    2928extern void ssb_mipscore_init(struct ssb_mipscore *mcore); 
     29extern u32 ssb_cpu_clock(struct ssb_mipscore *mcore); 
    3030 
    3131extern unsigned int ssb_mips_irq(struct ssb_device *dev); 
     
    4444#endif /* CONFIG_SSB_DRIVER_MIPS */ 
    4545 
    46 #endif /* __KERNEL__ */ 
    4746#endif /* LINUX_SSB_MIPSCORE_H_ */ 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_pci.h

    r6502 r9302  
    11#ifndef LINUX_SSB_PCICORE_H_ 
    22#define LINUX_SSB_PCICORE_H_ 
    3 #ifdef __KERNEL__ 
    43 
    54#ifdef CONFIG_SSB_DRIVER_PCICORE 
     
    105104 
    106105#endif /* CONFIG_SSB_DRIVER_PCICORE */ 
    107 #endif /* __KERNEL__ */ 
    108106#endif /* LINUX_SSB_PCICORE_H_ */ 
  • trunk/target/linux/generic-2.6/files/include/linux/ssb/ssb_regs.h

    r7732 r9302  
    11#ifndef LINUX_SSB_REGS_H_ 
    22#define LINUX_SSB_REGS_H_ 
    3 #ifdef __KERNEL__ 
    43 
    54 
     
    76 * All regions may not exist on all chips. 
    87 */ 
    9 #define SSB_SDRAM_BASE          0x00000000      /* Physical SDRAM */ 
    10 #define SSB_PCI_MEM             0x08000000      /* Host Mode sb2pcitranslation0 (64 MB) */ 
    11 #define SSB_PCI_CFG             0x0c000000      /* Host Mode sb2pcitranslation1 (64 MB) */ 
    12 #define SSB_SDRAM_SWAPPED       0x10000000      /* Byteswapped Physical SDRAM */ 
    13 #define SSB_ENUM_BASE           0x18000000      /* Enumeration space base */ 
    14 #define SSB_ENUM_LIMIT          0x18010000      /* Enumeration space limit */ 
    15  
    16 #define SSB_FLASH2              0x1c000000      /* Flash Region 2 (region 1 shadowed here) */ 
    17 #define SSB_FLASH2_SZ           0x02000000      /* Size of Flash Region 2 */ 
    18  
    19 #define SSB_EXTIF_BASE          0x1f000000      /* External Interface region base address */ 
    20 #define SSB_FLASH1              0x1fc00000      /* Flash Region 1 */ 
    21 #define SSB_FLASH1_SZ           0x00400000      /* Size of Flash Region 1 */ 
    22  
    23 #define SSB_PCI_DMA             0x40000000      /* Client Mode sb2pcitranslation2 (1 GB) */ 
    24 #define SSB_PCI_DMA_SZ          0x40000000      /* Client Mode sb2pcitranslation2 size in bytes */ 
    25 #define SSB_PCIE_DMA_L32                0x00000000      /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), low 32 bits */ 
    26 #define SSB_PCIE_DMA_H32                0x80000000      /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), high 32 bits */ 
    27 #define SSB_EUART               (SB_EXTIF_BASE + 0x00800000) 
    28 #define SSB_LED                 (SB_EXTIF_BASE + 0x00900000) 
     8#define SSB_SDRAM_BASE          0x00000000U     /* Physical SDRAM */ 
     9#define SSB_PCI_MEM             0x08000000U     /* Host Mode sb2pcitranslation0 (64 MB) */ 
     10#define SSB_PCI_CFG             0x0c000000U     /* Host Mode sb2pcitranslation1 (64 MB) */ 
     11#define SSB_SDRAM_SWAPPED       0x10000000U     /* Byteswapped Physical SDRAM */ 
     12#define SSB_ENUM_BASE           0x18000000U     /* Enumeration space base */ 
     13#define SSB_ENUM_LIMIT          0x18010000U     /* Enumeration space limit */ 
     14 
     15#define SSB_FLASH2              0x1c000000U     /* Flash Region 2 (region 1 shadowed here) */ 
     16#define SSB_FLASH2_SZ           0x02000000U     /* Size of Flash Region 2 */ 
     17 
     18#define SSB_EXTIF_BASE          0x1f000000U     /* External Interface region base address */ 
     19#define SSB_FLASH1              0x1fc00000U     /* Flash Region 1 */ 
     20#define SSB_FLASH1_SZ           0x00400000U     /* Size of Flash Region 1 */ 
     21 
     22#define SSB_PCI_DMA             0x40000000U     /* Client Mode sb2pcitranslation2 (1 GB) */ 
     23#define SSB_PCI_DMA_SZ          0x40000000U     /* Client Mode sb2pcitranslation2 size in bytes */ 
     24#define SSB_PCIE_DMA_L32        0x00000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), low 32 bits */ 
     25#define SSB_PCIE_DMA_H32        0x80000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), high 32 bits */ 
     26#define SSB_EUART               (SSB_EXTIF_BASE + 0x00800000) 
     27#define SSB_LED                 (SSB_EXTIF_BASE + 0x00900000) 
    2928 
    3029 
     
    269268}; 
    270269 
    271 /* Address-Match values and masks (SSB_ADMATCH?) */ 
     270/* Address-Match values and masks (SSB_ADMATCHxxx) */ 
    272271#define SSB_ADM_TYPE                    0x00000003      /* Address type */ 
    273272#define  SSB_ADM_TYPE0                  0 
     
    291290 
    292291 
    293 #endif /* __KERNEL__ */ 
    294292#endif /* LINUX_SSB_REGS_H_ */ 
Note: See TracChangeset for help on using the changeset viewer.