projects / openwrt / staging / dedeckeh.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
get rid of $Id$ - it has never helped us and it has broken too many patches ;)
[openwrt/staging/dedeckeh.git] / target / linux / brcm-2.4 / files / arch / mips / bcm947xx / sbutils.c
1 /*
2 * Misc utility routines for accessing chip-specific features
3 * of the SiliconBackplane-based Broadcom chips.
4 *
5 * Copyright 2007, Broadcom Corporation
6 * All Rights Reserved.
7 *
8 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
9 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
10 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
11 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
12 */
13
14 #include <typedefs.h>
15 #include <bcmdefs.h>
16 #include <osl.h>
17 #include <sbutils.h>
18 #include <bcmdevs.h>
19 #include <sbconfig.h>
20 #include <sbchipc.h>
21 #include <sbextif.h>
22 #include <sbpci.h>
23 #include <sbpcie.h>
24 #include <pcicfg.h>
25 #include <sbpcmcia.h>
26 #include <sbsocram.h>
27 #include <bcmnvram.h>
28 #include <bcmsrom.h>
29 #include <hndpmu.h>
30
31 /* debug/trace */
32 #define SB_ERROR(args)
33
34 #ifdef BCMDBG
35 #define SB_MSG(args) printf args
36 #else
37 #define SB_MSG(args)
38 #endif /* BCMDBG */
39
40 typedef uint32(*sb_intrsoff_t) (void *intr_arg);
41 typedef void (*sb_intrsrestore_t) (void *intr_arg, uint32 arg);
42 typedef bool(*sb_intrsenabled_t) (void *intr_arg);
43
44 typedef struct gpioh_item {
45 void *arg;
46 bool level;
47 gpio_handler_t handler;
48 uint32 event;
49 struct gpioh_item *next;
50 } gpioh_item_t;
51
52 /* misc sb info needed by some of the routines */
53 typedef struct sb_info {
54
55 struct sb_pub sb; /* back plane public state (must be first field) */
56
57 void *osh; /* osl os handle */
58 void *sdh; /* bcmsdh handle */
59
60 void *curmap; /* current regs va */
61 void *regs[SB_MAXCORES]; /* other regs va */
62
63 uint curidx; /* current core index */
64 uint dev_coreid; /* the core provides driver functions */
65
66 bool memseg; /* flag to toggle MEM_SEG register */
67
68 uint gpioidx; /* gpio control core index */
69 uint gpioid; /* gpio control coretype */
70
71 uint numcores; /* # discovered cores */
72 uint coreid[SB_MAXCORES]; /* id of each core */
73
74 void *intr_arg; /* interrupt callback function arg */
75 sb_intrsoff_t intrsoff_fn; /* turns chip interrupts off */
76 sb_intrsrestore_t intrsrestore_fn; /* restore chip interrupts */
77 sb_intrsenabled_t intrsenabled_fn; /* check if interrupts are enabled */
78
79 uint8 pciecap_lcreg_offset; /* PCIE capability LCreg offset in the config space */
80 bool pr42767_war;
81 uint8 pcie_polarity;
82 bool pcie_war_ovr; /* Override ASPM/Clkreq settings */
83
84 uint8 pmecap_offset; /* PM Capability offset in the config space */
85 bool pmecap; /* Capable of generating PME */
86
87 gpioh_item_t *gpioh_head; /* GPIO event handlers list */
88
89 char *vars;
90 uint varsz;
91 } sb_info_t;
92
93 /* local prototypes */
94 static sb_info_t *sb_doattach(sb_info_t * si, uint devid, osl_t * osh,
95 void *regs, uint bustype, void *sdh,
96 char **vars, uint * varsz);
97 static void sb_scan(sb_info_t * si);
98 static uint _sb_coreidx(sb_info_t * si);
99 static uint sb_pcidev2chip(uint pcidev);
100 static uint sb_chip2numcores(uint chip);
101 static bool sb_ispcie(sb_info_t * si);
102 static uint8 sb_find_pci_capability(sb_info_t * si, uint8 req_cap_id,
103 uchar * buf, uint32 * buflen);
104 static int sb_pci_fixcfg(sb_info_t * si);
105 /* routines to access mdio slave device registers */
106 static int sb_pcie_mdiowrite(sb_info_t * si, uint physmedia, uint readdr,
107 uint val);
108 static int sb_pcie_mdioread(sb_info_t * si, uint physmedia, uint readdr,
109 uint * ret_val);
110
111 /* dev path concatenation util */
112 static char *sb_devpathvar(sb_t * sbh, char *var, int len, const char *name);
113
114 /* WARs */
115 static void sb_war43448(sb_t * sbh);
116 static void sb_war43448_aspm(sb_t * sbh);
117 static void sb_war32414_forceHT(sb_t * sbh, bool forceHT);
118 static void sb_war30841(sb_info_t * si);
119 static void sb_war42767(sb_t * sbh);
120 static void sb_war42767_clkreq(sb_t * sbh);
121
122 /* delay needed between the mdio control/ mdiodata register data access */
123 #define PR28829_DELAY() OSL_DELAY(10)
124
125 /* size that can take bitfielddump */
126 #define BITFIELD_DUMP_SIZE 32
127
128 /* global variable to indicate reservation/release of gpio's */
129 static uint32 sb_gpioreservation = 0;
130
131 /* global flag to prevent shared resources from being initialized multiple times in sb_attach() */
132 static bool sb_onetimeinit = FALSE;
133
134 #define SB_INFO(sbh) (sb_info_t*)(uintptr)sbh
135 #define SET_SBREG(si, r, mask, val) \
136 W_SBREG((si), (r), ((R_SBREG((si), (r)) & ~(mask)) | (val)))
137 #define GOODCOREADDR(x) (((x) >= SB_ENUM_BASE) && ((x) <= SB_ENUM_LIM) && \
138 ISALIGNED((x), SB_CORE_SIZE))
139 #define GOODREGS(regs) ((regs) && ISALIGNED((uintptr)(regs), SB_CORE_SIZE))
140 #define REGS2SB(va) (sbconfig_t*) ((int8*)(va) + SBCONFIGOFF)
141 #define BADCOREADDR 0
142 #define GOODIDX(idx) (((uint)idx) < SB_MAXCORES)
143 #define BADIDX (SB_MAXCORES+1)
144 #define NOREV -1 /* Invalid rev */
145
146 #define PCI(si) ((BUSTYPE(si->sb.bustype) == PCI_BUS) && (si->sb.buscoretype == SB_PCI))
147 #define PCIE(si) ((BUSTYPE(si->sb.bustype) == PCI_BUS) && (si->sb.buscoretype == SB_PCIE))
148 #define PCMCIA(si) ((BUSTYPE(si->sb.bustype) == PCMCIA_BUS) && (si->memseg == TRUE))
149
150 /* sonicsrev */
151 #define SONICS_2_2 (SBIDL_RV_2_2 >> SBIDL_RV_SHIFT)
152 #define SONICS_2_3 (SBIDL_RV_2_3 >> SBIDL_RV_SHIFT)
153
154 #define R_SBREG(si, sbr) sb_read_sbreg((si), (sbr))
155 #define W_SBREG(si, sbr, v) sb_write_sbreg((si), (sbr), (v))
156 #define AND_SBREG(si, sbr, v) W_SBREG((si), (sbr), (R_SBREG((si), (sbr)) & (v)))
157 #define OR_SBREG(si, sbr, v) W_SBREG((si), (sbr), (R_SBREG((si), (sbr)) | (v)))
158
159 /*
160 * Macros to disable/restore function core(D11, ENET, ILINE20, etc) interrupts before/
161 * after core switching to avoid invalid register accesss inside ISR.
162 */
163 #define INTR_OFF(si, intr_val) \
164 if ((si)->intrsoff_fn && (si)->coreid[(si)->curidx] == (si)->dev_coreid) { \
165 intr_val = (*(si)->intrsoff_fn)((si)->intr_arg); }
166 #define INTR_RESTORE(si, intr_val) \
167 if ((si)->intrsrestore_fn && (si)->coreid[(si)->curidx] == (si)->dev_coreid) { \
168 (*(si)->intrsrestore_fn)((si)->intr_arg, intr_val); }
169
170 /* dynamic clock control defines */
171 #define LPOMINFREQ 25000 /* low power oscillator min */
172 #define LPOMAXFREQ 43000 /* low power oscillator max */
173 #define XTALMINFREQ 19800000 /* 20 MHz - 1% */
174 #define XTALMAXFREQ 20200000 /* 20 MHz + 1% */
175 #define PCIMINFREQ 25000000 /* 25 MHz */
176 #define PCIMAXFREQ 34000000 /* 33 MHz + fudge */
177
178 #define ILP_DIV_5MHZ 0 /* ILP = 5 MHz */
179 #define ILP_DIV_1MHZ 4 /* ILP = 1 MHz */
180
181 /* force HT war check */
182 #define FORCEHT_WAR32414(si) \
183 (((PCIE(si)) && (si->sb.chip == BCM4311_CHIP_ID) && ((si->sb.chiprev <= 1))) || \
184 ((PCI(si) || PCIE(si)) && (si->sb.chip == BCM4321_CHIP_ID) && (si->sb.chiprev <= 3)))
185
186 #define PCIE_ASPMWARS(si) \
187 ((PCIE(si)) && ((si->sb.buscorerev >= 3) && (si->sb.buscorerev <= 5)))
188
189 /* GPIO Based LED powersave defines */
190 #define DEFAULT_GPIO_ONTIME 10 /* Default: 10% on */
191 #define DEFAULT_GPIO_OFFTIME 90 /* Default: 10% on */
192
193 #define DEFAULT_GPIOTIMERVAL ((DEFAULT_GPIO_ONTIME << GPIO_ONTIME_SHIFT) | DEFAULT_GPIO_OFFTIME)
194
195 static uint32 sb_read_sbreg(sb_info_t * si, volatile uint32 * sbr)
196 {
197 uint8 tmp;
198 uint32 val, intr_val = 0;
199
200 /*
201 * compact flash only has 11 bits address, while we needs 12 bits address.
202 * MEM_SEG will be OR'd with other 11 bits address in hardware,
203 * so we program MEM_SEG with 12th bit when necessary(access sb regsiters).
204 * For normal PCMCIA bus(CFTable_regwinsz > 2k), do nothing special
205 */
206 if (PCMCIA(si)) {
207 INTR_OFF(si, intr_val);
208 tmp = 1;
209 OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
210 sbr = (volatile uint32 *)((uintptr) sbr & ~(1 << 11)); /* mask out bit 11 */
211 }
212
213 val = R_REG(si->osh, sbr);
214
215 if (PCMCIA(si)) {
216 tmp = 0;
217 OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
218 INTR_RESTORE(si, intr_val);
219 }
220
221 return (val);
222 }
223
224 static void sb_write_sbreg(sb_info_t * si, volatile uint32 * sbr, uint32 v)
225 {
226 uint8 tmp;
227 volatile uint32 dummy;
228 uint32 intr_val = 0;
229
230 /*
231 * compact flash only has 11 bits address, while we needs 12 bits address.
232 * MEM_SEG will be OR'd with other 11 bits address in hardware,
233 * so we program MEM_SEG with 12th bit when necessary(access sb regsiters).
234 * For normal PCMCIA bus(CFTable_regwinsz > 2k), do nothing special
235 */
236 if (PCMCIA(si)) {
237 INTR_OFF(si, intr_val);
238 tmp = 1;
239 OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
240 sbr = (volatile uint32 *)((uintptr) sbr & ~(1 << 11)); /* mask out bit 11 */
241 }
242
243 if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
244 #ifdef IL_BIGENDIAN
245 dummy = R_REG(si->osh, sbr);
246 W_REG(si->osh, ((volatile uint16 *)sbr + 1),
247 (uint16) ((v >> 16) & 0xffff));
248 dummy = R_REG(si->osh, sbr);
249 W_REG(si->osh, (volatile uint16 *)sbr, (uint16) (v & 0xffff));
250 #else
251 dummy = R_REG(si->osh, sbr);
252 W_REG(si->osh, (volatile uint16 *)sbr, (uint16) (v & 0xffff));
253 dummy = R_REG(si->osh, sbr);
254 W_REG(si->osh, ((volatile uint16 *)sbr + 1),
255 (uint16) ((v >> 16) & 0xffff));
256 #endif /* IL_BIGENDIAN */
257 } else
258 W_REG(si->osh, sbr, v);
259
260 if (PCMCIA(si)) {
261 tmp = 0;
262 OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
263 INTR_RESTORE(si, intr_val);
264 }
265 }
266
267 /*
268 * Allocate a sb handle.
269 * devid - pci device id (used to determine chip#)
270 * osh - opaque OS handle
271 * regs - virtual address of initial core registers
272 * bustype - pci/pcmcia/sb/sdio/etc
273 * vars - pointer to a pointer area for "environment" variables
274 * varsz - pointer to int to return the size of the vars
275 */
276 sb_t *sb_attach(uint devid, osl_t * osh, void *regs,
277 uint bustype, void *sdh, char **vars,
278 uint * varsz) {
279 sb_info_t *si;
280
281 /* alloc sb_info_t */
282 if ((si = MALLOC(osh, sizeof(sb_info_t))) == NULL) {
283 SB_ERROR(("sb_attach: malloc failed! malloced %d bytes\n",
284 MALLOCED(osh)));
285 return (NULL);
286 }
287
288 if (sb_doattach(si, devid, osh, regs, bustype, sdh, vars, varsz) ==
289 NULL) {
290 MFREE(osh, si, sizeof(sb_info_t));
291 return (NULL);
292 }
293 si->vars = vars ? *vars : NULL;
294 si->varsz = varsz ? *varsz : 0;
295
296 return (sb_t *) si;
297 }
298
299 /* Using sb_kattach depends on SB_BUS support, either implicit */
300 /* no limiting BCMBUSTYPE value) or explicit (value is SB_BUS). */
301 #if !defined(BCMBUSTYPE) || (BCMBUSTYPE == SB_BUS)
302
303 /* global kernel resource */
304 static sb_info_t ksi;
305
306 /* generic kernel variant of sb_attach() */
307 sb_t *BCMINITFN(sb_kattach) (osl_t * osh) {
308 static bool ksi_attached = FALSE;
309 uint32 *regs;
310
311 if (!ksi_attached) {
312 uint32 cid;
313
314 regs = (uint32 *) REG_MAP(SB_ENUM_BASE, SB_CORE_SIZE);
315 cid = R_REG(osh, (uint32 *) regs);
316 if (((cid & CID_ID_MASK) == BCM4712_CHIP_ID) &&
317 ((cid & CID_PKG_MASK) != BCM4712LARGE_PKG_ID) &&
318 ((cid & CID_REV_MASK) <= (3 << CID_REV_SHIFT))) {
319 uint32 *scc, val;
320
321 scc =
322 (uint32 *) ((uchar *) regs +
323 OFFSETOF(chipcregs_t, slow_clk_ctl));
324 val = R_REG(osh, scc);
325 SB_ERROR((" initial scc = 0x%x\n", val));
326 val |= SCC_SS_XTAL;
327 W_REG(osh, scc, val);
328 }
329
330 if (sb_doattach(&ksi, BCM4710_DEVICE_ID, osh, (void *)regs, SB_BUS, NULL,
331 osh != SB_OSH ? &ksi.vars : NULL,
332 osh != SB_OSH ? &ksi.varsz : NULL) == NULL)
333 return NULL;
334 ksi_attached = TRUE;
335 }
336
337 return &ksi.sb;
338 }
339 #endif /* !BCMBUSTYPE || (BCMBUSTYPE == SB_BUS) */
340
341 static sb_info_t *BCMINITFN(sb_doattach) (sb_info_t * si, uint devid,
342 osl_t * osh, void *regs,
343 uint bustype, void *sdh,
344 char **vars, uint * varsz) {
345 uint origidx;
346 chipcregs_t *cc;
347 sbconfig_t *sb;
348 uint32 w;
349 char *pvars;
350
351 ASSERT(GOODREGS(regs));
352
353 bzero((uchar *) si, sizeof(sb_info_t));
354 si->sb.buscoreidx = si->gpioidx = BADIDX;
355
356 si->curmap = regs;
357 si->sdh = sdh;
358 si->osh = osh;
359
360 /* check to see if we are a sb core mimic'ing a pci core */
361 if (bustype == PCI_BUS) {
362 if (OSL_PCI_READ_CONFIG
363 (si->osh, PCI_SPROM_CONTROL,
364 sizeof(uint32)) == 0xffffffff) {
365 SB_ERROR(("%s: incoming bus is PCI but it's a lie, switching to SB " "devid:0x%x\n", __FUNCTION__, devid));
366 bustype = SB_BUS;
367 }
368 }
369 si->sb.bustype = bustype;
370 if (si->sb.bustype != BUSTYPE(si->sb.bustype)) {
371 SB_ERROR(("sb_doattach: bus type %d does not match configured bus type %d\n", si->sb.bustype, BUSTYPE(si->sb.bustype)));
372 return NULL;
373 }
374
375 /* need to set memseg flag for CF card first before any sb registers access */
376 if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS)
377 si->memseg = TRUE;
378
379 /* kludge to enable the clock on the 4306 which lacks a slowclock */
380 if (BUSTYPE(si->sb.bustype) == PCI_BUS && !sb_ispcie(si))
381 sb_clkctl_xtal(&si->sb, XTAL | PLL, ON);
382
383 if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
384 w = OSL_PCI_READ_CONFIG(si->osh, PCI_BAR0_WIN, sizeof(uint32));
385 if (!GOODCOREADDR(w))
386 OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN,
387 sizeof(uint32), SB_ENUM_BASE);
388 }
389
390 /* initialize current core index value */
391 si->curidx = _sb_coreidx(si);
392
393 if (si->curidx == BADIDX) {
394 SB_ERROR(("sb_doattach: bad core index\n"));
395 return NULL;
396 }
397
398 /* get sonics backplane revision */
399 sb = REGS2SB(regs);
400 si->sb.sonicsrev =
401 (R_SBREG(si, &sb->sbidlow) & SBIDL_RV_MASK) >> SBIDL_RV_SHIFT;
402 /* keep and reuse the initial register mapping */
403 origidx = si->curidx;
404 if (BUSTYPE(si->sb.bustype) == SB_BUS)
405 si->regs[origidx] = regs;
406
407 /* is core-0 a chipcommon core? */
408 si->numcores = 1;
409 cc = (chipcregs_t *) sb_setcoreidx(&si->sb, 0);
410 if (sb_coreid(&si->sb) != SB_CC)
411 cc = NULL;
412
413 /* determine chip id and rev */
414 if (cc) {
415 /* chip common core found! */
416 si->sb.chip = R_REG(si->osh, &cc->chipid) & CID_ID_MASK;
417 si->sb.chiprev =
418 (R_REG(si->osh, &cc->chipid) & CID_REV_MASK) >>
419 CID_REV_SHIFT;
420 si->sb.chippkg =
421 (R_REG(si->osh, &cc->chipid) & CID_PKG_MASK) >>
422 CID_PKG_SHIFT;
423 } else {
424 /* no chip common core -- must convert device id to chip id */
425 if ((si->sb.chip = sb_pcidev2chip(devid)) == 0) {
426 SB_ERROR(("sb_doattach: unrecognized device id 0x%04x\n", devid));
427 sb_setcoreidx(&si->sb, origidx);
428 return NULL;
429 }
430 }
431
432 /* get chipcommon rev */
433 si->sb.ccrev = cc ? (int)sb_corerev(&si->sb) : NOREV;
434
435 /* get chipcommon capabilites */
436 si->sb.cccaps = cc ? R_REG(si->osh, &cc->capabilities) : 0;
437
438 /* determine numcores */
439 if (cc && ((si->sb.ccrev == 4) || (si->sb.ccrev >= 6)))
440 si->numcores =
441 (R_REG(si->osh, &cc->chipid) & CID_CC_MASK) >> CID_CC_SHIFT;
442 else
443 si->numcores = sb_chip2numcores(si->sb.chip);
444
445 /* return to original core */
446 sb_setcoreidx(&si->sb, origidx);
447
448 /* sanity checks */
449 ASSERT(si->sb.chip);
450
451 /* scan for cores */
452 sb_scan(si);
453
454 /* fixup necessary chip/core configurations */
455 if (BUSTYPE(si->sb.bustype) == PCI_BUS && sb_pci_fixcfg(si)) {
456 SB_ERROR(("sb_doattach: sb_pci_fixcfg failed\n"));
457 return NULL;
458 }
459
460 /* Init nvram from sprom/otp if they exist */
461 if (srom_var_init
462 (&si->sb, BUSTYPE(si->sb.bustype), regs, si->osh, vars, varsz)) {
463 SB_ERROR(("sb_doattach: srom_var_init failed: bad srom\n"));
464 return (NULL);
465 }
466 pvars = vars ? *vars : NULL;
467
468 /* PMU specific initializations */
469 if ((si->sb.cccaps & CC_CAP_PMU) && !sb_onetimeinit) {
470 sb_pmu_init(&si->sb, si->osh);
471 /* Find out Crystal frequency and init PLL */
472 sb_pmu_pll_init(&si->sb, si->osh, getintvar(pvars, "xtalfreq"));
473 /* Initialize PMU resources (up/dn timers, dep masks, etc.) */
474 sb_pmu_res_init(&si->sb, si->osh);
475 }
476 if (cc == NULL) {
477 /*
478 * The chip revision number is hardwired into all
479 * of the pci function config rev fields and is
480 * independent from the individual core revision numbers.
481 * For example, the "A0" silicon of each chip is chip rev 0.
482 * For PCMCIA we get it from the CIS instead.
483 */
484 if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
485 ASSERT(vars);
486 si->sb.chiprev = getintvar(*vars, "chiprev");
487 } else if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
488 w = OSL_PCI_READ_CONFIG(si->osh, PCI_CFG_REV,
489 sizeof(uint32));
490 si->sb.chiprev = w & 0xff;
491 } else
492 si->sb.chiprev = 0;
493 }
494
495 if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
496 w = getintvar(pvars, "regwindowsz");
497 si->memseg = (w <= CFTABLE_REGWIN_2K) ? TRUE : FALSE;
498 }
499 /* gpio control core is required */
500 if (!GOODIDX(si->gpioidx)) {
501 SB_ERROR(("sb_doattach: gpio control core not found\n"));
502 return NULL;
503 }
504
505 /* get boardtype and boardrev */
506 switch (BUSTYPE(si->sb.bustype)) {
507 case PCI_BUS:
508 /* do a pci config read to get subsystem id and subvendor id */
509 w = OSL_PCI_READ_CONFIG(si->osh, PCI_CFG_SVID, sizeof(uint32));
510 /* Let nvram variables override subsystem Vend/ID */
511 if ((si->sb.boardvendor =
512 (uint16) sb_getdevpathintvar(&si->sb, "boardvendor")) == 0)
513 si->sb.boardvendor = w & 0xffff;
514 else
515 SB_ERROR(("Overriding boardvendor: 0x%x instead of 0x%x\n", si->sb.boardvendor, w & 0xffff));
516 if ((si->sb.boardtype =
517 (uint16) sb_getdevpathintvar(&si->sb, "boardtype")) == 0)
518 si->sb.boardtype = (w >> 16) & 0xffff;
519 else
520 SB_ERROR(("Overriding boardtype: 0x%x instead of 0x%x\n", si->sb.boardtype, (w >> 16) & 0xffff));
521 break;
522
523 case PCMCIA_BUS:
524 si->sb.boardvendor = getintvar(pvars, "manfid");
525 si->sb.boardtype = getintvar(pvars, "prodid");
526 break;
527
528 case SB_BUS:
529 case JTAG_BUS:
530 si->sb.boardvendor = VENDOR_BROADCOM;
531 if (pvars == NULL
532 || ((si->sb.boardtype = getintvar(pvars, "prodid")) == 0))
533 if ((si->sb.boardtype =
534 getintvar(NULL, "boardtype")) == 0)
535 si->sb.boardtype = 0xffff;
536 break;
537 }
538
539 if (si->sb.boardtype == 0) {
540 SB_ERROR(("sb_doattach: unknown board type\n"));
541 ASSERT(si->sb.boardtype);
542 }
543
544 si->sb.boardflags = getintvar(pvars, "boardflags");
545
546 /* setup the GPIO based LED powersave register */
547 if (si->sb.ccrev >= 16) {
548 if ((pvars == NULL) || ((w = getintvar(pvars, "leddc")) == 0))
549 w = DEFAULT_GPIOTIMERVAL;
550 sb_corereg(&si->sb, SB_CC_IDX,
551 OFFSETOF(chipcregs_t, gpiotimerval), ~0, w);
552 }
553
554 /* Determine if this board needs override */
555 if (PCIE(si) && (si->sb.chip == BCM4321_CHIP_ID))
556 si->pcie_war_ovr = ((si->sb.boardvendor == VENDOR_APPLE) &&
557 ((uint8) getintvar(pvars, "sromrev") == 4)
558 && ((uint8) getintvar(pvars, "boardrev") <=
559 0x71))
560 || ((uint32) getintvar(pvars, "boardflags2") &
561 BFL2_PCIEWAR_OVR);
562
563 if (PCIE_ASPMWARS(si)) {
564 sb_war43448_aspm((void *)si);
565 sb_war42767_clkreq((void *)si);
566 }
567
568 if (FORCEHT_WAR32414(si)) {
569 si->sb.pr32414 = TRUE;
570 sb_clkctl_init(&si->sb);
571 sb_war32414_forceHT(&si->sb, 1);
572 }
573
574 if (PCIE(si) && ((si->sb.buscorerev == 6) || (si->sb.buscorerev == 7)))
575 si->sb.pr42780 = TRUE;
576
577 if (PCIE_ASPMWARS(si))
578 sb_pcieclkreq(&si->sb, 1, 0);
579
580 if (PCIE(si) &&
581 (((si->sb.chip == BCM4311_CHIP_ID) && (si->sb.chiprev == 2)) ||
582 ((si->sb.chip == BCM4312_CHIP_ID) && (si->sb.chiprev == 0))))
583 sb_set_initiator_to(&si->sb, 0x3,
584 sb_findcoreidx(&si->sb, SB_D11, 0));
585
586 /* Disable gpiopullup and gpiopulldown */
587 if (!sb_onetimeinit && si->sb.ccrev >= 20) {
588 cc = (chipcregs_t *) sb_setcore(&si->sb, SB_CC, 0);
589 W_REG(osh, &cc->gpiopullup, 0);
590 W_REG(osh, &cc->gpiopulldown, 0);
591 sb_setcoreidx(&si->sb, origidx);
592 }
593 #ifdef BCMDBG
594 /* clear any previous epidiag-induced target abort */
595 sb_taclear(&si->sb);
596 #endif /* BCMDBG */
597
598 #ifdef HNDRTE
599 sb_onetimeinit = TRUE;
600 #endif
601
602 return (si);
603 }
604
605 /* Enable/Disable clkreq for PCIE (4311B0/4321B1) */
606 void sb_war42780_clkreq(sb_t * sbh, bool clkreq) {
607 sb_info_t *si;
608
609 si = SB_INFO(sbh);
610
611 /* Don't change clkreq value if serdespll war has not yet been applied */
612 if (!si->pr42767_war && PCIE_ASPMWARS(si))
613 return;
614
615 sb_pcieclkreq(sbh, 1, (int32) clkreq);
616 }
617
618 static void BCMINITFN(sb_war43448) (sb_t * sbh) {
619 sb_info_t *si;
620
621 si = SB_INFO(sbh);
622
623 /* if not pcie bus, we're done */
624 if (!PCIE(si) || !PCIE_ASPMWARS(si))
625 return;
626
627 /* Restore the polarity */
628 if (si->pcie_polarity != 0)
629 sb_pcie_mdiowrite((void *)(uintptr) & si->sb, MDIODATA_DEV_RX,
630 SERDES_RX_CTRL, si->pcie_polarity);
631 }
632
633 static void BCMINITFN(sb_war43448_aspm) (sb_t * sbh) {
634 uint32 w;
635 uint16 val16, *reg16;
636 sbpcieregs_t *pcieregs;
637 sb_info_t *si;
638
639 si = SB_INFO(sbh);
640
641 /* if not pcie bus, we're done */
642 if (!PCIE(si) || !PCIE_ASPMWARS(si))
643 return;
644
645 /* no ASPM stuff on QT or VSIM */
646 if (si->sb.chippkg == HDLSIM_PKG_ID || si->sb.chippkg == HWSIM_PKG_ID)
647 return;
648
649 pcieregs = (sbpcieregs_t *) sb_setcoreidx(sbh, si->sb.buscoreidx);
650
651 /* Enable ASPM in the shadow SROM and Link control */
652 reg16 = &pcieregs->sprom[SRSH_ASPM_OFFSET];
653 val16 = R_REG(si->osh, reg16);
654 if (!si->pcie_war_ovr)
655 val16 |= SRSH_ASPM_ENB;
656 else
657 val16 &= ~SRSH_ASPM_ENB;
658 W_REG(si->osh, reg16, val16);
659
660 w = OSL_PCI_READ_CONFIG(si->osh, si->pciecap_lcreg_offset,
661 sizeof(uint32));
662 if (!si->pcie_war_ovr)
663 w |= PCIE_ASPM_ENAB;
664 else
665 w &= ~PCIE_ASPM_ENAB;
666 OSL_PCI_WRITE_CONFIG(si->osh, si->pciecap_lcreg_offset, sizeof(uint32),
667 w);
668 }
669
670 static void BCMINITFN(sb_war32414_forceHT) (sb_t * sbh, bool forceHT) {
671 sb_info_t *si;
672 uint32 val = 0;
673
674 si = SB_INFO(sbh);
675
676 ASSERT(FORCEHT_WAR32414(si));
677
678 if (forceHT)
679 val = SYCC_HR;
680 sb_corereg(sbh, SB_CC_IDX, OFFSETOF(chipcregs_t, system_clk_ctl),
681 SYCC_HR, val);
682 }
683
684 uint sb_coreid(sb_t * sbh)
685 {
686 sb_info_t *si;
687 sbconfig_t *sb;
688
689 si = SB_INFO(sbh);
690 sb = REGS2SB(si->curmap);
691
692 return ((R_SBREG(si, &sb->sbidhigh) & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT);
693 }
694
695 uint sb_flag(sb_t * sbh)
696 {
697 sb_info_t *si;
698 sbconfig_t *sb;
699
700 si = SB_INFO(sbh);
701 sb = REGS2SB(si->curmap);
702
703 return R_SBREG(si, &sb->sbtpsflag) & SBTPS_NUM0_MASK;
704 }
705
706 uint sb_coreidx(sb_t * sbh)
707 {
708 sb_info_t *si;
709
710 si = SB_INFO(sbh);
711 return (si->curidx);
712 }
713
714 static uint _sb_coreidx(sb_info_t * si)
715 {
716
717 sbconfig_t *sb;
718 uint32 sbaddr = 0;
719
720 ASSERT(si);
721
722 switch (BUSTYPE(si->sb.bustype)) {
723 case SB_BUS:
724 sb = REGS2SB(si->curmap);
725 sbaddr = sb_base(R_SBREG(si, &sb->sbadmatch0));
726 break;
727
728 case PCI_BUS:
729 sbaddr =
730 OSL_PCI_READ_CONFIG(si->osh, PCI_BAR0_WIN, sizeof(uint32));
731 break;
732
733 case PCMCIA_BUS:{
734 uint8 tmp = 0;
735
736 OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
737 sbaddr = (uint) tmp << 12;
738 OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
739 sbaddr |= (uint) tmp << 16;
740 OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
741 sbaddr |= (uint) tmp << 24;
742 break;
743 }
744
745 #ifdef BCMJTAG
746 case JTAG_BUS:
747 sbaddr = (uint32) si->curmap;
748 break;
749 #endif /* BCMJTAG */
750
751 default:
752 ASSERT(0);
753 }
754
755 if (!GOODCOREADDR(sbaddr))
756 return BADIDX;
757
758 return ((sbaddr - SB_ENUM_BASE) / SB_CORE_SIZE);
759 }
760
761 uint sb_corevendor(sb_t * sbh)
762 {
763 sb_info_t *si;
764 sbconfig_t *sb;
765
766 si = SB_INFO(sbh);
767 sb = REGS2SB(si->curmap);
768
769 return ((R_SBREG(si, &sb->sbidhigh) & SBIDH_VC_MASK) >> SBIDH_VC_SHIFT);
770 }
771
772 uint sb_corerev(sb_t * sbh)
773 {
774 sb_info_t *si;
775 sbconfig_t *sb;
776 uint sbidh;
777
778 si = SB_INFO(sbh);
779 sb = REGS2SB(si->curmap);
780 sbidh = R_SBREG(si, &sb->sbidhigh);
781
782 return (SBCOREREV(sbidh));
783 }
784
785 void *sb_osh(sb_t * sbh)
786 {
787 sb_info_t *si;
788
789 si = SB_INFO(sbh);
790 return si->osh;
791 }
792
793 void sb_setosh(sb_t * sbh, osl_t * osh)
794 {
795 sb_info_t *si;
796
797 si = SB_INFO(sbh);
798 if (si->osh != NULL) {
799 SB_ERROR(("osh is already set....\n"));
800 ASSERT(!si->osh);
801 }
802 si->osh = osh;
803 }
804
805 /* set sbtmstatelow core-specific flags */
806 void sb_coreflags_wo(sb_t * sbh, uint32 mask, uint32 val)
807 {
808 sb_info_t *si;
809 sbconfig_t *sb;
810 uint32 w;
811
812 si = SB_INFO(sbh);
813 sb = REGS2SB(si->curmap);
814
815 ASSERT((val & ~mask) == 0);
816
817 /* mask and set */
818 w = (R_SBREG(si, &sb->sbtmstatelow) & ~mask) | val;
819 W_SBREG(si, &sb->sbtmstatelow, w);
820 }
821
822 /* set/clear sbtmstatelow core-specific flags */
823 uint32 sb_coreflags(sb_t * sbh, uint32 mask, uint32 val)
824 {
825 sb_info_t *si;
826 sbconfig_t *sb;
827 uint32 w;
828
829 si = SB_INFO(sbh);
830 sb = REGS2SB(si->curmap);
831
832 ASSERT((val & ~mask) == 0);
833
834 /* mask and set */
835 if (mask || val) {
836 w = (R_SBREG(si, &sb->sbtmstatelow) & ~mask) | val;
837 W_SBREG(si, &sb->sbtmstatelow, w);
838 }
839
840 /* return the new value
841 * for write operation, the following readback ensures the completion of write opration.
842 */
843 return (R_SBREG(si, &sb->sbtmstatelow));
844 }
845
846 /* set/clear sbtmstatehigh core-specific flags */
847 uint32 sb_coreflagshi(sb_t * sbh, uint32 mask, uint32 val)
848 {
849 sb_info_t *si;
850 sbconfig_t *sb;
851 uint32 w;
852
853 si = SB_INFO(sbh);
854 sb = REGS2SB(si->curmap);
855
856 ASSERT((val & ~mask) == 0);
857 ASSERT((mask & ~SBTMH_FL_MASK) == 0);
858
859 /* mask and set */
860 if (mask || val) {
861 w = (R_SBREG(si, &sb->sbtmstatehigh) & ~mask) | val;
862 W_SBREG(si, &sb->sbtmstatehigh, w);
863 }
864
865 /* return the new value */
866 return (R_SBREG(si, &sb->sbtmstatehigh));
867 }
868
869 /* Run bist on current core. Caller needs to take care of core-specific bist hazards */
870 int sb_corebist(sb_t * sbh)
871 {
872 uint32 sblo;
873 sb_info_t *si;
874 sbconfig_t *sb;
875 int result = 0;
876
877 si = SB_INFO(sbh);
878 sb = REGS2SB(si->curmap);
879
880 sblo = R_SBREG(si, &sb->sbtmstatelow);
881 W_SBREG(si, &sb->sbtmstatelow, (sblo | SBTML_FGC | SBTML_BE));
882
883 SPINWAIT(((R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_BISTD) == 0),
884 100000);
885
886 if (R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_BISTF)
887 result = -1;
888
889 W_SBREG(si, &sb->sbtmstatelow, sblo);
890
891 return result;
892 }
893
894 bool sb_iscoreup(sb_t * sbh)
895 {
896 sb_info_t *si;
897 sbconfig_t *sb;
898
899 si = SB_INFO(sbh);
900 sb = REGS2SB(si->curmap);
901
902 return ((R_SBREG(si, &sb->sbtmstatelow) &
903 (SBTML_RESET | SBTML_REJ_MASK | SBTML_CLK)) == SBTML_CLK);
904 }
905
906 /*
907 * Switch to 'coreidx', issue a single arbitrary 32bit register mask&set operation,
908 * switch back to the original core, and return the new value.
909 *
910 * When using the silicon backplane, no fidleing with interrupts or core switches are needed.
911 *
912 * Also, when using pci/pcie, we can optimize away the core switching for pci registers
913 * and (on newer pci cores) chipcommon registers.
914 */
915 uint sb_corereg(sb_t * sbh, uint coreidx, uint regoff, uint mask, uint val)
916 {
917 uint origidx = 0;
918 uint32 *r = NULL;
919 uint w;
920 uint intr_val = 0;
921 bool fast = FALSE;
922 sb_info_t *si;
923
924 si = SB_INFO(sbh);
925
926 ASSERT(GOODIDX(coreidx));
927 ASSERT(regoff < SB_CORE_SIZE);
928 ASSERT((val & ~mask) == 0);
929
930 #if 0
931 if (BUSTYPE(si->sb.bustype) == SB_BUS) {
932 /* If internal bus, we can always get at everything */
933 fast = TRUE;
934 /* map if does not exist */
935 if (!si->regs[coreidx]) {
936 si->regs[coreidx] =
937 (void *)REG_MAP(si->coresba[coreidx], SB_CORE_SIZE);
938 ASSERT(GOODREGS(si->regs[coreidx]));
939 }
940 r = (uint32 *) ((uchar *) si->regs[coreidx] + regoff);
941 } else if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
942 /* If pci/pcie, we can get at pci/pcie regs and on newer cores to chipc */
943
944 if ((si->coreid[coreidx] == SB_CC) &&
945 ((si->sb.buscoretype == SB_PCIE)
946 || (si->sb.buscorerev >= 13))) {
947 /* Chipc registers are mapped at 12KB */
948
949 fast = TRUE;
950 r = (uint32 *) ((char *)si->curmap +
951 PCI_16KB0_CCREGS_OFFSET + regoff);
952 } else if (si->sb.buscoreidx == coreidx) {
953 /* pci registers are at either in the last 2KB of an 8KB window
954 * or, in pcie and pci rev 13 at 8KB
955 */
956 fast = TRUE;
957 if ((si->sb.buscoretype == SB_PCIE)
958 || (si->sb.buscorerev >= 13))
959 r = (uint32 *) ((char *)si->curmap +
960 PCI_16KB0_PCIREGS_OFFSET +
961 regoff);
962 else
963 r = (uint32 *) ((char *)si->curmap +
964 ((regoff >= SBCONFIGOFF) ?
965 PCI_BAR0_PCISBR_OFFSET :
966 PCI_BAR0_PCIREGS_OFFSET)
967 + regoff);
968 }
969 }
970 #endif
971
972 if (!fast) {
973 INTR_OFF(si, intr_val);
974
975 /* save current core index */
976 origidx = sb_coreidx(&si->sb);
977
978 /* switch core */
979 r = (uint32 *) ((uchar *) sb_setcoreidx(&si->sb, coreidx) +
980 regoff);
981 }
982 ASSERT(r);
983
984 /* mask and set */
985 if (mask || val) {
986 if (regoff >= SBCONFIGOFF) {
987 w = (R_SBREG(si, r) & ~mask) | val;
988 W_SBREG(si, r, w);
989 } else {
990 w = (R_REG(si->osh, r) & ~mask) | val;
991 W_REG(si->osh, r, w);
992 }
993 }
994
995 /* readback */
996 if (regoff >= SBCONFIGOFF)
997 w = R_SBREG(si, r);
998 else {
999 if ((si->sb.chip == BCM5354_CHIP_ID) &&
1000 (coreidx == SB_CC_IDX) &&
1001 (regoff == OFFSETOF(chipcregs_t, watchdog))) {
1002 w = val;
1003 } else
1004 w = R_REG(si->osh, r);
1005 }
1006
1007 if (!fast) {
1008 /* restore core index */
1009 if (origidx != coreidx)
1010 sb_setcoreidx(&si->sb, origidx);
1011
1012 INTR_RESTORE(si, intr_val);
1013 }
1014
1015 return (w);
1016 }
1017
1018 #define DWORD_ALIGN(x) (x & ~(0x03))
1019 #define BYTE_POS(x) (x & 0x3)
1020 #define WORD_POS(x) (x & 0x1)
1021
1022 #define BYTE_SHIFT(x) (8 * BYTE_POS(x))
1023 #define WORD_SHIFT(x) (16 * WORD_POS(x))
1024
1025 #define BYTE_VAL(a, x) ((a >> BYTE_SHIFT(x)) & 0xFF)
1026 #define WORD_VAL(a, x) ((a >> WORD_SHIFT(x)) & 0xFFFF)
1027
1028 #define read_pci_cfg_byte(a) \
1029 (BYTE_VAL(OSL_PCI_READ_CONFIG(si->osh, DWORD_ALIGN(a), 4), a) & 0xff)
1030
1031 #define read_pci_cfg_word(a) \
1032 (WORD_VAL(OSL_PCI_READ_CONFIG(si->osh, DWORD_ALIGN(a), 4), a) & 0xffff)
1033
1034 /* return cap_offset if requested capability exists in the PCI config space */
1035 static uint8
1036 sb_find_pci_capability(sb_info_t * si, uint8 req_cap_id, uchar * buf,
1037 uint32 * buflen)
1038 {
1039 uint8 cap_id;
1040 uint8 cap_ptr = 0;
1041 uint32 bufsize;
1042 uint8 byte_val;
1043
1044 if (BUSTYPE(si->sb.bustype) != PCI_BUS)
1045 goto end;
1046
1047 /* check for Header type 0 */
1048 byte_val = read_pci_cfg_byte(PCI_CFG_HDR);
1049 if ((byte_val & 0x7f) != PCI_HEADER_NORMAL)
1050 goto end;
1051
1052 /* check if the capability pointer field exists */
1053 byte_val = read_pci_cfg_byte(PCI_CFG_STAT);
1054 if (!(byte_val & PCI_CAPPTR_PRESENT))
1055 goto end;
1056
1057 cap_ptr = read_pci_cfg_byte(PCI_CFG_CAPPTR);
1058 /* check if the capability pointer is 0x00 */
1059 if (cap_ptr == 0x00)
1060 goto end;
1061
1062 /* loop thr'u the capability list and see if the pcie capabilty exists */
1063
1064 cap_id = read_pci_cfg_byte(cap_ptr);
1065
1066 while (cap_id != req_cap_id) {
1067 cap_ptr = read_pci_cfg_byte((cap_ptr + 1));
1068 if (cap_ptr == 0x00)
1069 break;
1070 cap_id = read_pci_cfg_byte(cap_ptr);
1071 }
1072 if (cap_id != req_cap_id) {
1073 goto end;
1074 }
1075 /* found the caller requested capability */
1076 if ((buf != NULL) && (buflen != NULL)) {
1077 uint8 cap_data;
1078
1079 bufsize = *buflen;
1080 if (!bufsize)
1081 goto end;
1082 *buflen = 0;
1083 /* copy the cpability data excluding cap ID and next ptr */
1084 cap_data = cap_ptr + 2;
1085 if ((bufsize + cap_data) > SZPCR)
1086 bufsize = SZPCR - cap_data;
1087 *buflen = bufsize;
1088 while (bufsize--) {
1089 *buf = read_pci_cfg_byte(cap_data);
1090 cap_data++;
1091 buf++;
1092 }
1093 }
1094 end:
1095 return cap_ptr;
1096 }
1097
1098 uint8 sb_pcieclkreq(sb_t * sbh, uint32 mask, uint32 val)
1099 {
1100 sb_info_t *si;
1101 uint32 reg_val;
1102 uint8 offset;
1103
1104 si = SB_INFO(sbh);
1105
1106 offset = si->pciecap_lcreg_offset;
1107 if (!offset)
1108 return 0;
1109
1110 reg_val = OSL_PCI_READ_CONFIG(si->osh, offset, sizeof(uint32));
1111 /* set operation */
1112 if (mask) {
1113 if (val)
1114 reg_val |= PCIE_CLKREQ_ENAB;
1115 else
1116 reg_val &= ~PCIE_CLKREQ_ENAB;
1117 OSL_PCI_WRITE_CONFIG(si->osh, offset, sizeof(uint32), reg_val);
1118 reg_val = OSL_PCI_READ_CONFIG(si->osh, offset, sizeof(uint32));
1119 }
1120 if (reg_val & PCIE_CLKREQ_ENAB)
1121 return 1;
1122 else
1123 return 0;
1124 }
1125
1126 #ifdef BCMDBG
1127
1128 uint32 sb_pcielcreg(sb_t * sbh, uint32 mask, uint32 val)
1129 {
1130 sb_info_t *si;
1131 uint32 reg_val;
1132 uint8 offset;
1133
1134 si = SB_INFO(sbh);
1135
1136 if (!PCIE(si))
1137 return 0;
1138
1139 offset = si->pciecap_lcreg_offset;
1140 if (!offset)
1141 return 0;
1142
1143 /* set operation */
1144 if (mask)
1145 OSL_PCI_WRITE_CONFIG(si->osh, offset, sizeof(uint32), val);
1146
1147 reg_val = OSL_PCI_READ_CONFIG(si->osh, offset, sizeof(uint32));
1148
1149 return reg_val;
1150 }
1151
1152 uint8 sb_pcieL1plldown(sb_t * sbh)
1153 {
1154 sb_info_t *si;
1155 uint intr_val = 0;
1156 uint origidx;
1157 uint32 reg_val;
1158
1159 si = SB_INFO(sbh);
1160
1161 if (!PCIE(si))
1162 return 0;
1163 if (!((si->sb.buscorerev == 3) || (si->sb.buscorerev == 4)))
1164 return 0;
1165
1166 if (!sb_pcieclkreq((void *)(uintptr) sbh, 0, 0)) {
1167 SB_ERROR(("PCIEL1PLLDOWN requires Clkreq be enabled, so enable it\n"));
1168 sb_pcieclkreq((void *)(uintptr) sbh, 1, 1);
1169 }
1170 reg_val = sb_pcielcreg((void *)(uintptr) sbh, 0, 0);
1171 if (reg_val & PCIE_CAP_LCREG_ASPML0s) {
1172 SB_ERROR(("PCIEL1PLLDOWN requires L0s to be disabled\n"));
1173 reg_val &= ~PCIE_CAP_LCREG_ASPML0s;
1174 sb_pcielcreg((void *)(uintptr) sbh, 1, reg_val);
1175 } else
1176 SB_ERROR(("PCIEL1PLLDOWN: L0s is already disabled\n"));
1177
1178 /* turnoff intrs, change core, set original back, turn on intrs back on */
1179 origidx = si->curidx;
1180 INTR_OFF(si, intr_val);
1181 sb_setcore(sbh, SB_PCIE, 0);
1182
1183 sb_pcie_writereg((void *)(uintptr) sbh, (void *)PCIE_PCIEREGS,
1184 PCIE_DLLP_PCIE11, 0);
1185
1186 sb_setcoreidx(sbh, origidx);
1187 INTR_RESTORE(si, intr_val);
1188 return 1;
1189 }
1190 #endif /* BCMDBG */
1191
1192 /* return TRUE if PCIE capability exists in the pci config space */
1193 static bool sb_ispcie(sb_info_t * si)
1194 {
1195 uint8 cap_ptr;
1196
1197 cap_ptr = sb_find_pci_capability(si, PCI_CAP_PCIECAP_ID, NULL, NULL);
1198 if (!cap_ptr)
1199 return FALSE;
1200
1201 si->pciecap_lcreg_offset = cap_ptr + PCIE_CAP_LINKCTRL_OFFSET;
1202
1203 return TRUE;
1204 }
1205
1206 /* Wake-on-wireless-LAN (WOWL) support functions */
1207 /* return TRUE if PM capability exists in the pci config space */
1208 bool sb_pci_pmecap(sb_t * sbh)
1209 {
1210 uint8 cap_ptr;
1211 uint32 pmecap;
1212 sb_info_t *si;
1213
1214 si = SB_INFO(sbh);
1215
1216 if (si == NULL || !(PCI(si) || PCIE(si)))
1217 return FALSE;
1218
1219 if (!si->pmecap_offset) {
1220 cap_ptr =
1221 sb_find_pci_capability(si, PCI_CAP_POWERMGMTCAP_ID, NULL,
1222 NULL);
1223 if (!cap_ptr)
1224 return FALSE;
1225
1226 si->pmecap_offset = cap_ptr;
1227
1228 pmecap =
1229 OSL_PCI_READ_CONFIG(si->osh, si->pmecap_offset,
1230 sizeof(uint32));
1231
1232 /* At least one state can generate PME */
1233 si->pmecap = (pmecap & PME_CAP_PM_STATES) != 0;
1234 }
1235
1236 return (si->pmecap);
1237 }
1238
1239 /* Enable PME generation and disable clkreq */
1240 void sb_pci_pmeen(sb_t * sbh)
1241 {
1242 sb_info_t *si;
1243 uint32 w;
1244 si = SB_INFO(sbh);
1245
1246 /* if not pmecapable return */
1247 if (!sb_pci_pmecap(sbh))
1248 return;
1249
1250 w = OSL_PCI_READ_CONFIG(si->osh, si->pmecap_offset + PME_CSR_OFFSET,
1251 sizeof(uint32));
1252 w |= (PME_CSR_PME_EN);
1253 OSL_PCI_WRITE_CONFIG(si->osh, si->pmecap_offset + PME_CSR_OFFSET,
1254 sizeof(uint32), w);
1255
1256 /* Disable clkreq */
1257 if (si->pr42767_war) {
1258 sb_pcieclkreq(sbh, 1, 0);
1259 si->pr42767_war = FALSE;
1260 } else if (si->sb.pr42780) {
1261 sb_pcieclkreq(sbh, 1, 1);
1262 }
1263 }
1264
1265 /* Disable PME generation, clear the PME status bit if set and
1266 * return TRUE if PME status set
1267 */
1268 bool sb_pci_pmeclr(sb_t * sbh)
1269 {
1270 sb_info_t *si;
1271 uint32 w;
1272 bool ret = FALSE;
1273
1274 si = SB_INFO(sbh);
1275
1276 if (!sb_pci_pmecap(sbh))
1277 return ret;
1278
1279 w = OSL_PCI_READ_CONFIG(si->osh, si->pmecap_offset + PME_CSR_OFFSET,
1280 sizeof(uint32));
1281
1282 SB_ERROR(("sb_pci_pmeclr PMECSR : 0x%x\n", w));
1283 ret = (w & PME_CSR_PME_STAT) == PME_CSR_PME_STAT;
1284
1285 /* PMESTAT is cleared by writing 1 to it */
1286 w &= ~(PME_CSR_PME_EN);
1287
1288 OSL_PCI_WRITE_CONFIG(si->osh, si->pmecap_offset + PME_CSR_OFFSET,
1289 sizeof(uint32), w);
1290
1291 return ret;
1292 }
1293
1294 /* use pci dev id to determine chip id for chips not having a chipcommon core */
1295 static uint BCMINITFN(sb_pcidev2chip) (uint pcidev) {
1296 if ((pcidev >= BCM4710_DEVICE_ID) && (pcidev <= BCM47XX_USB_ID))
1297 return (BCM4710_CHIP_ID);
1298 if ((pcidev >= BCM4402_ENET_ID) && (pcidev <= BCM4402_V90_ID))
1299 return (BCM4402_CHIP_ID);
1300 if (pcidev == BCM4401_ENET_ID)
1301 return (BCM4402_CHIP_ID);
1302 if (pcidev == SDIOH_FPGA_ID)
1303 return (SDIOH_FPGA_ID);
1304
1305 return (0);
1306 }
1307
1308 /* Scan the enumeration space to find all cores starting from the given
1309 * bus 'sbba'. Append coreid and other info to the lists in 'si'. 'sba'
1310 * is the default core address at chip POR time and 'regs' is the virtual
1311 * address that the default core is mapped at. 'ncores' is the number of
1312 * cores expected on bus 'sbba'. It returns the total number of cores
1313 * starting from bus 'sbba', inclusive.
1314 */
1315
1316 static void BCMINITFN(sb_scan) (sb_info_t * si) {
1317 sb_t *sbh;
1318 uint origidx;
1319 uint i;
1320 bool pci;
1321 bool pcie;
1322 uint pciidx;
1323 uint pcieidx;
1324 uint pcirev;
1325 uint pcierev;
1326
1327 sbh = (sb_t *) si;
1328
1329 /* numcores should already be set */
1330 ASSERT((si->numcores > 0) && (si->numcores <= SB_MAXCORES));
1331
1332 /* save current core index */
1333 origidx = sb_coreidx(&si->sb);
1334
1335 si->sb.buscorerev = NOREV;
1336 si->sb.buscoreidx = BADIDX;
1337
1338 si->gpioidx = BADIDX;
1339
1340 pci = pcie = FALSE;
1341 pcirev = pcierev = NOREV;
1342 pciidx = pcieidx = BADIDX;
1343
1344 for (i = 0; i < si->numcores; i++) {
1345 sb_setcoreidx(&si->sb, i);
1346 si->coreid[i] = sb_coreid(&si->sb);
1347
1348 if (si->coreid[i] == SB_PCI) {
1349 pciidx = i;
1350 pcirev = sb_corerev(&si->sb);
1351 pci = TRUE;
1352 } else if (si->coreid[i] == SB_PCIE) {
1353 pcieidx = i;
1354 pcierev = sb_corerev(&si->sb);
1355 pcie = TRUE;
1356 } else if (si->coreid[i] == SB_PCMCIA) {
1357 si->sb.buscorerev = sb_corerev(&si->sb);
1358 si->sb.buscoretype = si->coreid[i];
1359 si->sb.buscoreidx = i;
1360 }
1361 }
1362 if (pci && pcie) {
1363 if (sb_ispcie(si))
1364 pci = FALSE;
1365 else
1366 pcie = FALSE;
1367 }
1368 if (pci) {
1369 si->sb.buscoretype = SB_PCI;
1370 si->sb.buscorerev = pcirev;
1371 si->sb.buscoreidx = pciidx;
1372 } else if (pcie) {
1373 si->sb.buscoretype = SB_PCIE;
1374 si->sb.buscorerev = pcierev;
1375 si->sb.buscoreidx = pcieidx;
1376 }
1377
1378 /*
1379 * Find the gpio "controlling core" type and index.
1380 * Precedence:
1381 * - if there's a chip common core - use that
1382 * - else if there's a pci core (rev >= 2) - use that
1383 * - else there had better be an extif core (4710 only)
1384 */
1385 if (GOODIDX(sb_findcoreidx(sbh, SB_CC, 0))) {
1386 si->gpioidx = sb_findcoreidx(sbh, SB_CC, 0);
1387 si->gpioid = SB_CC;
1388 } else if (PCI(si) && (si->sb.buscorerev >= 2)) {
1389 si->gpioidx = si->sb.buscoreidx;
1390 si->gpioid = SB_PCI;
1391 } else if (sb_findcoreidx(sbh, SB_EXTIF, 0)) {
1392 si->gpioidx = sb_findcoreidx(sbh, SB_EXTIF, 0);
1393 si->gpioid = SB_EXTIF;
1394 } else
1395 ASSERT(si->gpioidx != BADIDX);
1396
1397 /* return to original core index */
1398 sb_setcoreidx(&si->sb, origidx);
1399 }
1400
1401 /* may be called with core in reset */
1402 void sb_detach(sb_t * sbh)
1403 {
1404 sb_info_t *si;
1405 uint idx;
1406
1407 si = SB_INFO(sbh);
1408
1409 if (si == NULL)
1410 return;
1411
1412 if (BUSTYPE(si->sb.bustype) == SB_BUS)
1413 for (idx = 0; idx < SB_MAXCORES; idx++)
1414 if (si->regs[idx]) {
1415 REG_UNMAP(si->regs[idx]);
1416 si->regs[idx] = NULL;
1417 }
1418 #if !defined(BCMBUSTYPE) || (BCMBUSTYPE == SB_BUS)
1419 if (si != &ksi)
1420 #endif /* !BCMBUSTYPE || (BCMBUSTYPE == SB_BUS) */
1421 MFREE(si->osh, si, sizeof(sb_info_t));
1422 }
1423
1424
1425 /* convert chip number to number of i/o cores */
1426 static uint BCMINITFN(sb_chip2numcores) (uint chip) {
1427 if (chip == BCM4710_CHIP_ID)
1428 return (9);
1429 if (chip == BCM4402_CHIP_ID)
1430 return (3);
1431 if (chip == BCM4306_CHIP_ID) /* < 4306c0 */
1432 return (6);
1433 if (chip == BCM4704_CHIP_ID)
1434 return (9);
1435 if (chip == BCM5365_CHIP_ID)
1436 return (7);
1437 if (chip == SDIOH_FPGA_ID)
1438 return (2);
1439
1440 SB_ERROR(("sb_chip2numcores: unsupported chip 0x%x\n", chip));
1441 ASSERT(0);
1442 return (1);
1443 }
1444
1445 /* return index of coreid or BADIDX if not found */
1446 uint sb_findcoreidx(sb_t * sbh, uint coreid, uint coreunit)
1447 {
1448 sb_info_t *si;
1449 uint found;
1450 uint i;
1451
1452 si = SB_INFO(sbh);
1453
1454 found = 0;
1455
1456 for (i = 0; i < si->numcores; i++)
1457 if (si->coreid[i] == coreid) {
1458 if (found == coreunit)
1459 return (i);
1460 found++;
1461 }
1462
1463 return (BADIDX);
1464 }
1465
1466 /*
1467 * this function changes logical "focus" to the indiciated core,
1468 * must be called with interrupt off.
1469 * Moreover, callers should keep interrupts off during switching out of and back to d11 core
1470 */
1471 void *sb_setcoreidx(sb_t * sbh, uint coreidx)
1472 {
1473 sb_info_t *si;
1474 uint32 sbaddr;
1475 uint8 tmp;
1476
1477 si = SB_INFO(sbh);
1478
1479 if (coreidx >= si->numcores)
1480 return (NULL);
1481
1482 /*
1483 * If the user has provided an interrupt mask enabled function,
1484 * then assert interrupts are disabled before switching the core.
1485 */
1486 ASSERT((si->intrsenabled_fn == NULL)
1487 || !(*(si)->intrsenabled_fn) ((si)->intr_arg));
1488
1489 sbaddr = SB_ENUM_BASE + (coreidx * SB_CORE_SIZE);
1490
1491 switch (BUSTYPE(si->sb.bustype)) {
1492 case SB_BUS:
1493 /* map new one */
1494 if (!si->regs[coreidx]) {
1495 si->regs[coreidx] =
1496 (void *)REG_MAP(sbaddr, SB_CORE_SIZE);
1497 ASSERT(GOODREGS(si->regs[coreidx]));
1498 }
1499 si->curmap = si->regs[coreidx];
1500 break;
1501
1502 case PCI_BUS:
1503 /* point bar0 window */
1504 OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN, 4, sbaddr);
1505 break;
1506
1507 case PCMCIA_BUS:
1508 tmp = (sbaddr >> 12) & 0x0f;
1509 OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
1510 tmp = (sbaddr >> 16) & 0xff;
1511 OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
1512 tmp = (sbaddr >> 24) & 0xff;
1513 OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
1514 break;
1515 #ifdef BCMJTAG
1516 case JTAG_BUS:
1517 /* map new one */
1518 if (!si->regs[coreidx]) {
1519 si->regs[coreidx] = (void *)sbaddr;
1520 ASSERT(GOODREGS(si->regs[coreidx]));
1521 }
1522 si->curmap = si->regs[coreidx];
1523 break;
1524 #endif /* BCMJTAG */
1525 }
1526
1527 si->curidx = coreidx;
1528
1529 return (si->curmap);
1530 }
1531
1532 /*
1533 * this function changes logical "focus" to the indiciated core,
1534 * must be called with interrupt off.
1535 * Moreover, callers should keep interrupts off during switching out of and back to d11 core
1536 */
1537 void *sb_setcore(sb_t * sbh, uint coreid, uint coreunit)
1538 {
1539 uint idx;
1540
1541 idx = sb_findcoreidx(sbh, coreid, coreunit);
1542 if (!GOODIDX(idx))
1543 return (NULL);
1544
1545 return (sb_setcoreidx(sbh, idx));
1546 }
1547
1548 /* return chip number */
1549 uint BCMINITFN(sb_chip) (sb_t * sbh) {
1550 sb_info_t *si;
1551
1552 si = SB_INFO(sbh);
1553 return (si->sb.chip);
1554 }
1555
1556 /* return chip revision number */
1557 uint BCMINITFN(sb_chiprev) (sb_t * sbh) {
1558 sb_info_t *si;
1559
1560 si = SB_INFO(sbh);
1561 return (si->sb.chiprev);
1562 }
1563
1564 /* return chip common revision number */
1565 uint BCMINITFN(sb_chipcrev) (sb_t * sbh) {
1566 sb_info_t *si;
1567
1568 si = SB_INFO(sbh);
1569 return (si->sb.ccrev);
1570 }
1571
1572 /* return chip package option */
1573 uint BCMINITFN(sb_chippkg) (sb_t * sbh) {
1574 sb_info_t *si;
1575
1576 si = SB_INFO(sbh);
1577 return (si->sb.chippkg);
1578 }
1579
1580 /* return PCI core rev. */
1581 uint BCMINITFN(sb_pcirev) (sb_t * sbh) {
1582 sb_info_t *si;
1583
1584 si = SB_INFO(sbh);
1585 return (si->sb.buscorerev);
1586 }
1587
1588 bool BCMINITFN(sb_war16165) (sb_t * sbh) {
1589 sb_info_t *si;
1590
1591 si = SB_INFO(sbh);
1592
1593 return (PCI(si) && (si->sb.buscorerev <= 10));
1594 }
1595
1596 static void BCMINITFN(sb_war30841) (sb_info_t * si) {
1597 sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_TIMER1, 0x8128);
1598 sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_CDR, 0x0100);
1599 sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_CDRBW, 0x1466);
1600 }
1601
1602 /* return PCMCIA core rev. */
1603 uint BCMINITFN(sb_pcmciarev) (sb_t * sbh) {
1604 sb_info_t *si;
1605
1606 si = SB_INFO(sbh);
1607 return (si->sb.buscorerev);
1608 }
1609
1610 /* return board vendor id */
1611 uint BCMINITFN(sb_boardvendor) (sb_t * sbh) {
1612 sb_info_t *si;
1613
1614 si = SB_INFO(sbh);
1615 return (si->sb.boardvendor);
1616 }
1617
1618 /* return boardtype */
1619 uint BCMINITFN(sb_boardtype) (sb_t * sbh) {
1620 sb_info_t *si;
1621 char *var;
1622
1623 si = SB_INFO(sbh);
1624
1625 if (BUSTYPE(si->sb.bustype) == SB_BUS && si->sb.boardtype == 0xffff) {
1626 /* boardtype format is a hex string */
1627 si->sb.boardtype = getintvar(NULL, "boardtype");
1628
1629 /* backward compatibility for older boardtype string format */
1630 if ((si->sb.boardtype == 0)
1631 && (var = getvar(NULL, "boardtype"))) {
1632 if (!strcmp(var, "bcm94710dev"))
1633 si->sb.boardtype = BCM94710D_BOARD;
1634 else if (!strcmp(var, "bcm94710ap"))
1635 si->sb.boardtype = BCM94710AP_BOARD;
1636 else if (!strcmp(var, "bu4710"))
1637 si->sb.boardtype = BU4710_BOARD;
1638 else if (!strcmp(var, "bcm94702mn"))
1639 si->sb.boardtype = BCM94702MN_BOARD;
1640 else if (!strcmp(var, "bcm94710r1"))
1641 si->sb.boardtype = BCM94710R1_BOARD;
1642 else if (!strcmp(var, "bcm94710r4"))
1643 si->sb.boardtype = BCM94710R4_BOARD;
1644 else if (!strcmp(var, "bcm94702cpci"))
1645 si->sb.boardtype = BCM94702CPCI_BOARD;
1646 else if (!strcmp(var, "bcm95380_rr"))
1647 si->sb.boardtype = BCM95380RR_BOARD;
1648 }
1649 }
1650
1651 return (si->sb.boardtype);
1652 }
1653
1654 /* return bus type of sbh device */
1655 uint sb_bus(sb_t * sbh)
1656 {
1657 sb_info_t *si;
1658
1659 si = SB_INFO(sbh);
1660 return (si->sb.bustype);
1661 }
1662
1663 /* return bus core type */
1664 uint sb_buscoretype(sb_t * sbh)
1665 {
1666 sb_info_t *si;
1667
1668 si = SB_INFO(sbh);
1669
1670 return (si->sb.buscoretype);
1671 }
1672
1673 /* return bus core revision */
1674 uint sb_buscorerev(sb_t * sbh)
1675 {
1676 sb_info_t *si;
1677 si = SB_INFO(sbh);
1678
1679 return (si->sb.buscorerev);
1680 }
1681
1682 /* return list of found cores */
1683 uint sb_corelist(sb_t * sbh, uint coreid[])
1684 {
1685 sb_info_t *si;
1686
1687 si = SB_INFO(sbh);
1688
1689 bcopy((uchar *) si->coreid, (uchar *) coreid,
1690 (si->numcores * sizeof(uint)));
1691 return (si->numcores);
1692 }
1693
1694 /* return current register mapping */
1695 void *sb_coreregs(sb_t * sbh)
1696 {
1697 sb_info_t *si;
1698
1699 si = SB_INFO(sbh);
1700 ASSERT(GOODREGS(si->curmap));
1701
1702 return (si->curmap);
1703 }
1704
1705 #if defined(BCMDBG_ASSERT)
1706 /* traverse all cores to find and clear source of serror */
1707 static void sb_serr_clear(sb_info_t * si)
1708 {
1709 sbconfig_t *sb;
1710 uint origidx;
1711 uint i, intr_val = 0;
1712 void *corereg = NULL;
1713
1714 INTR_OFF(si, intr_val);
1715 origidx = sb_coreidx(&si->sb);
1716
1717 for (i = 0; i < si->numcores; i++) {
1718 corereg = sb_setcoreidx(&si->sb, i);
1719 if (NULL != corereg) {
1720 sb = REGS2SB(corereg);
1721 if ((R_SBREG(si, &sb->sbtmstatehigh)) & SBTMH_SERR) {
1722 AND_SBREG(si, &sb->sbtmstatehigh, ~SBTMH_SERR);
1723 SB_ERROR(("sb_serr_clear: SError at core 0x%x\n", sb_coreid(&si->sb)));
1724 }
1725 }
1726 }
1727
1728 sb_setcoreidx(&si->sb, origidx);
1729 INTR_RESTORE(si, intr_val);
1730 }
1731
1732 /*
1733 * Check if any inband, outband or timeout errors has happened and clear them.
1734 * Must be called with chip clk on !
1735 */
1736 bool sb_taclear(sb_t * sbh)
1737 {
1738 sb_info_t *si;
1739 sbconfig_t *sb;
1740 uint origidx;
1741 uint intr_val = 0;
1742 bool rc = FALSE;
1743 uint32 inband = 0, serror = 0, timeout = 0;
1744 void *corereg = NULL;
1745 volatile uint32 imstate, tmstate;
1746
1747 si = SB_INFO(sbh);
1748
1749 if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
1750 volatile uint32 stcmd;
1751
1752 /* inband error is Target abort for PCI */
1753 stcmd =
1754 OSL_PCI_READ_CONFIG(si->osh, PCI_CFG_CMD, sizeof(uint32));
1755 inband = stcmd & PCI_CFG_CMD_STAT_TA;
1756 if (inband) {
1757 #ifdef BCMDBG
1758 SB_ERROR(("inband:\n"));
1759 sb_viewall((void *)si);
1760 #endif
1761 OSL_PCI_WRITE_CONFIG(si->osh, PCI_CFG_CMD,
1762 sizeof(uint32), stcmd);
1763 }
1764
1765 /* serror */
1766 stcmd =
1767 OSL_PCI_READ_CONFIG(si->osh, PCI_INT_STATUS,
1768 sizeof(uint32));
1769 serror = stcmd & PCI_SBIM_STATUS_SERR;
1770 if (serror) {
1771 #ifdef BCMDBG
1772 SB_ERROR(("serror:\n"));
1773 sb_viewall((void *)si);
1774 #endif
1775 sb_serr_clear(si);
1776 OSL_PCI_WRITE_CONFIG(si->osh, PCI_INT_STATUS,
1777 sizeof(uint32), stcmd);
1778 }
1779
1780 /* timeout */
1781 imstate = sb_corereg(sbh, si->sb.buscoreidx,
1782 SBCONFIGOFF + OFFSETOF(sbconfig_t,
1783 sbimstate), 0, 0);
1784 if ((imstate != 0xffffffff) && (imstate & (SBIM_IBE | SBIM_TO))) {
1785 sb_corereg(sbh, si->sb.buscoreidx,
1786 SBCONFIGOFF + OFFSETOF(sbconfig_t,
1787 sbimstate), ~0,
1788 (imstate & ~(SBIM_IBE | SBIM_TO)));
1789 /* inband = imstate & SBIM_IBE; same as TA above */
1790 timeout = imstate & SBIM_TO;
1791 if (timeout) {
1792 #ifdef BCMDBG
1793 SB_ERROR(("timeout:\n"));
1794 sb_viewall((void *)si);
1795 #endif
1796 }
1797 }
1798
1799 if (inband) {
1800 /* dump errlog for sonics >= 2.3 */
1801 if (si->sb.sonicsrev == SONICS_2_2) ;
1802 else {
1803 uint32 imerrlog, imerrloga;
1804 imerrlog =
1805 sb_corereg(sbh, si->sb.buscoreidx,
1806 SBIMERRLOG, 0, 0);
1807 if (imerrlog & SBTMEL_EC) {
1808 imerrloga =
1809 sb_corereg(sbh, si->sb.buscoreidx,
1810 SBIMERRLOGA, 0, 0);
1811 /* clear errlog */
1812 sb_corereg(sbh, si->sb.buscoreidx,
1813 SBIMERRLOG, ~0, 0);
1814 SB_ERROR(("sb_taclear: ImErrLog 0x%x, ImErrLogA 0x%x\n", imerrlog, imerrloga));
1815 }
1816 }
1817 }
1818
1819 } else if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
1820
1821 INTR_OFF(si, intr_val);
1822 origidx = sb_coreidx(sbh);
1823
1824 corereg = sb_setcore(sbh, SB_PCMCIA, 0);
1825 if (NULL != corereg) {
1826 sb = REGS2SB(corereg);
1827
1828 imstate = R_SBREG(si, &sb->sbimstate);
1829 /* handle surprise removal */
1830 if ((imstate != 0xffffffff)
1831 && (imstate & (SBIM_IBE | SBIM_TO))) {
1832 AND_SBREG(si, &sb->sbimstate,
1833 ~(SBIM_IBE | SBIM_TO));
1834 inband = imstate & SBIM_IBE;
1835 timeout = imstate & SBIM_TO;
1836 }
1837 tmstate = R_SBREG(si, &sb->sbtmstatehigh);
1838 if ((tmstate != 0xffffffff)
1839 && (tmstate & SBTMH_INT_STATUS)) {
1840 if (!inband) {
1841 serror = 1;
1842 sb_serr_clear(si);
1843 }
1844 OR_SBREG(si, &sb->sbtmstatelow, SBTML_INT_ACK);
1845 AND_SBREG(si, &sb->sbtmstatelow,
1846 ~SBTML_INT_ACK);
1847 }
1848 }
1849 sb_setcoreidx(sbh, origidx);
1850 INTR_RESTORE(si, intr_val);
1851
1852 }
1853
1854 if (inband | timeout | serror) {
1855 rc = TRUE;
1856 SB_ERROR(("sb_taclear: inband 0x%x, serror 0x%x, timeout 0x%x!\n", inband, serror, timeout));
1857 }
1858
1859 return (rc);
1860 }
1861 #endif /* BCMDBG */
1862
1863 /* do buffered registers update */
1864 void sb_commit(sb_t * sbh)
1865 {
1866 sb_info_t *si;
1867 uint origidx;
1868 uint intr_val = 0;
1869
1870 si = SB_INFO(sbh);
1871
1872 origidx = si->curidx;
1873 ASSERT(GOODIDX(origidx));
1874
1875 INTR_OFF(si, intr_val);
1876
1877 /* switch over to chipcommon core if there is one, else use pci */
1878 if (si->sb.ccrev != NOREV) {
1879 chipcregs_t *ccregs = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0);
1880
1881 /* do the buffer registers update */
1882 W_REG(si->osh, &ccregs->broadcastaddress, SB_COMMIT);
1883 W_REG(si->osh, &ccregs->broadcastdata, 0x0);
1884 } else if (PCI(si)) {
1885 sbpciregs_t *pciregs =
1886 (sbpciregs_t *) sb_setcore(sbh, SB_PCI, 0);
1887
1888 /* do the buffer registers update */
1889 W_REG(si->osh, &pciregs->bcastaddr, SB_COMMIT);
1890 W_REG(si->osh, &pciregs->bcastdata, 0x0);
1891 } else
1892 ASSERT(0);
1893
1894 /* restore core index */
1895 sb_setcoreidx(sbh, origidx);
1896 INTR_RESTORE(si, intr_val);
1897 }
1898
1899 /* reset and re-enable a core
1900 * inputs:
1901 * bits - core specific bits that are set during and after reset sequence
1902 * resetbits - core specific bits that are set only during reset sequence
1903 */
1904 void sb_core_reset(sb_t * sbh, uint32 bits, uint32 resetbits)
1905 {
1906 sb_info_t *si;
1907 sbconfig_t *sb;
1908 volatile uint32 dummy;
1909
1910 si = SB_INFO(sbh);
1911 ASSERT(GOODREGS(si->curmap));
1912 sb = REGS2SB(si->curmap);
1913
1914 /*
1915 * Must do the disable sequence first to work for arbitrary current core state.
1916 */
1917 sb_core_disable(sbh, (bits | resetbits));
1918
1919 /*
1920 * Now do the initialization sequence.
1921 */
1922
1923 /* set reset while enabling the clock and forcing them on throughout the core */
1924 W_SBREG(si, &sb->sbtmstatelow,
1925 (SBTML_FGC | SBTML_CLK | SBTML_RESET | bits | resetbits));
1926 dummy = R_SBREG(si, &sb->sbtmstatelow);
1927 OSL_DELAY(1);
1928
1929 if (R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_SERR) {
1930 W_SBREG(si, &sb->sbtmstatehigh, 0);
1931 }
1932 if ((dummy = R_SBREG(si, &sb->sbimstate)) & (SBIM_IBE | SBIM_TO)) {
1933 AND_SBREG(si, &sb->sbimstate, ~(SBIM_IBE | SBIM_TO));
1934 }
1935
1936 /* clear reset and allow it to propagate throughout the core */
1937 W_SBREG(si, &sb->sbtmstatelow, (SBTML_FGC | SBTML_CLK | bits));
1938 dummy = R_SBREG(si, &sb->sbtmstatelow);
1939 OSL_DELAY(1);
1940
1941 /* leave clock enabled */
1942 W_SBREG(si, &sb->sbtmstatelow, (SBTML_CLK | bits));
1943 dummy = R_SBREG(si, &sb->sbtmstatelow);
1944 OSL_DELAY(1);
1945 }
1946
1947 void sb_core_tofixup(sb_t * sbh)
1948 {
1949 sb_info_t *si;
1950 sbconfig_t *sb;
1951
1952 si = SB_INFO(sbh);
1953
1954 if ((BUSTYPE(si->sb.bustype) != PCI_BUS) || PCIE(si) ||
1955 (PCI(si) && (si->sb.buscorerev >= 5)))
1956 return;
1957
1958 ASSERT(GOODREGS(si->curmap));
1959 sb = REGS2SB(si->curmap);
1960
1961 if (BUSTYPE(si->sb.bustype) == SB_BUS) {
1962 SET_SBREG(si, &sb->sbimconfiglow,
1963 SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
1964 (0x5 << SBIMCL_RTO_SHIFT) | 0x3);
1965 } else {
1966 if (sb_coreid(sbh) == SB_PCI) {
1967 SET_SBREG(si, &sb->sbimconfiglow,
1968 SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
1969 (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
1970 } else {
1971 SET_SBREG(si, &sb->sbimconfiglow,
1972 (SBIMCL_RTO_MASK | SBIMCL_STO_MASK), 0);
1973 }
1974 }
1975
1976 sb_commit(sbh);
1977 }
1978
1979 /*
1980 * Set the initiator timeout for the "master core".
1981 * The master core is defined to be the core in control
1982 * of the chip and so it issues accesses to non-memory
1983 * locations (Because of dma *any* core can access memeory).
1984 *
1985 * The routine uses the bus to decide who is the master:
1986 * SB_BUS => mips
1987 * JTAG_BUS => chipc
1988 * PCI_BUS => pci or pcie
1989 * PCMCIA_BUS => pcmcia
1990 * SDIO_BUS => pcmcia
1991 *
1992 * This routine exists so callers can disable initiator
1993 * timeouts so accesses to very slow devices like otp
1994 * won't cause an abort. The routine allows arbitrary
1995 * settings of the service and request timeouts, though.
1996 *
1997 * Returns the timeout state before changing it or -1
1998 * on error.
1999 */
2000
2001 #define TO_MASK (SBIMCL_RTO_MASK | SBIMCL_STO_MASK)
2002
2003 uint32 sb_set_initiator_to(sb_t * sbh, uint32 to, uint idx)
2004 {
2005 sb_info_t *si;
2006 uint origidx;
2007 uint intr_val = 0;
2008 uint32 tmp, ret = 0xffffffff;
2009 sbconfig_t *sb;
2010
2011 si = SB_INFO(sbh);
2012
2013 if ((to & ~TO_MASK) != 0)
2014 return ret;
2015
2016 /* Figure out the master core */
2017 if (idx == BADIDX) {
2018 switch (BUSTYPE(si->sb.bustype)) {
2019 case PCI_BUS:
2020 idx = si->sb.buscoreidx;
2021 break;
2022 case JTAG_BUS:
2023 idx = SB_CC_IDX;
2024 break;
2025 case PCMCIA_BUS:
2026 case SDIO_BUS:
2027 idx = sb_findcoreidx(sbh, SB_PCMCIA, 0);
2028 break;
2029 case SB_BUS:
2030 if ((idx = sb_findcoreidx(sbh, SB_MIPS33, 0)) == BADIDX)
2031 idx = sb_findcoreidx(sbh, SB_MIPS, 0);
2032 break;
2033 default:
2034 ASSERT(0);
2035 }
2036 if (idx == BADIDX)
2037 return ret;
2038 }
2039
2040 INTR_OFF(si, intr_val);
2041 origidx = sb_coreidx(sbh);
2042
2043 sb = REGS2SB(sb_setcoreidx(sbh, idx));
2044
2045 tmp = R_SBREG(si, &sb->sbimconfiglow);
2046 ret = tmp & TO_MASK;
2047 W_SBREG(si, &sb->sbimconfiglow, (tmp & ~TO_MASK) | to);
2048
2049 sb_commit(sbh);
2050 sb_setcoreidx(sbh, origidx);
2051 INTR_RESTORE(si, intr_val);
2052 return ret;
2053 }
2054
2055 void sb_core_disable(sb_t * sbh, uint32 bits)
2056 {
2057 sb_info_t *si;
2058 volatile uint32 dummy;
2059 uint32 rej;
2060 sbconfig_t *sb;
2061
2062 si = SB_INFO(sbh);
2063
2064 ASSERT(GOODREGS(si->curmap));
2065 sb = REGS2SB(si->curmap);
2066
2067 /* if core is already in reset, just return */
2068 if (R_SBREG(si, &sb->sbtmstatelow) & SBTML_RESET)
2069 return;
2070
2071 /* reject value changed between sonics 2.2 and 2.3 */
2072 if (si->sb.sonicsrev == SONICS_2_2)
2073 rej = (1 << SBTML_REJ_SHIFT);
2074 else
2075 rej = (2 << SBTML_REJ_SHIFT);
2076
2077 /* if clocks are not enabled, put into reset and return */
2078 if ((R_SBREG(si, &sb->sbtmstatelow) & SBTML_CLK) == 0)
2079 goto disable;
2080
2081 /* set target reject and spin until busy is clear (preserve core-specific bits) */
2082 OR_SBREG(si, &sb->sbtmstatelow, rej);
2083 dummy = R_SBREG(si, &sb->sbtmstatelow);
2084 OSL_DELAY(1);
2085 SPINWAIT((R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_BUSY), 100000);
2086 if (R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_BUSY)
2087 SB_ERROR(("%s: target state still busy\n", __FUNCTION__));
2088
2089 if (R_SBREG(si, &sb->sbidlow) & SBIDL_INIT) {
2090 OR_SBREG(si, &sb->sbimstate, SBIM_RJ);
2091 dummy = R_SBREG(si, &sb->sbimstate);
2092 OSL_DELAY(1);
2093 SPINWAIT((R_SBREG(si, &sb->sbimstate) & SBIM_BY), 100000);
2094 }
2095
2096 /* set reset and reject while enabling the clocks */
2097 W_SBREG(si, &sb->sbtmstatelow,
2098 (bits | SBTML_FGC | SBTML_CLK | rej | SBTML_RESET));
2099 dummy = R_SBREG(si, &sb->sbtmstatelow);
2100 OSL_DELAY(10);
2101
2102 /* don't forget to clear the initiator reject bit */
2103 if (R_SBREG(si, &sb->sbidlow) & SBIDL_INIT)
2104 AND_SBREG(si, &sb->sbimstate, ~SBIM_RJ);
2105
2106 disable:
2107 /* leave reset and reject asserted */
2108 W_SBREG(si, &sb->sbtmstatelow, (bits | rej | SBTML_RESET));
2109 OSL_DELAY(1);
2110 }
2111
2112 /* set chip watchdog reset timer to fire in 'ticks' backplane cycles */
2113 void sb_watchdog(sb_t * sbh, uint ticks)
2114 {
2115 sb_info_t *si = SB_INFO(sbh);
2116
2117 /* make sure we come up in fast clock mode; or if clearing, clear clock */
2118 if (ticks)
2119 sb_clkctl_clk(sbh, CLK_FAST);
2120 else
2121 sb_clkctl_clk(sbh, CLK_DYNAMIC);
2122
2123 if (sbh->chip == BCM4328_CHIP_ID && ticks != 0)
2124 sb_corereg(sbh, SB_CC_IDX, OFFSETOF(chipcregs_t, min_res_mask),
2125 PMURES_BIT(RES4328_ROM_SWITCH),
2126 PMURES_BIT(RES4328_ROM_SWITCH));
2127
2128 /* instant NMI */
2129 switch (si->gpioid) {
2130 case SB_CC:
2131 sb_corereg(sbh, SB_CC_IDX, OFFSETOF(chipcregs_t, watchdog), ~0,
2132 ticks);
2133 break;
2134 case SB_EXTIF:
2135 sb_corereg(sbh, si->gpioidx, OFFSETOF(extifregs_t, watchdog),
2136 ~0, ticks);
2137 break;
2138 }
2139 }
2140
2141 /* initialize the pcmcia core */
2142 void sb_pcmcia_init(sb_t * sbh)
2143 {
2144 sb_info_t *si;
2145 uint8 cor = 0;
2146
2147 si = SB_INFO(sbh);
2148
2149 /* enable d11 mac interrupts */
2150 OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_FCR0 + PCMCIA_COR, &cor, 1);
2151 cor |= COR_IRQEN | COR_FUNEN;
2152 OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_FCR0 + PCMCIA_COR, &cor, 1);
2153
2154 }
2155
2156 void BCMINITFN(sb_pci_up) (sb_t * sbh) {
2157 sb_info_t *si = SB_INFO(sbh);
2158 if (si->gpioid == SB_EXTIF)
2159 return;
2160
2161 /* if not pci bus, we're done */
2162 if (BUSTYPE(si->sb.bustype) != PCI_BUS)
2163 return;
2164
2165 if (FORCEHT_WAR32414(si))
2166 sb_war32414_forceHT(sbh, 1);
2167
2168 if (PCIE_ASPMWARS(si) || si->sb.pr42780)
2169 sb_pcieclkreq(sbh, 1, 0);
2170
2171 if (PCIE(si) &&
2172 (((si->sb.chip == BCM4311_CHIP_ID) && (si->sb.chiprev == 2)) ||
2173 ((si->sb.chip == BCM4312_CHIP_ID) && (si->sb.chiprev == 0))))
2174 sb_set_initiator_to((void *)si, 0x3,
2175 sb_findcoreidx((void *)si, SB_D11, 0));
2176 }
2177
2178 /* Unconfigure and/or apply various WARs when system is going to sleep mode */
2179 void BCMUNINITFN(sb_pci_sleep) (sb_t * sbh) {
2180 sb_info_t *si = SB_INFO(sbh);
2181 if (si->gpioid == SB_EXTIF)
2182 return;
2183 uint32 w;
2184
2185 /* if not pci bus, we're done */
2186 if (!PCIE(si) || !PCIE_ASPMWARS(si))
2187 return;
2188
2189 w = OSL_PCI_READ_CONFIG(si->osh, si->pciecap_lcreg_offset,
2190 sizeof(uint32));
2191 w &= ~PCIE_CAP_LCREG_ASPML1;
2192 OSL_PCI_WRITE_CONFIG(si->osh, si->pciecap_lcreg_offset, sizeof(uint32),
2193 w);
2194 }
2195
2196 /* Unconfigure and/or apply various WARs when going down */
2197 void BCMINITFN(sb_pci_down) (sb_t * sbh) {
2198 sb_info_t *si = SB_INFO(sbh);
2199 if (si->gpioid == SB_EXTIF)
2200 return;
2201
2202 /* if not pci bus, we're done */
2203 if (BUSTYPE(si->sb.bustype) != PCI_BUS)
2204 return;
2205
2206 if (FORCEHT_WAR32414(si))
2207 sb_war32414_forceHT(sbh, 0);
2208
2209 if (si->pr42767_war) {
2210 sb_pcieclkreq(sbh, 1, 1);
2211 si->pr42767_war = FALSE;
2212 } else if (si->sb.pr42780) {
2213 sb_pcieclkreq(sbh, 1, 1);
2214 }
2215 }
2216
2217 static void BCMINITFN(sb_war42767_clkreq) (sb_t * sbh) {
2218 sbpcieregs_t *pcieregs;
2219 uint16 val16, *reg16;
2220 sb_info_t *si;
2221
2222 si = SB_INFO(sbh);
2223
2224 /* if not pcie bus, we're done */
2225 if (!PCIE(si) || !PCIE_ASPMWARS(si))
2226 return;
2227
2228 pcieregs = (sbpcieregs_t *) sb_setcoreidx(sbh, si->sb.buscoreidx);
2229 reg16 = &pcieregs->sprom[SRSH_CLKREQ_OFFSET];
2230 val16 = R_REG(si->osh, reg16);
2231 /* if clockreq is not advertized advertize it */
2232 if (!si->pcie_war_ovr) {
2233 val16 |= SRSH_CLKREQ_ENB;
2234 si->pr42767_war = TRUE;
2235
2236 si->sb.pr42780 = TRUE;
2237 } else
2238 val16 &= ~SRSH_CLKREQ_ENB;
2239 W_REG(si->osh, reg16, val16);
2240 }
2241
2242 static void BCMINITFN(sb_war42767) (sb_t * sbh) {
2243 uint32 w = 0;
2244 sb_info_t *si;
2245
2246 si = SB_INFO(sbh);
2247
2248 /* if not pcie bus, we're done */
2249 if (!PCIE(si) || !PCIE_ASPMWARS(si))
2250 return;
2251
2252 sb_pcie_mdioread(si, MDIODATA_DEV_PLL, SERDES_PLL_CTRL, &w);
2253 if (w & PLL_CTRL_FREQDET_EN) {
2254 w &= ~PLL_CTRL_FREQDET_EN;
2255 sb_pcie_mdiowrite(si, MDIODATA_DEV_PLL, SERDES_PLL_CTRL, w);
2256 }
2257 }
2258
2259 /*
2260 * Configure the pci core for pci client (NIC) action
2261 * coremask is the bitvec of cores by index to be enabled.
2262 */
2263 void BCMINITFN(sb_pci_setup) (sb_t * sbh, uint coremask) {
2264 sb_info_t *si;
2265 sbconfig_t *sb;
2266 sbpciregs_t *pciregs;
2267 uint32 sbflag;
2268 uint32 w;
2269 uint idx;
2270
2271 si = SB_INFO(sbh);
2272
2273 /* if not pci bus, we're done */
2274 if (BUSTYPE(si->sb.bustype) != PCI_BUS)
2275 return;
2276
2277 ASSERT(PCI(si) || PCIE(si));
2278 ASSERT(si->sb.buscoreidx != BADIDX);
2279
2280 /* get current core index */
2281 idx = si->curidx;
2282
2283 /* we interrupt on this backplane flag number */
2284 ASSERT(GOODREGS(si->curmap));
2285 sb = REGS2SB(si->curmap);
2286 sbflag = R_SBREG(si, &sb->sbtpsflag) & SBTPS_NUM0_MASK;
2287
2288 /* switch over to pci core */
2289 pciregs = (sbpciregs_t *) sb_setcoreidx(sbh, si->sb.buscoreidx);
2290 sb = REGS2SB(pciregs);
2291
2292 /*
2293 * Enable sb->pci interrupts. Assume
2294 * PCI rev 2.3 support was added in pci core rev 6 and things changed..
2295 */
2296 if (PCIE(si) || (PCI(si) && ((si->sb.buscorerev) >= 6))) {
2297 /* pci config write to set this core bit in PCIIntMask */
2298 w = OSL_PCI_READ_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32));
2299 w |= (coremask << PCI_SBIM_SHIFT);
2300 OSL_PCI_WRITE_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32), w);
2301 } else {
2302 /* set sbintvec bit for our flag number */
2303 OR_SBREG(si, &sb->sbintvec, (1 << sbflag));
2304 }
2305
2306 if (PCI(si)) {
2307 OR_REG(si->osh, &pciregs->sbtopci2,
2308 (SBTOPCI_PREF | SBTOPCI_BURST));
2309 if (si->sb.buscorerev >= 11)
2310 OR_REG(si->osh, &pciregs->sbtopci2,
2311 SBTOPCI_RC_READMULTI);
2312 if (si->sb.buscorerev < 5) {
2313 SET_SBREG(si, &sb->sbimconfiglow,
2314 SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
2315 (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
2316 sb_commit(sbh);
2317 }
2318 }
2319
2320 /* PCIE workarounds */
2321 if (PCIE(si)) {
2322 if ((si->sb.buscorerev == 0) || (si->sb.buscorerev == 1)) {
2323 w = sb_pcie_readreg((void *)(uintptr) sbh,
2324 (void *)(uintptr) PCIE_PCIEREGS,
2325 PCIE_TLP_WORKAROUNDSREG);
2326 w |= 0x8;
2327 sb_pcie_writereg((void *)(uintptr) sbh,
2328 (void *)(uintptr) PCIE_PCIEREGS,
2329 PCIE_TLP_WORKAROUNDSREG, w);
2330 }
2331
2332 if (si->sb.buscorerev == 1) {
2333 w = sb_pcie_readreg((void *)(uintptr) sbh,
2334 (void *)(uintptr) PCIE_PCIEREGS,
2335 PCIE_DLLP_LCREG);
2336 w |= (0x40);
2337 sb_pcie_writereg((void *)(uintptr) sbh,
2338 (void *)(uintptr) PCIE_PCIEREGS,
2339 PCIE_DLLP_LCREG, w);
2340 }
2341
2342 if (si->sb.buscorerev == 0)
2343 sb_war30841(si);
2344
2345 if ((si->sb.buscorerev >= 3) && (si->sb.buscorerev <= 5)) {
2346 w = sb_pcie_readreg((void *)(uintptr) sbh,
2347 (void *)(uintptr) PCIE_PCIEREGS,
2348 PCIE_DLLP_PMTHRESHREG);
2349 w &= ~(PCIE_L1THRESHOLDTIME_MASK);
2350 w |= (PCIE_L1THRESHOLD_WARVAL <<
2351 PCIE_L1THRESHOLDTIME_SHIFT);
2352 sb_pcie_writereg((void *)(uintptr) sbh,
2353 (void *)(uintptr) PCIE_PCIEREGS,
2354 PCIE_DLLP_PMTHRESHREG, w);
2355
2356 sb_war43448(sbh);
2357
2358 sb_war42767(sbh);
2359
2360 sb_war43448_aspm(sbh);
2361 sb_war42767_clkreq(sbh);
2362 }
2363 }
2364
2365 /* switch back to previous core */
2366 sb_setcoreidx(sbh, idx);
2367 }
2368
2369 uint32 sb_base(uint32 admatch)
2370 {
2371 uint32 base;
2372 uint type;
2373
2374 type = admatch & SBAM_TYPE_MASK;
2375 ASSERT(type < 3);
2376
2377 base = 0;
2378
2379 if (type == 0) {
2380 base = admatch & SBAM_BASE0_MASK;
2381 } else if (type == 1) {
2382 ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
2383 base = admatch & SBAM_BASE1_MASK;
2384 } else if (type == 2) {
2385 ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
2386 base = admatch & SBAM_BASE2_MASK;
2387 }
2388
2389 return (base);
2390 }
2391
2392 uint32 sb_size(uint32 admatch)
2393 {
2394 uint32 size;
2395 uint type;
2396
2397 type = admatch & SBAM_TYPE_MASK;
2398 ASSERT(type < 3);
2399
2400 size = 0;
2401
2402 if (type == 0) {
2403 size =
2404 1 << (((admatch & SBAM_ADINT0_MASK) >> SBAM_ADINT0_SHIFT) +
2405 1);
2406 } else if (type == 1) {
2407 ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
2408 size =
2409 1 << (((admatch & SBAM_ADINT1_MASK) >> SBAM_ADINT1_SHIFT) +
2410 1);
2411 } else if (type == 2) {
2412 ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
2413 size =
2414 1 << (((admatch & SBAM_ADINT2_MASK) >> SBAM_ADINT2_SHIFT) +
2415 1);
2416 }
2417
2418 return (size);
2419 }
2420
2421 /* return the core-type instantiation # of the current core */
2422 uint sb_coreunit(sb_t * sbh)
2423 {
2424 sb_info_t *si;
2425 uint idx;
2426 uint coreid;
2427 uint coreunit;
2428 uint i;
2429
2430 si = SB_INFO(sbh);
2431 coreunit = 0;
2432
2433 idx = si->curidx;
2434
2435 ASSERT(GOODREGS(si->curmap));
2436 coreid = sb_coreid(sbh);
2437
2438 /* count the cores of our type */
2439 for (i = 0; i < idx; i++)
2440 if (si->coreid[i] == coreid)
2441 coreunit++;
2442
2443 return (coreunit);
2444 }
2445
2446 static uint32 BCMINITFN(factor6) (uint32 x) {
2447 switch (x) {
2448 case CC_F6_2:
2449 return 2;
2450 case CC_F6_3:
2451 return 3;
2452 case CC_F6_4:
2453 return 4;
2454 case CC_F6_5:
2455 return 5;
2456 case CC_F6_6:
2457 return 6;
2458 case CC_F6_7:
2459 return 7;
2460 default:
2461 return 0;
2462 }
2463 }
2464
2465 /* calculate the speed the SB would run at given a set of clockcontrol values */
2466 uint32 BCMINITFN(sb_clock_rate) (uint32 pll_type, uint32 n, uint32 m) {
2467 uint32 n1, n2, clock, m1, m2, m3, mc;
2468
2469 n1 = n & CN_N1_MASK;
2470 n2 = (n & CN_N2_MASK) >> CN_N2_SHIFT;
2471
2472 if (pll_type == PLL_TYPE6) {
2473 if (m & CC_T6_MMASK)
2474 return CC_T6_M1;
2475 else
2476 return CC_T6_M0;
2477 } else if ((pll_type == PLL_TYPE1) ||
2478 (pll_type == PLL_TYPE3) ||
2479 (pll_type == PLL_TYPE4) || (pll_type == PLL_TYPE7)) {
2480 n1 = factor6(n1);
2481 n2 += CC_F5_BIAS;
2482 } else if (pll_type == PLL_TYPE2) {
2483 n1 += CC_T2_BIAS;
2484 n2 += CC_T2_BIAS;
2485 ASSERT((n1 >= 2) && (n1 <= 7));
2486 ASSERT((n2 >= 5) && (n2 <= 23));
2487 } else if (pll_type == PLL_TYPE5) {
2488 return (100000000);
2489 } else
2490 ASSERT(0);
2491 /* PLL types 3 and 7 use BASE2 (25Mhz) */
2492 if ((pll_type == PLL_TYPE3) || (pll_type == PLL_TYPE7)) {
2493 clock = CC_CLOCK_BASE2 * n1 * n2;
2494 } else
2495 clock = CC_CLOCK_BASE1 * n1 * n2;
2496
2497 if (clock == 0)
2498 return 0;
2499
2500 m1 = m & CC_M1_MASK;
2501 m2 = (m & CC_M2_MASK) >> CC_M2_SHIFT;
2502 m3 = (m & CC_M3_MASK) >> CC_M3_SHIFT;
2503 mc = (m & CC_MC_MASK) >> CC_MC_SHIFT;
2504
2505 if ((pll_type == PLL_TYPE1) ||
2506 (pll_type == PLL_TYPE3) ||
2507 (pll_type == PLL_TYPE4) || (pll_type == PLL_TYPE7)) {
2508 m1 = factor6(m1);
2509 if ((pll_type == PLL_TYPE1) || (pll_type == PLL_TYPE3))
2510 m2 += CC_F5_BIAS;
2511 else
2512 m2 = factor6(m2);
2513 m3 = factor6(m3);
2514
2515 switch (mc) {
2516 case CC_MC_BYPASS:
2517 return (clock);
2518 case CC_MC_M1:
2519 return (clock / m1);
2520 case CC_MC_M1M2:
2521 return (clock / (m1 * m2));
2522 case CC_MC_M1M2M3:
2523 return (clock / (m1 * m2 * m3));
2524 case CC_MC_M1M3:
2525 return (clock / (m1 * m3));
2526 default:
2527 return (0);
2528 }
2529 } else {
2530 ASSERT(pll_type == PLL_TYPE2);
2531
2532 m1 += CC_T2_BIAS;
2533 m2 += CC_T2M2_BIAS;
2534 m3 += CC_T2_BIAS;
2535 ASSERT((m1 >= 2) && (m1 <= 7));
2536 ASSERT((m2 >= 3) && (m2 <= 10));
2537 ASSERT((m3 >= 2) && (m3 <= 7));
2538
2539 if ((mc & CC_T2MC_M1BYP) == 0)
2540 clock /= m1;
2541 if ((mc & CC_T2MC_M2BYP) == 0)
2542 clock /= m2;
2543 if ((mc & CC_T2MC_M3BYP) == 0)
2544 clock /= m3;
2545
2546 return (clock);
2547 }
2548 }
2549
2550 /* returns the current speed the SB is running at */
2551 uint32 BCMINITFN(sb_clock) (sb_t * sbh) {
2552 sb_info_t *si;
2553 extifregs_t *eir;
2554 chipcregs_t *cc;
2555 uint32 n, m;
2556 uint idx;
2557 uint32 cap, pll_type, rate;
2558 uint intr_val = 0;
2559
2560 si = SB_INFO(sbh);
2561 idx = si->curidx;
2562 pll_type = PLL_TYPE1;
2563
2564 INTR_OFF(si, intr_val);
2565
2566 /* switch to extif or chipc core */
2567 if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
2568 n = R_REG(si->osh, &eir->clockcontrol_n);
2569 m = R_REG(si->osh, &eir->clockcontrol_sb);
2570 } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
2571
2572 cap = R_REG(si->osh, &cc->capabilities);
2573
2574 if (cap & CC_CAP_PMU) {
2575
2576 if (sb_chip(sbh) == BCM5354_CHIP_ID) {
2577 /* 5354 has a constant sb clock of 120MHz */
2578 rate = 120000000;
2579 goto end;
2580 } else
2581 if (sb_chip(sbh) == BCM4328_CHIP_ID) {
2582 rate = 80000000;
2583 goto end;
2584 } else
2585 ASSERT(0);
2586 }
2587
2588 pll_type = cap & CC_CAP_PLL_MASK;
2589 if (pll_type == PLL_NONE) {
2590 INTR_RESTORE(si, intr_val);
2591 return 80000000;
2592 }
2593 n = R_REG(si->osh, &cc->clockcontrol_n);
2594 if (pll_type == PLL_TYPE6)
2595 m = R_REG(si->osh, &cc->clockcontrol_m3);
2596 else if (pll_type == PLL_TYPE3
2597 && !(BCMINIT(sb_chip) (sbh) == 0x5365))
2598 m = R_REG(si->osh, &cc->clockcontrol_m2);
2599 else
2600 m = R_REG(si->osh, &cc->clockcontrol_sb);
2601 } else {
2602 INTR_RESTORE(si, intr_val);
2603 return 0;
2604 }
2605
2606 /* calculate rate */
2607 if (BCMINIT(sb_chip) (sbh) == 0x5365)
2608 rate = 100000000;
2609 else {
2610 rate = sb_clock_rate(pll_type, n, m);
2611
2612 if (pll_type == PLL_TYPE3)
2613 rate = rate / 2;
2614 }
2615
2616 end:
2617 /* switch back to previous core */
2618 sb_setcoreidx(sbh, idx);
2619
2620 INTR_RESTORE(si, intr_val);
2621
2622 return rate;
2623 }
2624
2625 uint32 BCMINITFN(sb_alp_clock) (sb_t * sbh) {
2626 uint32 clock = ALP_CLOCK;
2627
2628 if (sbh->cccaps & CC_CAP_PMU)
2629 clock = sb_pmu_alp_clock(sbh, sb_osh(sbh));
2630
2631 return clock;
2632 }
2633
2634 /* change logical "focus" to the gpio core for optimized access */
2635 void *sb_gpiosetcore(sb_t * sbh)
2636 {
2637 sb_info_t *si;
2638
2639 si = SB_INFO(sbh);
2640
2641 return (sb_setcoreidx(sbh, si->gpioidx));
2642 }
2643
2644 /* mask&set gpiocontrol bits */
2645 uint32 sb_gpiocontrol(sb_t * sbh, uint32 mask, uint32 val, uint8 priority)
2646 {
2647 sb_info_t *si;
2648 uint regoff;
2649
2650 si = SB_INFO(sbh);
2651 regoff = 0;
2652
2653 /* gpios could be shared on router platforms
2654 * ignore reservation if it's high priority (e.g., test apps)
2655 */
2656 if ((priority != GPIO_HI_PRIORITY) &&
2657 (BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
2658 mask = priority ? (sb_gpioreservation & mask) :
2659 ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
2660 val &= mask;
2661 }
2662
2663 switch (si->gpioid) {
2664 case SB_CC:
2665 regoff = OFFSETOF(chipcregs_t, gpiocontrol);
2666 break;
2667
2668 case SB_PCI:
2669 regoff = OFFSETOF(sbpciregs_t, gpiocontrol);
2670 break;
2671
2672 case SB_EXTIF:
2673 return (0);
2674 }
2675
2676 return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
2677 }
2678
2679 /* mask&set gpio output enable bits */
2680 uint32 sb_gpioouten(sb_t * sbh, uint32 mask, uint32 val, uint8 priority)
2681 {
2682 sb_info_t *si;
2683 uint regoff;
2684
2685 si = SB_INFO(sbh);
2686 regoff = 0;
2687
2688 /* gpios could be shared on router platforms
2689 * ignore reservation if it's high priority (e.g., test apps)
2690 */
2691 if ((priority != GPIO_HI_PRIORITY) &&
2692 (BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
2693 mask = priority ? (sb_gpioreservation & mask) :
2694 ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
2695 val &= mask;
2696 }
2697
2698 switch (si->gpioid) {
2699 case SB_CC:
2700 regoff = OFFSETOF(chipcregs_t, gpioouten);
2701 break;
2702
2703 case SB_PCI:
2704 regoff = OFFSETOF(sbpciregs_t, gpioouten);
2705 break;
2706
2707 case SB_EXTIF:
2708 regoff = OFFSETOF(extifregs_t, gpio[0].outen);
2709 break;
2710 }
2711
2712 return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
2713 }
2714
2715 /* mask&set gpio output bits */
2716 uint32 sb_gpioout(sb_t * sbh, uint32 mask, uint32 val, uint8 priority)
2717 {
2718 sb_info_t *si;
2719 uint regoff;
2720
2721 si = SB_INFO(sbh);
2722 regoff = 0;
2723
2724 /* gpios could be shared on router platforms
2725 * ignore reservation if it's high priority (e.g., test apps)
2726 */
2727 if ((priority != GPIO_HI_PRIORITY) &&
2728 (BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
2729 mask = priority ? (sb_gpioreservation & mask) :
2730 ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
2731 val &= mask;
2732 }
2733
2734 switch (si->gpioid) {
2735 case SB_CC:
2736 regoff = OFFSETOF(chipcregs_t, gpioout);
2737 break;
2738
2739 case SB_PCI:
2740 regoff = OFFSETOF(sbpciregs_t, gpioout);
2741 break;
2742
2743 case SB_EXTIF:
2744 regoff = OFFSETOF(extifregs_t, gpio[0].out);
2745 break;
2746 }
2747
2748 return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
2749 }
2750
2751 /* reserve one gpio */
2752 uint32 sb_gpioreserve(sb_t * sbh, uint32 gpio_bitmask, uint8 priority)
2753 {
2754 sb_info_t *si;
2755
2756 si = SB_INFO(sbh);
2757
2758 /* only cores on SB_BUS share GPIO's and only applcation users need to
2759 * reserve/release GPIO
2760 */
2761 if ((BUSTYPE(si->sb.bustype) != SB_BUS) || (!priority)) {
2762 ASSERT((BUSTYPE(si->sb.bustype) == SB_BUS) && (priority));
2763 return -1;
2764 }
2765 /* make sure only one bit is set */
2766 if ((!gpio_bitmask) || ((gpio_bitmask) & (gpio_bitmask - 1))) {
2767 ASSERT((gpio_bitmask)
2768 && !((gpio_bitmask) & (gpio_bitmask - 1)));
2769 return -1;
2770 }
2771
2772 /* already reserved */
2773 if (sb_gpioreservation & gpio_bitmask)
2774 return -1;
2775 /* set reservation */
2776 sb_gpioreservation |= gpio_bitmask;
2777
2778 return sb_gpioreservation;
2779 }
2780
2781 /* release one gpio */
2782 /*
2783 * releasing the gpio doesn't change the current value on the GPIO last write value
2784 * persists till some one overwrites it
2785 */
2786
2787 uint32 sb_gpiorelease(sb_t * sbh, uint32 gpio_bitmask, uint8 priority)
2788 {
2789 sb_info_t *si;
2790
2791 si = SB_INFO(sbh);
2792
2793 /* only cores on SB_BUS share GPIO's and only applcation users need to
2794 * reserve/release GPIO
2795 */
2796 if ((BUSTYPE(si->sb.bustype) != SB_BUS) || (!priority)) {
2797 ASSERT((BUSTYPE(si->sb.bustype) == SB_BUS) && (priority));
2798 return -1;
2799 }
2800 /* make sure only one bit is set */
2801 if ((!gpio_bitmask) || ((gpio_bitmask) & (gpio_bitmask - 1))) {
2802 ASSERT((gpio_bitmask)
2803 && !((gpio_bitmask) & (gpio_bitmask - 1)));
2804 return -1;
2805 }
2806
2807 /* already released */
2808 if (!(sb_gpioreservation & gpio_bitmask))
2809 return -1;
2810
2811 /* clear reservation */
2812 sb_gpioreservation &= ~gpio_bitmask;
2813
2814 return sb_gpioreservation;
2815 }
2816
2817 /* return the current gpioin register value */
2818 uint32 sb_gpioin(sb_t * sbh)
2819 {
2820 sb_info_t *si;
2821 uint regoff;
2822
2823 si = SB_INFO(sbh);
2824 regoff = 0;
2825
2826 switch (si->gpioid) {
2827 case SB_CC:
2828 regoff = OFFSETOF(chipcregs_t, gpioin);
2829 break;
2830
2831 case SB_PCI:
2832 regoff = OFFSETOF(sbpciregs_t, gpioin);
2833 break;
2834
2835 case SB_EXTIF:
2836 regoff = OFFSETOF(extifregs_t, gpioin);
2837 break;
2838 }
2839
2840 return (sb_corereg(sbh, si->gpioidx, regoff, 0, 0));
2841 }
2842
2843 /* mask&set gpio interrupt polarity bits */
2844 uint32 sb_gpiointpolarity(sb_t * sbh, uint32 mask, uint32 val, uint8 priority)
2845 {
2846 sb_info_t *si;
2847 uint regoff;
2848
2849 si = SB_INFO(sbh);
2850 regoff = 0;
2851
2852 /* gpios could be shared on router platforms */
2853 if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
2854 mask = priority ? (sb_gpioreservation & mask) :
2855 ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
2856 val &= mask;
2857 }
2858
2859 switch (si->gpioid) {
2860 case SB_CC:
2861 regoff = OFFSETOF(chipcregs_t, gpiointpolarity);
2862 break;
2863
2864 case SB_PCI:
2865 /* pci gpio implementation does not support interrupt polarity */
2866 ASSERT(0);
2867 break;
2868
2869 case SB_EXTIF:
2870 regoff = OFFSETOF(extifregs_t, gpiointpolarity);
2871 break;
2872 }
2873
2874 return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
2875 }
2876
2877 /* mask&set gpio interrupt mask bits */
2878 uint32 sb_gpiointmask(sb_t * sbh, uint32 mask, uint32 val, uint8 priority)
2879 {
2880 sb_info_t *si;
2881 uint regoff;
2882
2883 si = SB_INFO(sbh);
2884 regoff = 0;
2885
2886 /* gpios could be shared on router platforms */
2887 if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
2888 mask = priority ? (sb_gpioreservation & mask) :
2889 ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
2890 val &= mask;
2891 }
2892
2893 switch (si->gpioid) {
2894 case SB_CC:
2895 regoff = OFFSETOF(chipcregs_t, gpiointmask);
2896 break;
2897
2898 case SB_PCI:
2899 /* pci gpio implementation does not support interrupt mask */
2900 ASSERT(0);
2901 break;
2902
2903 case SB_EXTIF:
2904 regoff = OFFSETOF(extifregs_t, gpiointmask);
2905 break;
2906 }
2907
2908 return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
2909 }
2910
2911 /* assign the gpio to an led */
2912 uint32 sb_gpioled(sb_t * sbh, uint32 mask, uint32 val)
2913 {
2914 sb_info_t *si;
2915
2916 si = SB_INFO(sbh);
2917 if (si->sb.ccrev < 16)
2918 return -1;
2919
2920 /* gpio led powersave reg */
2921 return (sb_corereg
2922 (sbh, SB_CC_IDX, OFFSETOF(chipcregs_t, gpiotimeroutmask), mask,
2923 val));
2924 }
2925
2926 /* mask&set gpio timer val */
2927 uint32 sb_gpiotimerval(sb_t * sbh, uint32 mask, uint32 gpiotimerval)
2928 {
2929 sb_info_t *si;
2930 si = SB_INFO(sbh);
2931
2932 if (si->sb.ccrev < 16)
2933 return -1;
2934
2935 return (sb_corereg(sbh, SB_CC_IDX,
2936 OFFSETOF(chipcregs_t, gpiotimerval), mask,
2937 gpiotimerval));
2938 }
2939
2940 uint32 sb_gpiopull(sb_t * sbh, bool updown, uint32 mask, uint32 val)
2941 {
2942 sb_info_t *si;
2943 uint offs;
2944
2945 si = SB_INFO(sbh);
2946 if (si->sb.ccrev < 20)
2947 return -1;
2948
2949 offs =
2950 (updown ? OFFSETOF(chipcregs_t, gpiopulldown) :
2951 OFFSETOF(chipcregs_t, gpiopullup));
2952 return (sb_corereg(sbh, SB_CC_IDX, offs, mask, val));
2953 }
2954
2955 uint32 sb_gpioevent(sb_t * sbh, uint regtype, uint32 mask, uint32 val)
2956 {
2957 sb_info_t *si;
2958 uint offs;
2959
2960 si = SB_INFO(sbh);
2961 if (si->sb.ccrev < 11)
2962 return -1;
2963
2964 if (regtype == GPIO_REGEVT)
2965 offs = OFFSETOF(chipcregs_t, gpioevent);
2966 else if (regtype == GPIO_REGEVT_INTMSK)
2967 offs = OFFSETOF(chipcregs_t, gpioeventintmask);
2968 else if (regtype == GPIO_REGEVT_INTPOL)
2969 offs = OFFSETOF(chipcregs_t, gpioeventintpolarity);
2970 else
2971 return -1;
2972
2973 return (sb_corereg(sbh, SB_CC_IDX, offs, mask, val));
2974 }
2975
2976 void *BCMINITFN(sb_gpio_handler_register) (sb_t * sbh, uint32 event,
2977 bool level, gpio_handler_t cb,
2978 void *arg) {
2979 sb_info_t *si;
2980 gpioh_item_t *gi;
2981
2982 ASSERT(event);
2983 ASSERT(cb);
2984
2985 si = SB_INFO(sbh);
2986 if (si->sb.ccrev < 11)
2987 return NULL;
2988
2989 if ((gi = MALLOC(si->osh, sizeof(gpioh_item_t))) == NULL)
2990 return NULL;
2991
2992 bzero(gi, sizeof(gpioh_item_t));
2993 gi->event = event;
2994 gi->handler = cb;
2995 gi->arg = arg;
2996 gi->level = level;
2997
2998 gi->next = si->gpioh_head;
2999 si->gpioh_head = gi;
3000
3001 return (void *)(gi);
3002 }
3003
3004 void BCMINITFN(sb_gpio_handler_unregister) (sb_t * sbh, void *gpioh) {
3005 sb_info_t *si;
3006 gpioh_item_t *p, *n;
3007
3008 si = SB_INFO(sbh);
3009 if (si->sb.ccrev < 11)
3010 return;
3011
3012 ASSERT(si->gpioh_head);
3013 if ((void *)si->gpioh_head == gpioh) {
3014 si->gpioh_head = si->gpioh_head->next;
3015 MFREE(si->osh, gpioh, sizeof(gpioh_item_t));
3016 return;
3017 } else {
3018 p = si->gpioh_head;
3019 n = p->next;
3020 while (n) {
3021 if ((void *)n == gpioh) {
3022 p->next = n->next;
3023 MFREE(si->osh, gpioh, sizeof(gpioh_item_t));
3024 return;
3025 }
3026 p = n;
3027 n = n->next;
3028 }
3029 }
3030
3031 ASSERT(0); /* Not found in list */
3032 }
3033
3034 void sb_gpio_handler_process(sb_t * sbh)
3035 {
3036 sb_info_t *si;
3037 gpioh_item_t *h;
3038 uint32 status;
3039 uint32 level = sb_gpioin(sbh);
3040 uint32 edge = sb_gpioevent(sbh, GPIO_REGEVT, 0, 0);
3041
3042 si = SB_INFO(sbh);
3043 for (h = si->gpioh_head; h != NULL; h = h->next) {
3044 if (h->handler) {
3045 status = (h->level ? level : edge);
3046
3047 if (status & h->event)
3048 h->handler(status, h->arg);
3049 }
3050 }
3051
3052 sb_gpioevent(sbh, GPIO_REGEVT, edge, edge); /* clear edge-trigger status */
3053 }
3054
3055 uint32 sb_gpio_int_enable(sb_t * sbh, bool enable)
3056 {
3057 sb_info_t *si;
3058 uint offs;
3059
3060 si = SB_INFO(sbh);
3061 if (si->sb.ccrev < 11)
3062 return -1;
3063
3064 offs = OFFSETOF(chipcregs_t, intmask);
3065 return (sb_corereg
3066 (sbh, SB_CC_IDX, offs, CI_GPIO, (enable ? CI_GPIO : 0)));
3067 }
3068
3069 #ifdef BCMDBG
3070 void sb_dump(sb_t * sbh, struct bcmstrbuf *b)
3071 {
3072 sb_info_t *si;
3073 uint i;
3074
3075 si = SB_INFO(sbh);
3076
3077 bcm_bprintf(b,
3078 "si %p chip 0x%x chiprev 0x%x boardtype 0x%x boardvendor 0x%x bus %d\n",
3079 si, si->sb.chip, si->sb.chiprev, si->sb.boardtype,
3080 si->sb.boardvendor, si->sb.bustype);
3081 bcm_bprintf(b, "osh %p curmap %p\n", si->osh, si->curmap);
3082 bcm_bprintf(b,
3083 "sonicsrev %d ccrev %d buscoretype 0x%x buscorerev %d curidx %d\n",
3084 si->sb.sonicsrev, si->sb.ccrev, si->sb.buscoretype,
3085 si->sb.buscorerev, si->curidx);
3086
3087 bcm_bprintf(b, "forceHT %d ASPM overflowPR42780 %d pcie_polarity %d\n",
3088 si->sb.pr32414, si->sb.pr42780, si->pcie_polarity);
3089
3090 bcm_bprintf(b, "cores: ");
3091 for (i = 0; i < si->numcores; i++)
3092 bcm_bprintf(b, "0x%x ", si->coreid[i]);
3093 bcm_bprintf(b, "\n");
3094 }
3095
3096 /* print interesting sbconfig registers */
3097 void sb_dumpregs(sb_t * sbh, struct bcmstrbuf *b)
3098 {
3099 sb_info_t *si;
3100 sbconfig_t *sb;
3101 uint origidx;
3102 uint curidx, i, intr_val = 0;
3103
3104 si = SB_INFO(sbh);
3105 origidx = si->curidx;
3106
3107 INTR_OFF(si, intr_val);
3108 curidx = si->curidx;
3109
3110 for (i = 0; i < si->numcores; i++) {
3111 sb = REGS2SB(sb_setcoreidx(sbh, i));
3112
3113 bcm_bprintf(b, "core 0x%x: \n", si->coreid[i]);
3114 bcm_bprintf(b,
3115 "sbtmstatelow 0x%x sbtmstatehigh 0x%x sbidhigh 0x%x "
3116 "sbimstate 0x%x\n sbimconfiglow 0x%x sbimconfighigh 0x%x\n",
3117 R_SBREG(si, &sb->sbtmstatelow), R_SBREG(si,
3118 &sb->
3119 sbtmstatehigh),
3120 R_SBREG(si, &sb->sbidhigh), R_SBREG(si,
3121 &sb->sbimstate),
3122 R_SBREG(si, &sb->sbimconfiglow), R_SBREG(si,
3123 &sb->
3124 sbimconfighigh));
3125 }
3126
3127 sb_setcoreidx(sbh, origidx);
3128 INTR_RESTORE(si, intr_val);
3129 }
3130
3131 void sb_view(sb_t * sbh)
3132 {
3133 sb_info_t *si;
3134 sbconfig_t *sb;
3135
3136 si = SB_INFO(sbh);
3137 sb = REGS2SB(si->curmap);
3138
3139 if (si->sb.sonicsrev > SONICS_2_2)
3140 SB_ERROR(("sbimerrlog 0x%x sbimerrloga 0x%x\n",
3141 sb_corereg(sbh, sb_coreidx(&si->sb), SBIMERRLOG, 0,
3142 0), sb_corereg(sbh, sb_coreidx(&si->sb),
3143 SBIMERRLOGA, 0, 0)));
3144
3145 SB_ERROR(("sbipsflag 0x%x sbtpsflag 0x%x sbtmerrloga 0x%x sbtmerrlog 0x%x\n", R_SBREG(si, &sb->sbipsflag), R_SBREG(si, &sb->sbtpsflag), R_SBREG(si, &sb->sbtmerrloga), R_SBREG(si, &sb->sbtmerrlog)));
3146 SB_ERROR(("sbadmatch3 0x%x sbadmatch2 0x%x sbadmatch1 0x%x\n",
3147 R_SBREG(si, &sb->sbadmatch3), R_SBREG(si, &sb->sbadmatch2),
3148 R_SBREG(si, &sb->sbadmatch1)));
3149 SB_ERROR(("sbimstate 0x%x sbintvec 0x%x sbtmstatelow 0x%x sbtmstatehigh 0x%x\n", R_SBREG(si, &sb->sbimstate), R_SBREG(si, &sb->sbintvec), R_SBREG(si, &sb->sbtmstatelow), R_SBREG(si, &sb->sbtmstatehigh)));
3150 SB_ERROR(("sbbwa0 0x%x sbimconfiglow 0x%x sbimconfighigh 0x%x sbadmatch0 0x%x\n", R_SBREG(si, &sb->sbbwa0), R_SBREG(si, &sb->sbimconfiglow), R_SBREG(si, &sb->sbimconfighigh), R_SBREG(si, &sb->sbadmatch0)));
3151 SB_ERROR(("sbtmconfiglow 0x%x sbtmconfighigh 0x%x sbbconfig 0x%x sbbstate 0x%x\n", R_SBREG(si, &sb->sbtmconfiglow), R_SBREG(si, &sb->sbtmconfighigh), R_SBREG(si, &sb->sbbconfig), R_SBREG(si, &sb->sbbstate)));
3152 SB_ERROR(("sbactcnfg 0x%x sbflagst 0x%x sbidlow 0x%x sbidhigh 0x%x\n",
3153 R_SBREG(si, &sb->sbactcnfg), R_SBREG(si, &sb->sbflagst),
3154 R_SBREG(si, &sb->sbidlow), R_SBREG(si, &sb->sbidhigh)));
3155 }
3156
3157 void sb_viewall(sb_t * sbh)
3158 {
3159 sb_info_t *si;
3160 uint curidx, i;
3161 uint intr_val = 0;
3162
3163 si = SB_INFO(sbh);
3164 curidx = si->curidx;
3165
3166 for (i = 0; i < si->numcores; i++) {
3167 INTR_OFF(si, intr_val);
3168 sb_setcoreidx(sbh, i);
3169 sb_view(sbh);
3170 INTR_RESTORE(si, intr_val);
3171 }
3172
3173 sb_setcoreidx(sbh, curidx);
3174 }
3175 #endif /* BCMDBG */
3176
3177 /* return the slow clock source - LPO, XTAL, or PCI */
3178 static uint sb_slowclk_src(sb_info_t * si)
3179 {
3180 chipcregs_t *cc;
3181
3182 ASSERT(sb_coreid(&si->sb) == SB_CC);
3183
3184 if (si->sb.ccrev < 6) {
3185 if ((BUSTYPE(si->sb.bustype) == PCI_BUS) &&
3186 (OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUT, sizeof(uint32))
3187 & PCI_CFG_GPIO_SCS))
3188 return (SCC_SS_PCI);
3189 else
3190 return (SCC_SS_XTAL);
3191 } else if (si->sb.ccrev < 10) {
3192 cc = (chipcregs_t *) sb_setcoreidx(&si->sb, si->curidx);
3193 return (R_REG(si->osh, &cc->slow_clk_ctl) & SCC_SS_MASK);
3194 } else /* Insta-clock */
3195 return (SCC_SS_XTAL);
3196 }
3197
3198 /* return the ILP (slowclock) min or max frequency */
3199 static uint sb_slowclk_freq(sb_info_t * si, bool max_freq)
3200 {
3201 chipcregs_t *cc;
3202 uint32 slowclk;
3203 uint div;
3204
3205 ASSERT(sb_coreid(&si->sb) == SB_CC);
3206
3207 cc = (chipcregs_t *) sb_setcoreidx(&si->sb, si->curidx);
3208
3209 /* shouldn't be here unless we've established the chip has dynamic clk control */
3210 ASSERT(R_REG(si->osh, &cc->capabilities) & CC_CAP_PWR_CTL);
3211
3212 slowclk = sb_slowclk_src(si);
3213 if (si->sb.ccrev < 6) {
3214 if (slowclk == SCC_SS_PCI)
3215 return (max_freq ? (PCIMAXFREQ / 64)
3216 : (PCIMINFREQ / 64));
3217 else
3218 return (max_freq ? (XTALMAXFREQ / 32)
3219 : (XTALMINFREQ / 32));
3220 } else if (si->sb.ccrev < 10) {
3221 div =
3222 4 *
3223 (((R_REG(si->osh, &cc->slow_clk_ctl) & SCC_CD_MASK) >>
3224 SCC_CD_SHIFT)
3225 + 1);
3226 if (slowclk == SCC_SS_LPO)
3227 return (max_freq ? LPOMAXFREQ : LPOMINFREQ);
3228 else if (slowclk == SCC_SS_XTAL)
3229 return (max_freq ? (XTALMAXFREQ / div)
3230 : (XTALMINFREQ / div));
3231 else if (slowclk == SCC_SS_PCI)
3232 return (max_freq ? (PCIMAXFREQ / div)
3233 : (PCIMINFREQ / div));
3234 else
3235 ASSERT(0);
3236 } else {
3237 /* Chipc rev 10 is InstaClock */
3238 div = R_REG(si->osh, &cc->system_clk_ctl) >> SYCC_CD_SHIFT;
3239 div = 4 * (div + 1);
3240 return (max_freq ? XTALMAXFREQ : (XTALMINFREQ / div));
3241 }
3242 return (0);
3243 }
3244
3245 static void BCMINITFN(sb_clkctl_setdelay) (sb_info_t * si, void *chipcregs) {
3246 chipcregs_t *cc;
3247 uint slowmaxfreq, pll_delay, slowclk;
3248 uint pll_on_delay, fref_sel_delay;
3249
3250 pll_delay = PLL_DELAY;
3251
3252 /* If the slow clock is not sourced by the xtal then add the xtal_on_delay
3253 * since the xtal will also be powered down by dynamic clk control logic.
3254 */
3255
3256 slowclk = sb_slowclk_src(si);
3257 if (slowclk != SCC_SS_XTAL)
3258 pll_delay += XTAL_ON_DELAY;
3259
3260 /* Starting with 4318 it is ILP that is used for the delays */
3261 slowmaxfreq = sb_slowclk_freq(si, (si->sb.ccrev >= 10) ? FALSE : TRUE);
3262
3263 pll_on_delay = ((slowmaxfreq * pll_delay) + 999999) / 1000000;
3264 fref_sel_delay = ((slowmaxfreq * FREF_DELAY) + 999999) / 1000000;
3265
3266 cc = (chipcregs_t *) chipcregs;
3267 W_REG(si->osh, &cc->pll_on_delay, pll_on_delay);
3268 W_REG(si->osh, &cc->fref_sel_delay, fref_sel_delay);
3269 }
3270
3271 /* initialize power control delay registers */
3272 void BCMINITFN(sb_clkctl_init) (sb_t * sbh) {
3273 sb_info_t *si;
3274 uint origidx;
3275 chipcregs_t *cc;
3276
3277 si = SB_INFO(sbh);
3278
3279 origidx = si->curidx;
3280
3281 if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0)) == NULL)
3282 return;
3283
3284 if ((si->sb.chip == BCM4321_CHIP_ID) && (si->sb.chiprev < 2))
3285 W_REG(si->osh, &cc->chipcontrol,
3286 (si->sb.chiprev ==
3287 0) ? CHIPCTRL_4321A0_DEFAULT : CHIPCTRL_4321A1_DEFAULT);
3288
3289 if (!(R_REG(si->osh, &cc->capabilities) & CC_CAP_PWR_CTL))
3290 goto done;
3291
3292 /* set all Instaclk chip ILP to 1 MHz */
3293 if (si->sb.ccrev >= 10)
3294 SET_REG(si->osh, &cc->system_clk_ctl, SYCC_CD_MASK,
3295 (ILP_DIV_1MHZ << SYCC_CD_SHIFT));
3296
3297 sb_clkctl_setdelay(si, (void *)(uintptr) cc);
3298
3299 done:
3300 sb_setcoreidx(sbh, origidx);
3301 }
3302
3303 /* return the value suitable for writing to the dot11 core FAST_PWRUP_DELAY register */
3304 uint16 BCMINITFN(sb_clkctl_fast_pwrup_delay) (sb_t * sbh) {
3305 sb_info_t *si;
3306 uint origidx;
3307 chipcregs_t *cc;
3308 uint slowminfreq;
3309 uint16 fpdelay;
3310 uint intr_val = 0;
3311
3312 si = SB_INFO(sbh);
3313 fpdelay = 0;
3314 origidx = si->curidx;
3315
3316 INTR_OFF(si, intr_val);
3317
3318 if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0)) == NULL)
3319 goto done;
3320
3321 if (sbh->cccaps & CC_CAP_PMU) {
3322 fpdelay = sb_pmu_fast_pwrup_delay(sbh, si->osh);
3323 goto done;
3324 }
3325
3326 if (!(sbh->cccaps & CC_CAP_PWR_CTL))
3327 goto done;
3328
3329 slowminfreq = sb_slowclk_freq(si, FALSE);
3330 fpdelay = (((R_REG(si->osh, &cc->pll_on_delay) + 2) * 1000000) +
3331 (slowminfreq - 1)) / slowminfreq;
3332
3333 done:
3334 sb_setcoreidx(sbh, origidx);
3335 INTR_RESTORE(si, intr_val);
3336 return (fpdelay);
3337 }
3338
3339 /* turn primary xtal and/or pll off/on */
3340 int sb_clkctl_xtal(sb_t * sbh, uint what, bool on)
3341 {
3342 sb_info_t *si;
3343 uint32 in, out, outen;
3344
3345 si = SB_INFO(sbh);
3346
3347 switch (BUSTYPE(si->sb.bustype)) {
3348
3349 case PCMCIA_BUS:
3350 return (0);
3351
3352 case PCI_BUS:
3353
3354 /* pcie core doesn't have any mapping to control the xtal pu */
3355 if (PCIE(si))
3356 return -1;
3357
3358 in = OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_IN, sizeof(uint32));
3359 out =
3360 OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUT, sizeof(uint32));
3361 outen =
3362 OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUTEN,
3363 sizeof(uint32));
3364
3365 /*
3366 * Avoid glitching the clock if GPRS is already using it.
3367 * We can't actually read the state of the PLLPD so we infer it
3368 * by the value of XTAL_PU which *is* readable via gpioin.
3369 */
3370 if (on && (in & PCI_CFG_GPIO_XTAL))
3371 return (0);
3372
3373 if (what & XTAL)
3374 outen |= PCI_CFG_GPIO_XTAL;
3375 if (what & PLL)
3376 outen |= PCI_CFG_GPIO_PLL;
3377
3378 if (on) {
3379 /* turn primary xtal on */
3380 if (what & XTAL) {
3381 out |= PCI_CFG_GPIO_XTAL;
3382 if (what & PLL)
3383 out |= PCI_CFG_GPIO_PLL;
3384 OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT,
3385 sizeof(uint32), out);
3386 OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUTEN,
3387 sizeof(uint32), outen);
3388 OSL_DELAY(XTAL_ON_DELAY);
3389 }
3390
3391 /* turn pll on */
3392 if (what & PLL) {
3393 out &= ~PCI_CFG_GPIO_PLL;
3394 OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT,
3395 sizeof(uint32), out);
3396 OSL_DELAY(2000);
3397 }
3398 } else {
3399 if (what & XTAL)
3400 out &= ~PCI_CFG_GPIO_XTAL;
3401 if (what & PLL)
3402 out |= PCI_CFG_GPIO_PLL;
3403 OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT,
3404 sizeof(uint32), out);
3405 OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUTEN,
3406 sizeof(uint32), outen);
3407 }
3408
3409 default:
3410 return (-1);
3411 }
3412
3413 return (0);
3414 }
3415
3416 /* set dynamic clk control mode (forceslow, forcefast, dynamic) */
3417 /* returns true if we are forcing fast clock */
3418 bool sb_clkctl_clk(sb_t * sbh, uint mode)
3419 {
3420 sb_info_t *si;
3421 uint origidx;
3422 chipcregs_t *cc;
3423 uint32 scc;
3424 uint intr_val = 0;
3425
3426 si = SB_INFO(sbh);
3427
3428 /* chipcommon cores prior to rev6 don't support dynamic clock control */
3429 if (si->sb.ccrev < 6)
3430 return (FALSE);
3431
3432 /* Chips with ccrev 10 are EOL and they don't have SYCC_HR which we use below */
3433 ASSERT(si->sb.ccrev != 10);
3434
3435 INTR_OFF(si, intr_val);
3436
3437 origidx = si->curidx;
3438
3439 if (sb_setcore(sbh, SB_MIPS33, 0) && (sb_corerev(&si->sb) <= 7) &&
3440 (BUSTYPE(si->sb.bustype) == SB_BUS) && (si->sb.ccrev >= 10))
3441 goto done;
3442
3443 if (FORCEHT_WAR32414(si))
3444 goto done;
3445
3446 cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0);
3447 ASSERT(cc != NULL);
3448
3449 if (!(R_REG(si->osh, &cc->capabilities) & CC_CAP_PWR_CTL)
3450 && (si->sb.ccrev < 20))
3451 goto done;
3452
3453 switch (mode) {
3454 case CLK_FAST: /* force fast (pll) clock */
3455 if (si->sb.ccrev < 10) {
3456 /* don't forget to force xtal back on before we clear SCC_DYN_XTAL.. */
3457 sb_clkctl_xtal(&si->sb, XTAL, ON);
3458
3459 SET_REG(si->osh, &cc->slow_clk_ctl,
3460 (SCC_XC | SCC_FS | SCC_IP), SCC_IP);
3461 } else if (si->sb.ccrev < 20) {
3462 OR_REG(si->osh, &cc->system_clk_ctl, SYCC_HR);
3463 } else {
3464 OR_REG(si->osh, &cc->clk_ctl_st, CCS_FORCEHT);
3465 }
3466
3467 /* wait for the PLL */
3468 if (R_REG(si->osh, &cc->capabilities) & CC_CAP_PMU) {
3469 SPINWAIT(((R_REG(si->osh, &cc->clk_ctl_st) &
3470 CCS_HTAVAIL) == 0), PMU_MAX_TRANSITION_DLY);
3471 ASSERT(R_REG(si->osh, &cc->clk_ctl_st) & CCS_HTAVAIL);
3472 } else {
3473 OSL_DELAY(PLL_DELAY);
3474 }
3475 break;
3476
3477 case CLK_DYNAMIC: /* enable dynamic clock control */
3478 if (si->sb.ccrev < 10) {
3479 scc = R_REG(si->osh, &cc->slow_clk_ctl);
3480 scc &= ~(SCC_FS | SCC_IP | SCC_XC);
3481 if ((scc & SCC_SS_MASK) != SCC_SS_XTAL)
3482 scc |= SCC_XC;
3483 W_REG(si->osh, &cc->slow_clk_ctl, scc);
3484
3485 /* for dynamic control, we have to release our xtal_pu "force on" */
3486 if (scc & SCC_XC)
3487 sb_clkctl_xtal(&si->sb, XTAL, OFF);
3488 } else if (si->sb.ccrev < 20) {
3489 /* Instaclock */
3490 AND_REG(si->osh, &cc->system_clk_ctl, ~SYCC_HR);
3491 } else {
3492 AND_REG(si->osh, &cc->clk_ctl_st, ~CCS_FORCEHT);
3493 }
3494 break;
3495
3496 default:
3497 ASSERT(0);
3498 }
3499
3500 done:
3501 sb_setcoreidx(sbh, origidx);
3502 INTR_RESTORE(si, intr_val);
3503 return (mode == CLK_FAST);
3504 }
3505
3506 /* register driver interrupt disabling and restoring callback functions */
3507 void
3508 sb_register_intr_callback(sb_t * sbh, void *intrsoff_fn,
3509 void *intrsrestore_fn, void *intrsenabled_fn,
3510 void *intr_arg)
3511 {
3512 sb_info_t *si;
3513
3514 si = SB_INFO(sbh);
3515 si->intr_arg = intr_arg;
3516 si->intrsoff_fn = (sb_intrsoff_t) intrsoff_fn;
3517 si->intrsrestore_fn = (sb_intrsrestore_t) intrsrestore_fn;
3518 si->intrsenabled_fn = (sb_intrsenabled_t) intrsenabled_fn;
3519 /* save current core id. when this function called, the current core
3520 * must be the core which provides driver functions(il, et, wl, etc.)
3521 */
3522 si->dev_coreid = si->coreid[si->curidx];
3523 }
3524
3525 void sb_deregister_intr_callback(sb_t * sbh)
3526 {
3527 sb_info_t *si;
3528
3529 si = SB_INFO(sbh);
3530 si->intrsoff_fn = NULL;
3531 }
3532
3533 #ifdef BCMDBG
3534 /* dump dynamic clock control related registers */
3535 void sb_clkctl_dump(sb_t * sbh, struct bcmstrbuf *b)
3536 {
3537 sb_info_t *si;
3538 chipcregs_t *cc;
3539 uint origidx;
3540 uint intr_val = 0;
3541
3542 si = SB_INFO(sbh);
3543
3544 INTR_OFF(si, intr_val);
3545
3546 origidx = si->curidx;
3547
3548 if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0)) == NULL) {
3549 INTR_RESTORE(si, intr_val);
3550 return;
3551 }
3552
3553 if (!(R_REG(si->osh, &cc->capabilities) & CC_CAP_PWR_CTL))
3554 goto done;
3555
3556 bcm_bprintf(b, "pll_on_delay 0x%x fref_sel_delay 0x%x ",
3557 cc->pll_on_delay, cc->fref_sel_delay);
3558 if ((si->sb.ccrev >= 6) && (si->sb.ccrev < 10))
3559 bcm_bprintf(b, "slow_clk_ctl 0x%x ", cc->slow_clk_ctl);
3560 if (si->sb.ccrev >= 10) {
3561 bcm_bprintf(b, "system_clk_ctl 0x%x ", cc->system_clk_ctl);
3562 bcm_bprintf(b, "clkstatestretch 0x%x ", cc->clkstatestretch);
3563 }
3564 if (BUSTYPE(si->sb.bustype) == PCI_BUS)
3565 bcm_bprintf(b, "gpioout 0x%x gpioouten 0x%x ",
3566 OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUT,
3567 sizeof(uint32)),
3568 OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUTEN,
3569 sizeof(uint32)));
3570 bcm_bprintf(b, "\n");
3571
3572 done:
3573 sb_setcoreidx(sbh, origidx);
3574 INTR_RESTORE(si, intr_val);
3575 }
3576 #endif /* BCMDBG */
3577
3578 uint16 BCMINITFN(sb_d11_devid) (sb_t * sbh) {
3579 sb_info_t *si = SB_INFO(sbh);
3580 uint16 device;
3581
3582 #if defined(BCM4328)
3583 /* Fix device id for dual band BCM4328 */
3584 if (sbh->chip == BCM4328_CHIP_ID &&
3585 (sbh->chippkg == BCM4328USBDUAL_PKG_ID
3586 || sbh->chippkg == BCM4328SDIODUAL_PKG_ID))
3587 device = BCM4328_D11DUAL_ID;
3588 else
3589 #endif /* BCM4328 */
3590 /* Let an nvram variable with devpath override devid */
3591 if ((device = (uint16) sb_getdevpathintvar(sbh, "devid")) != 0) ;
3592 /* Get devid from OTP/SPROM depending on where the SROM is read */
3593 else if ((device = (uint16) getintvar(si->vars, "devid")) != 0) ;
3594 /*
3595 * no longer support wl0id, but keep the code
3596 * here for backward compatibility.
3597 */
3598 else if ((device = (uint16) getintvar(si->vars, "wl0id")) != 0) ;
3599 /* Chip specific conversion */
3600 else if (sbh->chip == BCM4712_CHIP_ID) {
3601 if (sbh->chippkg == BCM4712SMALL_PKG_ID)
3602 device = BCM4306_D11G_ID;
3603 else
3604 device = BCM4306_D11DUAL_ID;
3605 }
3606 /* ignore it */
3607 else
3608 device = 0xffff;
3609
3610 return device;
3611 }
3612
3613 int
3614 BCMINITFN(sb_corepciid) (sb_t * sbh, uint func, uint16 * pcivendor,
3615 uint16 * pcidevice, uint8 * pciclass,
3616 uint8 * pcisubclass, uint8 * pciprogif,
3617 uint8 * pciheader) {
3618 uint16 vendor = 0xffff, device = 0xffff;
3619 uint8 class, subclass, progif = 0;
3620 uint8 header = PCI_HEADER_NORMAL;
3621 uint32 core = sb_coreid(sbh);
3622
3623 /* Verify whether the function exists for the core */
3624 if (func >= (uint) (core == SB_USB20H ? 2 : 1))
3625 return -1;
3626
3627 /* Known vendor translations */
3628 switch (sb_corevendor(sbh)) {
3629 case SB_VEND_BCM:
3630 vendor = VENDOR_BROADCOM;
3631 break;
3632 default:
3633 return -1;
3634 }
3635
3636 /* Determine class based on known core codes */
3637 switch (core) {
3638 case SB_ILINE20:
3639 class = PCI_CLASS_NET;
3640 subclass = PCI_NET_ETHER;
3641 device = BCM47XX_ILINE_ID;
3642 break;
3643 case SB_ENET:
3644 class = PCI_CLASS_NET;
3645 subclass = PCI_NET_ETHER;
3646 device = BCM47XX_ENET_ID;
3647 break;
3648 case SB_GIGETH:
3649 class = PCI_CLASS_NET;
3650 subclass = PCI_NET_ETHER;
3651 device = BCM47XX_GIGETH_ID;
3652 break;
3653 case SB_SDRAM:
3654 case SB_MEMC:
3655 class = PCI_CLASS_MEMORY;
3656 subclass = PCI_MEMORY_RAM;
3657 device = (uint16) core;
3658 break;
3659 case SB_PCI:
3660 case SB_PCIE:
3661 class = PCI_CLASS_BRIDGE;
3662 subclass = PCI_BRIDGE_PCI;
3663 device = (uint16) core;
3664 header = PCI_HEADER_BRIDGE;
3665 break;
3666 case SB_MIPS:
3667 case SB_MIPS33:
3668 class = PCI_CLASS_CPU;
3669 subclass = PCI_CPU_MIPS;
3670 device = (uint16) core;
3671 break;
3672 case SB_CODEC:
3673 class = PCI_CLASS_COMM;
3674 subclass = PCI_COMM_MODEM;
3675 device = BCM47XX_V90_ID;
3676 break;
3677 case SB_USB:
3678 class = PCI_CLASS_SERIAL;
3679 subclass = PCI_SERIAL_USB;
3680 progif = 0x10; /* OHCI */
3681 device = BCM47XX_USB_ID;
3682 break;
3683 case SB_USB11H:
3684 class = PCI_CLASS_SERIAL;
3685 subclass = PCI_SERIAL_USB;
3686 progif = 0x10; /* OHCI */
3687 device = BCM47XX_USBH_ID;
3688 break;
3689 case SB_USB20H:
3690 class = PCI_CLASS_SERIAL;
3691 subclass = PCI_SERIAL_USB;
3692 progif = func == 0 ? 0x10 : 0x20; /* OHCI/EHCI */
3693 device = BCM47XX_USB20H_ID;
3694 header = 0x80; /* multifunction */
3695 break;
3696 case SB_IPSEC:
3697 class = PCI_CLASS_CRYPT;
3698 subclass = PCI_CRYPT_NETWORK;
3699 device = BCM47XX_IPSEC_ID;
3700 break;
3701 case SB_ROBO:
3702 class = PCI_CLASS_NET;
3703 subclass = PCI_NET_OTHER;
3704 device = BCM47XX_ROBO_ID;
3705 break;
3706 case SB_EXTIF:
3707 case SB_CC:
3708 class = PCI_CLASS_MEMORY;
3709 subclass = PCI_MEMORY_FLASH;
3710 device = (uint16) core;
3711 break;
3712 case SB_SATAXOR:
3713 class = PCI_CLASS_XOR;
3714 subclass = PCI_XOR_QDMA;
3715 device = BCM47XX_SATAXOR_ID;
3716 break;
3717 case SB_ATA100:
3718 class = PCI_CLASS_DASDI;
3719 subclass = PCI_DASDI_IDE;
3720 device = BCM47XX_ATA100_ID;
3721 break;
3722 case SB_USB11D:
3723 class = PCI_CLASS_SERIAL;
3724 subclass = PCI_SERIAL_USB;
3725 device = BCM47XX_USBD_ID;
3726 break;
3727 case SB_USB20D:
3728 class = PCI_CLASS_SERIAL;
3729 subclass = PCI_SERIAL_USB;
3730 device = BCM47XX_USB20D_ID;
3731 break;
3732 case SB_D11:
3733 class = PCI_CLASS_NET;
3734 subclass = PCI_NET_OTHER;
3735 device = sb_d11_devid(sbh);
3736 break;
3737
3738 default:
3739 class = subclass = progif = 0xff;
3740 device = (uint16) core;
3741 break;
3742 }
3743
3744 *pcivendor = vendor;
3745 *pcidevice = device;
3746 *pciclass = class;
3747 *pcisubclass = subclass;
3748 *pciprogif = progif;
3749 *pciheader = header;
3750
3751 return 0;
3752 }
3753
3754 /* use the mdio interface to read from mdio slaves */
3755 static int
3756 sb_pcie_mdioread(sb_info_t * si, uint physmedia, uint regaddr, uint * regval)
3757 {
3758 uint mdiodata;
3759 uint i = 0;
3760 sbpcieregs_t *pcieregs;
3761
3762 pcieregs = (sbpcieregs_t *) sb_setcoreidx(&si->sb, si->sb.buscoreidx);
3763 ASSERT(pcieregs);
3764
3765 /* enable mdio access to SERDES */
3766 W_REG(si->osh, (&pcieregs->mdiocontrol),
3767 MDIOCTL_PREAM_EN | MDIOCTL_DIVISOR_VAL);
3768
3769 mdiodata = MDIODATA_START | MDIODATA_READ |
3770 (physmedia << MDIODATA_DEVADDR_SHF) |
3771 (regaddr << MDIODATA_REGADDR_SHF) | MDIODATA_TA;
3772
3773 W_REG(si->osh, &pcieregs->mdiodata, mdiodata);
3774
3775 PR28829_DELAY();
3776
3777 /* retry till the transaction is complete */
3778 while (i < 10) {
3779 if (R_REG(si->osh, &(pcieregs->mdiocontrol)) &
3780 MDIOCTL_ACCESS_DONE) {
3781 PR28829_DELAY();
3782 *regval =
3783 (R_REG(si->osh, &(pcieregs->mdiodata)) &
3784 MDIODATA_MASK);
3785 /* Disable mdio access to SERDES */
3786 W_REG(si->osh, (&pcieregs->mdiocontrol), 0);
3787 return 0;
3788 }
3789 OSL_DELAY(1000);
3790 i++;
3791 }
3792
3793 SB_ERROR(("sb_pcie_mdioread: timed out\n"));
3794 /* Disable mdio access to SERDES */
3795 W_REG(si->osh, (&pcieregs->mdiocontrol), 0);
3796 return 1;
3797 }
3798
3799 /* use the mdio interface to write to mdio slaves */
3800 static int
3801 sb_pcie_mdiowrite(sb_info_t * si, uint physmedia, uint regaddr, uint val)
3802 {
3803 uint mdiodata;
3804 uint i = 0;
3805 sbpcieregs_t *pcieregs;
3806
3807 pcieregs = (sbpcieregs_t *) sb_setcoreidx(&si->sb, si->sb.buscoreidx);
3808 ASSERT(pcieregs);
3809
3810 /* enable mdio access to SERDES */
3811 W_REG(si->osh, (&pcieregs->mdiocontrol),
3812 MDIOCTL_PREAM_EN | MDIOCTL_DIVISOR_VAL);
3813
3814 mdiodata = MDIODATA_START | MDIODATA_WRITE |
3815 (physmedia << MDIODATA_DEVADDR_SHF) |
3816 (regaddr << MDIODATA_REGADDR_SHF) | MDIODATA_TA | val;
3817
3818 W_REG(si->osh, (&pcieregs->mdiodata), mdiodata);
3819
3820 PR28829_DELAY();
3821
3822 /* retry till the transaction is complete */
3823 while (i < 10) {
3824 if (R_REG(si->osh, &(pcieregs->mdiocontrol)) &
3825 MDIOCTL_ACCESS_DONE) {
3826 /* Disable mdio access to SERDES */
3827 W_REG(si->osh, (&pcieregs->mdiocontrol), 0);
3828 return 0;
3829 }
3830 OSL_DELAY(1000);
3831 i++;
3832 }
3833
3834 SB_ERROR(("sb_pcie_mdiowrite: timed out\n"));
3835 /* Disable mdio access to SERDES */
3836 W_REG(si->osh, (&pcieregs->mdiocontrol), 0);
3837 return 1;
3838
3839 }
3840
3841 /* indirect way to read pcie config regs */
3842 uint sb_pcie_readreg(void *sb, void *arg1, uint offset)
3843 {
3844 sb_info_t *si;
3845 sb_t *sbh;
3846 uint retval = 0xFFFFFFFF;
3847 sbpcieregs_t *pcieregs;
3848 uint addrtype;
3849
3850 sbh = (sb_t *) sb;
3851 si = SB_INFO(sbh);
3852 ASSERT(PCIE(si));
3853
3854 pcieregs = (sbpcieregs_t *) sb_setcore(sbh, SB_PCIE, 0);
3855 ASSERT(pcieregs);
3856
3857 addrtype = (uint) ((uintptr) arg1);
3858 switch (addrtype) {
3859 case PCIE_CONFIGREGS:
3860 W_REG(si->osh, (&pcieregs->configaddr), offset);
3861 retval = R_REG(si->osh, &(pcieregs->configdata));
3862 break;
3863 case PCIE_PCIEREGS:
3864 W_REG(si->osh, &(pcieregs->pcieindaddr), offset);
3865 retval = R_REG(si->osh, &(pcieregs->pcieinddata));
3866 break;
3867 default:
3868 ASSERT(0);
3869 break;
3870 }
3871 return retval;
3872 }
3873
3874 /* indirect way to write pcie config/mdio/pciecore regs */
3875 uint sb_pcie_writereg(sb_t * sbh, void *arg1, uint offset, uint val)
3876 {
3877 sb_info_t *si;
3878 sbpcieregs_t *pcieregs;
3879 uint addrtype;
3880
3881 si = SB_INFO(sbh);
3882 ASSERT(PCIE(si));
3883
3884 pcieregs = (sbpcieregs_t *) sb_setcore(sbh, SB_PCIE, 0);
3885 ASSERT(pcieregs);
3886
3887 addrtype = (uint) ((uintptr) arg1);
3888
3889 switch (addrtype) {
3890 case PCIE_CONFIGREGS:
3891 W_REG(si->osh, (&pcieregs->configaddr), offset);
3892 W_REG(si->osh, (&pcieregs->configdata), val);
3893 break;
3894 case PCIE_PCIEREGS:
3895 W_REG(si->osh, (&pcieregs->pcieindaddr), offset);
3896 W_REG(si->osh, (&pcieregs->pcieinddata), val);
3897 break;
3898 default:
3899 ASSERT(0);
3900 break;
3901 }
3902 return 0;
3903 }
3904
3905 /* Build device path. Support SB, PCI, and JTAG for now. */
3906 int BCMINITFN(sb_devpath) (sb_t * sbh, char *path, int size) {
3907 int slen;
3908 ASSERT(path);
3909 ASSERT(size >= SB_DEVPATH_BUFSZ);
3910
3911 if (!path || size <= 0)
3912 return -1;
3913
3914 switch (BUSTYPE((SB_INFO(sbh))->sb.bustype)) {
3915 case SB_BUS:
3916 case JTAG_BUS:
3917 slen = snprintf(path, (size_t) size, "sb/%u/", sb_coreidx(sbh));
3918 break;
3919 case PCI_BUS:
3920 ASSERT((SB_INFO(sbh))->osh);
3921 slen = snprintf(path, (size_t) size, "pci/%u/%u/",
3922 OSL_PCI_BUS((SB_INFO(sbh))->osh),
3923 OSL_PCI_SLOT((SB_INFO(sbh))->osh));
3924 break;
3925 case PCMCIA_BUS:
3926 SB_ERROR(("sb_devpath: OSL_PCMCIA_BUS() not implemented, bus 1 assumed\n"));
3927 SB_ERROR(("sb_devpath: OSL_PCMCIA_SLOT() not implemented, slot 1 assumed\n"));
3928 slen = snprintf(path, (size_t) size, "pc/1/1/");
3929 break;
3930 default:
3931 slen = -1;
3932 ASSERT(0);
3933 break;
3934 }
3935
3936 if (slen < 0 || slen >= size) {
3937 path[0] = '\0';
3938 return -1;
3939 }
3940
3941 return 0;
3942 }
3943
3944 /* Get a variable, but only if it has a devpath prefix */
3945 char *BCMINITFN(sb_getdevpathvar) (sb_t * sbh, const char *name) {
3946 char varname[SB_DEVPATH_BUFSZ + 32];
3947
3948 sb_devpathvar(sbh, varname, sizeof(varname), name);
3949
3950 return (getvar(NULL, varname));
3951 }
3952
3953 /* Get a variable, but only if it has a devpath prefix */
3954 int BCMINITFN(sb_getdevpathintvar) (sb_t * sbh, const char *name) {
3955 char varname[SB_DEVPATH_BUFSZ + 32];
3956
3957 sb_devpathvar(sbh, varname, sizeof(varname), name);
3958
3959 return (getintvar(NULL, varname));
3960 }
3961
3962 /* Concatenate the dev path with a varname into the given 'var' buffer
3963 * and return the 'var' pointer.
3964 * Nothing is done to the arguments if len == 0 or var is NULL, var is still returned.
3965 * On overflow, the first char will be set to '\0'.
3966 */
3967 static char *BCMINITFN(sb_devpathvar) (sb_t * sbh, char *var, int len,
3968 const char *name) {
3969 uint path_len;
3970
3971 if (!var || len <= 0)
3972 return var;
3973
3974 if (sb_devpath(sbh, var, len) == 0) {
3975 path_len = strlen(var);
3976
3977 if (strlen(name) + 1 > (uint) (len - path_len))
3978 var[0] = '\0';
3979 else
3980 strncpy(var + path_len, name, len - path_len - 1);
3981 }
3982
3983 return var;
3984 }
3985
3986 /*
3987 * Fixup SROMless PCI device's configuration.
3988 * The current core may be changed upon return.
3989 */
3990 static int sb_pci_fixcfg(sb_info_t * si)
3991 {
3992 uint origidx, pciidx;
3993 sbpciregs_t *pciregs;
3994 sbpcieregs_t *pcieregs = NULL;
3995 uint16 val16, *reg16;
3996 uint32 w;
3997
3998 ASSERT(BUSTYPE(si->sb.bustype) == PCI_BUS);
3999
4000 /* Fixup PI in SROM shadow area to enable the correct PCI core access */
4001 /* save the current index */
4002 origidx = sb_coreidx(&si->sb);
4003
4004 /* check 'pi' is correct and fix it if not */
4005 if (si->sb.buscoretype == SB_PCIE) {
4006 pcieregs = (sbpcieregs_t *) sb_setcore(&si->sb, SB_PCIE, 0);
4007 ASSERT(pcieregs);
4008 reg16 = &pcieregs->sprom[SRSH_PI_OFFSET];
4009 } else if (si->sb.buscoretype == SB_PCI) {
4010 pciregs = (sbpciregs_t *) sb_setcore(&si->sb, SB_PCI, 0);
4011 ASSERT(pciregs);
4012 reg16 = &pciregs->sprom[SRSH_PI_OFFSET];
4013 } else {
4014 ASSERT(0);
4015 return -1;
4016 }
4017 pciidx = sb_coreidx(&si->sb);
4018 val16 = R_REG(si->osh, reg16);
4019 if (((val16 & SRSH_PI_MASK) >> SRSH_PI_SHIFT) != (uint16) pciidx) {
4020 val16 =
4021 (uint16) (pciidx << SRSH_PI_SHIFT) | (val16 &
4022 ~SRSH_PI_MASK);
4023 W_REG(si->osh, reg16, val16);
4024 }
4025
4026 if (PCIE_ASPMWARS(si)) {
4027 w = sb_pcie_readreg((void *)(uintptr) & si->sb,
4028 (void *)PCIE_PCIEREGS, PCIE_PLP_STATUSREG);
4029
4030 /* Detect the current polarity at attach and force that polarity and
4031 * disable changing the polarity
4032 */
4033 if ((w & PCIE_PLP_POLARITYINV_STAT) == 0) {
4034 si->pcie_polarity = (SERDES_RX_CTRL_FORCE);
4035 } else {
4036 si->pcie_polarity = (SERDES_RX_CTRL_FORCE |
4037 SERDES_RX_CTRL_POLARITY);
4038 }
4039
4040 w = OSL_PCI_READ_CONFIG(si->osh, si->pciecap_lcreg_offset,
4041 sizeof(uint32));
4042 if (w & PCIE_CLKREQ_ENAB) {
4043 reg16 = &pcieregs->sprom[SRSH_CLKREQ_OFFSET];
4044 val16 = R_REG(si->osh, reg16);
4045 /* if clockreq is not advertized clkreq should not be enabled */
4046 if (!(val16 & SRSH_CLKREQ_ENB))
4047 SB_ERROR(("WARNING: CLK REQ enabled already 0x%x\n", w));
4048 }
4049
4050 sb_war43448(&si->sb);
4051
4052 sb_war42767(&si->sb);
4053
4054 }
4055
4056 /* restore the original index */
4057 sb_setcoreidx(&si->sb, origidx);
4058
4059 return 0;
4060 }
4061
4062 /* Return ADDR64 capability of the backplane */
4063 bool sb_backplane64(sb_t * sbh)
4064 {
4065 sb_info_t *si;
4066
4067 si = SB_INFO(sbh);
4068 return ((si->sb.cccaps & CC_CAP_BKPLN64) != 0);
4069 }
4070
4071 void sb_btcgpiowar(sb_t * sbh)
4072 {
4073 sb_info_t *si;
4074 uint origidx;
4075 uint intr_val = 0;
4076 chipcregs_t *cc;
4077 si = SB_INFO(sbh);
4078
4079 /* Make sure that there is ChipCommon core present &&
4080 * UART_TX is strapped to 1
4081 */
4082 if (!(si->sb.cccaps & CC_CAP_UARTGPIO))
4083 return;
4084
4085 /* sb_corereg cannot be used as we have to guarantee 8-bit read/writes */
4086 INTR_OFF(si, intr_val);
4087
4088 origidx = sb_coreidx(sbh);
4089
4090 cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0);
4091 ASSERT(cc);
4092
4093 W_REG(si->osh, &cc->uart0mcr, R_REG(si->osh, &cc->uart0mcr) | 0x04);
4094
4095 /* restore the original index */
4096 sb_setcoreidx(sbh, origidx);
4097
4098 INTR_RESTORE(si, intr_val);
4099 }
4100
4101 /* check if the device is removed */
4102 bool sb_deviceremoved(sb_t * sbh)
4103 {
4104 uint32 w;
4105 sb_info_t *si;
4106
4107 si = SB_INFO(sbh);
4108
4109 switch (BUSTYPE(si->sb.bustype)) {
4110 case PCI_BUS:
4111 ASSERT(si->osh);
4112 w = OSL_PCI_READ_CONFIG(si->osh, PCI_CFG_VID, sizeof(uint32));
4113 if ((w & 0xFFFF) != VENDOR_BROADCOM)
4114 return TRUE;
4115 else
4116 return FALSE;
4117 default:
4118 return FALSE;
4119 }
4120 return FALSE;
4121 }
4122
4123 #if 0
4124 /* Return the RAM size of the SOCRAM core */
4125 uint32 BCMINITFN(sb_socram_size) (sb_t * sbh) {
4126 sb_info_t *si;
4127 uint origidx;
4128 uint intr_val = 0;
4129
4130 sbsocramregs_t *regs;
4131 bool wasup;
4132 uint corerev;
4133 uint32 coreinfo;
4134 uint memsize = 0;
4135
4136 si = SB_INFO(sbh);
4137 ASSERT(si);
4138
4139 /* Block ints and save current core */
4140 INTR_OFF(si, intr_val);
4141 origidx = sb_coreidx(sbh);
4142
4143 /* Switch to SOCRAM core */
4144 if (!(regs = sb_setcore(sbh, SB_SOCRAM, 0)))
4145 goto done;
4146
4147 /* Get info for determining size */
4148 if (!(wasup = sb_iscoreup(sbh)))
4149 sb_core_reset(sbh, 0, 0);
4150 corerev = sb_corerev(sbh);
4151 coreinfo = R_REG(si->osh, &regs->coreinfo);
4152
4153 /* Calculate size from coreinfo based on rev */
4154 if (corerev == 0)
4155 memsize = 1 << (16 + (coreinfo & SRCI_MS0_MASK));
4156 else if (corerev < 3) {
4157 memsize = 1 << (SR_BSZ_BASE + (coreinfo & SRCI_SRBSZ_MASK));
4158 memsize *= (coreinfo & SRCI_SRNB_MASK) >> SRCI_SRNB_SHIFT;
4159 } else {
4160 uint nb = (coreinfo & SRCI_SRNB_MASK) >> SRCI_SRNB_SHIFT;
4161 uint bsz = (coreinfo & SRCI_SRBSZ_MASK);
4162 uint lss = (coreinfo & SRCI_LSS_MASK) >> SRCI_LSS_SHIFT;
4163 if (lss != 0)
4164 nb--;
4165 memsize = nb * (1 << (bsz + SR_BSZ_BASE));
4166 if (lss != 0)
4167 memsize += (1 << ((lss - 1) + SR_BSZ_BASE));
4168 }
4169 /* Return to previous state and core */
4170 if (!wasup)
4171 sb_core_disable(sbh, 0);
4172 sb_setcoreidx(sbh, origidx);
4173
4174 done:
4175 INTR_RESTORE(si, intr_val);
4176 return memsize;
4177 }
4178
4179 #endif
Staging tree of dedeckeh