开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
sbutils.c
资源名称：bcm4702.rar　[点击查看]
上传用户：yuanda199
上传日期：2022-06-26
资源大小：412k
文件大小：46k
源码类别：

VxWorks

开发平台：

C/C++

sbutils.c：源码内容
  1. /*
  2.  * Misc utility routines for accessing chip-specific features
  3.  * of the SiliconBackplane-based Broadcom chips.
  4.  *
  5.  * Copyright(c) 2001 Broadcom Corp.
  6.  * $Id: sbutils.c,v 1.1 Broadcom SDK $
  7.  */
  9. #include <hnbutypedefs.h>
  10. #include <osl.h>
  11. #include <bcmutils.h>
  12. #include <bcmdevs.h>
  13. #include <sbconfig.h>
  14. #include <sbchipc.h>
  15. #include <sbpci.h>
  16. #include <sbpcmcia.h>
  17. #include <sbextif.h>
  18. #include <sbutils.h>
  19. #include <bcmendian.h>
  20. #ifndef BROADCOM_BSP
  21. #include <bcmnvram.h>
  22. #endif
  24. /* debug/trace */
  25. #ifdef BCMDBG
  26. #define SB_ERROR(args) printf args
  27. #else
  28. #define SB_ERROR(args)
  29. #endif
  31. /* misc sb info needed by some of the routines */
  32. typedef struct sb_info {
  33. uint chip; /* chip number */
  34. uint chiprev; /* chip revision */
  35. uint16 board; /* board id */
  36. uint16 boardvendor; /* board vendor id */
  37. uint bus; /* what bus type we are going through */
  39. void *osh; /* osl os handle */
  41. void *curmap; /* current regs va */
  42. void *origregs; /* initial core registers va */
  43. uint origcoreidx; /* initial core index */
  45. uint pciidx; /* pci core index */
  46. uint pcirev; /* pci core rev */
  48. uint gpioidx; /* gpio control core index */
  49. uint gpioid; /* gpio control coretype */
  51. uint numcores; /* # discovered cores */
  52. uint coreid[SB_MAXCORES]; /* id of each core */
  53. } sb_info_t;
  55. /* local prototypes */
  56. static void sb_scan(sb_info_t *si);
  57. static uint sb_corereg(void *sbh, uint coreidx, uint regoff, uint mask, uint val);
  58. static uint sb_findcoreidx(void *sbh, uint coreid, uint coreunit);
  59. static uint sb_pcidev2chip(uint pcidev);
  60. static int sb_initvars(sb_info_t *si, char **vars, int *count);
  61. static int srominitvars(sb_info_t *si, char **vars, int *count);
  62. static int cisinitvars(sb_info_t *si, char **vars, int *count);
  63. /* A cis parsing routine that can be called externally */
  64. int parsecis(uint8 *cis, char **vars, int *count);
  65. static void msecs(uint ms);
  67. #define SB_INFO(sbh) (sb_info_t*)sbh
  68. #define SET_SBREG(sbh, r, mask, val) W_SBREG((sbh), (r), ((R_SBREG(r) & ~(mask)) | (val)));
  69. #define GOODCOREADDR(x) (((x) >= SB_ENUM_BASE) && ((x) <= SB_ENUM_LIM) 
  70. && ISALIGNED((x), SB_CORE_SIZE))
  71. #define GOODREGS(regs) (regs && ISALIGNED(regs, SB_CORE_SIZE))
  72. #define REGS2SB(va) (sbconfig_t*) ((uint)(va) + SBCONFIGOFF)
  73. #define GOODIDX(idx) (((uint)idx) < SB_MAXCORES)
  74. #define BADIDX (SB_MAXCORES+1)
  76. /*
  77.  * Macros to read/write sbconfig registers. On the PCMCIA core rev 0
  78.  * we need to treat them differently from other registers. See PR 3863.
  79.  */
  80. #define R_SBREG(sbr) R_REG(sbr)
  81. #define W_SBREG(sbh, sbr, v) sb_write_sbreg((sbh), (sbr), (v))
  82. #define AND_SBREG(sbh, sbr, v) W_SBREG((sbh), (sbr), (R_SBREG(sbr) & (v)))
  83. #define OR_SBREG(sbh, sbr, v) W_SBREG((sbh), (sbr), (R_SBREG(sbr) | (v)))
  85. /* implement PR3863 workaround for the PCMCIA core rev 0 */
  86. static void
  87. sb_write_sbreg(void *sbh, volatile uint32 *sbr, uint32 v)
  88. {
  89. sb_info_t *si;
  90. volatile uint32 dummy;
  92. si = SB_INFO(sbh);
  94. if ((si->bus == PCMCIA_BUS) && (sb_corerev(sbh) == 0)) {
  95. #ifdef IL_BIGENDIAN
  96. dummy = R_REG(sbr);
  97. W_REG((volatile uint16 *)((uint32)sbr + 2), (uint16)((v >> 16) & 0xffff));
  98. dummy = R_REG(sbr);
  99. W_REG((volatile uint16 *)sbr, (uint16)(v & 0xffff));
  100. #else
  101. dummy = R_REG(sbr);
  102. W_REG((volatile uint16 *)sbr, (uint16)(v & 0xffff));
  103. dummy = R_REG(sbr);
  104. W_REG((volatile uint16 *)((uint32)sbr + 2), (uint16)((v >> 16) & 0xffff));
  105. #endif
  106. } else
  107. W_REG(sbr, v);
  108. }
  110. /*
  111.  * Allocate a sb handle.
  112.  * devid - pci device id (used to determine chip#)
  113.  * osh - opaque OS handle
  114.  * regs - virtual address of initial core registers
  115.  * vars - pointer to a pointer area for "environment" variables
  116.  * varsz - pointer to int to return the size of the vars
  117.  */
  118. void*
  119. sb_attach(uint devid, void *osh, void *regs, char **vars, int *varsz)
  120. {
  121. sb_info_t *si;
  122. uint ccidx;
  123. uint chipid;
  124. uint32 w;
  126. ASSERT(GOODREGS(regs));
  128. /* alloc sb_info_t */
  129. if ((si = MALLOC(sizeof (sb_info_t))) == NULL) {
  130. SB_ERROR(("sb_attach: malloc failed!n"));
  131. return (NULL);
  132. }
  133. bzero((uchar*)si, sizeof (sb_info_t));
  135. si->pciidx = si->gpioidx = BADIDX;
  137. si->osh = osh;
  138. si->origregs = si->curmap = regs;
  140. /* determine bus type we're operating over */
  141. if (sb_coreid((void *)si) == SB_PCMCIA) {
  142. si->bus = PCMCIA_BUS;
  143. } else {
  144.         if (osh == NULL) {
  145. si->bus = SB_BUS;
  146.         } else {
  147. /* check to see if we are a sb core mimic'ing a pci core */
  148. if (OSL_PCI_READ_CONFIG(osh, PCI_SPROM_CONTROL, sizeof (uint32)) == 0xffffffff)
  149. si->bus = SB_BUS;
  150. else
  151. si->bus = PCI_BUS;
  152.         }
  153. }
  155. /* keep and reuse the initial register mapping */
  156. si->origcoreidx = sb_coreidx((void*)si);
  158. /* scan for cores */
  159. sb_scan(si);
  161. /* pci core is required */
  162. if (!GOODIDX(si->pciidx)) {
  163. SB_ERROR(("sb_attach: pci core not foundn"));
  164. goto bad;
  165. }
  167. /* gpio control core is required */
  168. if (!GOODIDX(si->gpioidx)) {
  169. SB_ERROR(("sb_attach: gpio control core not foundn"));
  170. goto bad;
  171. }
  173. /* initialize the vars */
  174. if (sb_initvars(si, vars, varsz) != 0) {
  175. SB_ERROR(("sb_attach: sb_initvars failedn"));
  176. goto bad;
  177. }
  179. /* determine chip id and rev */
  180. ccidx = sb_findcoreidx((void*)si, SB_CC, 0);
  181. if (GOODIDX(ccidx)) {
  182. /* easy - found chipcommon core */
  183. chipid = sb_corereg((void*)si, ccidx, OFFSETOF(chipcregs_t, chipid), 0, 0);
  184. si->chip = chipid & CID_ID_MASK;
  185. si->chiprev = (chipid & CID_REV_MASK) >> CID_REV_SHIFT;
  187. /* PR10654: The chipid register on 4306a1 lies */
  188. if ((si->chip == 0x4306) && (si->chiprev == 0))
  189. goto bad4306;
  190. } else {
  191. /* hard - no chipcommon core - must convert device id to chip id */
  192. if ((si->chip = sb_pcidev2chip(devid)) == 0) {
  193. SB_ERROR(("sb_attach: unrecognized device id 0x%04xn", devid));
  194. goto bad;
  195. }
  197. /*
  198.  * The chip revision number is hardwired into all
  199.  * of the pci function config rev fields and is
  200.  * independent from the individual core revision numbers.
  201.  * For example, the "A0" silicon of each chip is chip rev 0.
  202.  * For PCMCIA we get it from the CIS instead.
  203.  */
  204. if (si->bus == PCMCIA_BUS)
  205. #ifndef BROADCOM_BSP  /* we don't use PCMCIA */
  206. si->chiprev = (uint)getintvar(*vars, "chiprev");
  207. #else
  208.                         ;
  209. #endif
  210. else {
  211. bad4306: w = OSL_PCI_READ_CONFIG(osh, 8, sizeof (uint32));
  212. si->chiprev = w & 0xff;
  213. }
  214. }
  216. /* sanity checks */
  217. ASSERT(si->chip);
  218. ASSERT(si->chiprev < 8);
  220. /* get boardtype and boardrev */
  221. if (si->bus == PCMCIA_BUS) {
  222. #ifndef BROADCOM_BSP
  223. si->board = (uint16)getintvar(*vars, "prodid");
  224. si->boardvendor = (uint16)getintvar(*vars, "manfid");
  225. #endif
  226. } else {
  227. /* do a pci config read to get subsystem id and subvendor id */
  228. w = OSL_PCI_READ_CONFIG(osh, 0x2c, sizeof (uint32));
  229. si->board = (w >> 16) & 0xffff;
  230. si->boardvendor = w & 0xffff;
  231. }
  233. /* XXX temp d11 kludge */
  234. if (si->bus == PCMCIA_BUS) {
  235. /* set the d11 core instead of pcmcia */
  236. regs = sb_setcore((void *)si, SB_D11, 0);
  238. /* reset origregs, curmap and origcoreidx */
  239. si->origregs = si->curmap = regs;
  240. si->origcoreidx = sb_coreidx((void*)si);
  241. }
  243. return ((void*)si);
  245. bad:
  246. MFREE(si, sizeof (sb_info_t));
  247. return (NULL);
  248. }
  250. /* kernel caller variant of sb_attach() */
  251. void*
  252. sb_kattach(uint chip, uint chiprev)
  253. {
  254. sb_info_t *si;
  255. uint ccidx, chipid;
  257. /* alloc sb_info_t */
  258. if ((si = MALLOC(sizeof (sb_info_t))) == NULL) {
  259. SB_ERROR(("sb_kattach: malloc failed!n"));
  260. return (NULL);
  261. }
  262. bzero((uchar*)si, sizeof (sb_info_t));
  264. si->pciidx = si->gpioidx = BADIDX;
  265. si->bus = SB_BUS;
  267. /* core0 is default */
  268. si->origcoreidx = 0;
  269. si->origregs = si->curmap = (void*)REG_MAP(SB_ENUM_BASE, SB_CORE_SIZE);
  271. /* scan for cores */
  272. sb_scan(si);
  274. /* pci core is required */
  275. if (!GOODIDX(si->pciidx)) {
  276. SB_ERROR(("sb_attach: pci core not foundn"));
  277. goto bad;
  278. }
  280. /* gpio control core is required */
  281. if (!GOODIDX(si->gpioidx)) {
  282. SB_ERROR(("sb_attach: gpio control core not foundn"));
  283. goto bad;
  284. }
  286. /* determine chip id and rev */
  287. ccidx = sb_findcoreidx((void*)si, SB_CC, 0);
  288. if (GOODIDX(ccidx)) {
  289. /* easy - chipcommon core exists */
  290. chipid = sb_corereg((void*)si, ccidx, OFFSETOF(chipcregs_t, chipid), 0, 0);
  291. si->chip = chipid & CID_ID_MASK;
  292. si->chiprev = (chipid & CID_REV_MASK) >> CID_REV_SHIFT;
  293. }
  294. else {
  295. /* no chipcommon core - just use what we're told */
  296. si->chip = chip;
  297. si->chiprev = chiprev;
  298. }
  300. /* sanity checks */
  301. ASSERT(chip);
  302. ASSERT(chiprev < 8);
  304. return ((void*)si);
  306. bad:
  307. MFREE(si, sizeof (sb_info_t));
  308. return (NULL);
  309. }
  311. uint
  312. sb_coreid(void *sbh)
  313. {
  314. sb_info_t *si;
  315. sbconfig_t *sb;
  317. si = SB_INFO(sbh);
  318. sb = REGS2SB(si->curmap);
  320. return ((R_SBREG(&(sb)->sbidhigh) & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT);
  321. }
  323. /* return current index of core */
  324. uint
  325. sb_coreidx(void *sbh)
  326. {
  327. sb_info_t *si;
  328. sbconfig_t *sb;
  329. uint32 sbaddr = 0;
  331. si = SB_INFO(sbh);
  332. ASSERT(si);
  334. switch (si->bus) {
  335. case SB_BUS:
  336. sb = REGS2SB(si->curmap);
  337. sbaddr = sb_base(R_SBREG(&sb->sbadmatch0));
  338. break;
  340. case PCI_BUS:
  341. sbaddr = OSL_PCI_READ_CONFIG(si->osh, PCI_BAR0_WIN, sizeof (uint32));
  342. break;
  344. case PCMCIA_BUS: {
  345. uint8 tmp;
  347. OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
  348. sbaddr  = (uint)tmp << 12;
  349. OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
  350. sbaddr |= (uint)tmp << 16;
  351. OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
  352. sbaddr |= (uint)tmp << 24;
  353. break;
  354. }
  356. default:
  357. ASSERT(0);
  358. }
  360. ASSERT(GOODCOREADDR(sbaddr));
  361. return ((sbaddr - SB_ENUM_BASE)/SB_CORE_SIZE);
  362. }
  364. uint
  365. sb_corevendor(void *sbh)
  366. {
  367. sb_info_t *si;
  368. sbconfig_t *sb;
  370. si = SB_INFO(sbh);
  371. sb = REGS2SB(si->curmap);
  373. return ((R_SBREG(&(sb)->sbidhigh) & SBIDH_VC_MASK) >> SBIDH_VC_SHIFT);
  374. }
  376. uint
  377. sb_corerev(void *sbh)
  378. {
  379. sb_info_t *si;
  380. sbconfig_t *sb;
  382. si = SB_INFO(sbh);
  383. sb = REGS2SB(si->curmap);
  385. return (R_SBREG(&(sb)->sbidhigh) & SBIDH_RC_MASK);
  386. }
  388. #define SBTML_ALLOW (SBTML_PE | SBTML_FGC | SBTML_FL_MASK)
  390. /* set/clear one or more sbtmstatelow core-specific flag or pme bits */
  391. uint32
  392. sb_coreflags(void *sbh, uint32 mask, uint32 val)
  393. {
  394. sb_info_t *si;
  395. sbconfig_t *sb;
  396. uint32 w;
  398. si = SB_INFO(sbh);
  399. sb = REGS2SB(si->curmap);
  401. ASSERT((val & ~mask) == 0);
  402. ASSERT((mask & ~SBTML_ALLOW) == 0);
  404. /* mask and set */
  405. if (mask || val) {
  406. w = (R_SBREG(&sb->sbtmstatelow) & ~mask) | val;
  407. W_SBREG(sbh, &sb->sbtmstatelow, w);
  408. }
  410. /* return the new value */
  411. return (R_SBREG(&sb->sbtmstatelow) & SBTML_ALLOW);
  412. }
  414. bool
  415. sb_iscoreup(void *sbh)
  416. {
  417. sb_info_t *si;
  418. sbconfig_t *sb;
  420. si = SB_INFO(sbh);
  421. sb = REGS2SB(si->curmap);
  423. return ((R_SBREG(&(sb)->sbtmstatelow) & (SBTML_RESET | SBTML_REJ | SBTML_CLK)) == SBTML_CLK);
  424. }
  426. /*
  427.  * Switch to 'coreidx', issue a single arbitrary 32bit register mask&set operation,
  428.  * switch back to the original core, and return the new value.
  429.  */
  430. static uint
  431. sb_corereg(void *sbh, uint coreidx, uint regoff, uint mask, uint val)
  432. {
  433. sb_info_t *si;
  434. uint origidx;
  435. uint32 *r;
  436. uint w;
  438. ASSERT(GOODIDX(coreidx));
  439. ASSERT(regoff < SB_CORE_SIZE);
  440. ASSERT((val & ~mask) == 0);
  442. si = SB_INFO(sbh);
  444. /* save current core index */
  445. origidx = sb_coreidx(sbh);
  447. /* switch core */
  448. if (origidx != coreidx)
  449. r = (uint32*) ((uint) sb_setcoreidx(sbh, coreidx) + regoff);
  450. else
  451. r = (uint32*) ((uint) si->curmap + regoff);
  453. /* mask and set */
  454. if (mask || val) {
  455. w = (R_SBREG(r) & ~mask) | val;
  456. W_SBREG(sbh, r, w);
  457. }
  459. /* readback */
  460. w = R_SBREG(r);
  462. /* restore core index */
  463. if (origidx != coreidx)
  464. sb_setcoreidx(sbh, origidx);
  466. return (w);
  467. }
  469. /* scan the sb enumerated space to find all cores */
  470. static void
  471. sb_scan(sb_info_t *si)
  472. {
  473. void *sbh;
  474. sbconfig_t *sb;
  475. uint32 sbidhigh;
  476. void *regs;
  477. uint busidx;
  478. uint idx;
  479. uint id;
  480. int i;
  482. sbh = (void*) si;
  484. /* busidx is the index of our "active" pci or pcmcia core */
  485. busidx = BADIDX;
  487. /* required by sb_setcoreidx() */
  488. si->numcores = SB_MAXCORES;
  490. /* save current core index */
  491. idx = sb_coreidx(sbh);
  493. for (i = 0; i < SB_MAXCORES; i++) {
  494. regs = sb_setcoreidx(sbh, i);
  495. sb = REGS2SB(regs);
  497. /* target abort at end of enumerated cores */
  498. sbidhigh = 0;
  499. BUSPROBE(sbidhigh, (&sb->sbidhigh));
  500. if ((sbidhigh == 0xffffffff) || (sbidhigh == 0))
  501. break;
  503. /*
  504.  * Some PC chipsets don't return all ones or all zeros on target abort.
  505.  * Check pci/pcmcia for sbimstate.inbanderror.
  506.  */
  507. if (GOODIDX(busidx) && (sb_corereg(sbh, busidx,
  508. (SBCONFIGOFF + SBIMSTATE), 0, 0) & SBIM_IBE))
  509. break;
  511. /* found a core */
  512. id = sb_coreid(sbh);
  514. si->coreid[i] = id;
  516. /* locate our bus adapter core and clear sbimstate.inbanderror */
  517. if (((si->bus == PCI_BUS) && (id == SB_PCI))
  518. || ((si->bus == PCMCIA_BUS) && (id == SB_PCMCIA))) {
  519. busidx = i;
  520. SET_SBREG(sbh, &sb->sbimstate, SBIM_IBE, 0);
  521. }
  523. /* save pci core rev */
  524. if (id == SB_PCI)
  525. si->pcirev = sb_corerev(sbh);
  526. }
  528. si->numcores = i;
  530. /* find pci core */
  531. si->pciidx = sb_findcoreidx(sbh, SB_PCI, 0);
  533. /*
  534.  * Find the gpio "controlling core" type and index.
  535.  * Precedence:
  536.  * - if there's a chip common core - use that
  537.  * - else if there's a pci core (rev >= 2) - use that
  538.  * - else there had better be an extif core (4710 only)
  539.  */
  540. if (GOODIDX(sb_findcoreidx(sbh, SB_CC, 0))) {
  541. si->gpioidx = sb_findcoreidx(sbh, SB_CC, 0);
  542. si->gpioid = SB_CC;
  543. } else if (GOODIDX(si->pciidx) && (si->pcirev >= 2)) {
  544. si->gpioidx = si->pciidx;
  545. si->gpioid = SB_PCI;
  546. } else if (sb_findcoreidx(sbh, SB_EXTIF, 0)) {
  547. si->gpioidx = sb_findcoreidx(sbh, SB_EXTIF, 0);
  548. si->gpioid = SB_EXTIF;
  549. }
  551. /* restore core index */
  552. sb_setcoreidx(sbh, idx);
  553. }
  555. void
  556. sb_detach(void *sbh)
  557. {
  558. sb_info_t *si;
  560. si = SB_INFO(sbh);
  562. if (si == NULL)
  563. return;
  565. if ((si->bus == SB_BUS) && si->curmap && (si->curmap != si->origregs)) {
  566. ASSERT(GOODREGS(si->curmap));
  567. REG_UNMAP(si->curmap);
  568. si->curmap = NULL;
  569. }
  571. MFREE(si, sizeof (sb_info_t));
  572. }
  574. /* use pci dev id to determine chip id for chips not having a chipcommon core */
  575. static uint
  576. sb_pcidev2chip(uint pcidev)
  577. {
  578. if ((pcidev >= BCM4710_DEVICE_ID) && (pcidev <= BCM47XX_USB_ID))
  579. return (BCM4710_DEVICE_ID);
  580. if ((pcidev >= BCM4610_DEVICE_ID) && (pcidev <= BCM4610_USB_ID))
  581. return (BCM4610_DEVICE_ID);
  582. if ((pcidev >= BCM4402_DEVICE_ID) && (pcidev <= BCM4402_V90_ID))
  583. return (BCM4402_DEVICE_ID);
  584. if ((pcidev >= BCM4307_V90_ID) && (pcidev <= BCM4307_D11B_ID))
  585. return (BCM4307_DEVICE_ID);
  586. if (pcidev == BCM4301_DEVICE_ID)
  587. return (BCM4301_DEVICE_ID);
  588. if ((pcidev >= BCM4309_DEVICE_ID) && (pcidev <= BCM4309_D11DUAL_ID))
  589. return (BCM4309_DEVICE_ID);
  591. return (0);
  592. }
  594. /* return index of coreid or BADIDX if not found */
  595. static uint
  596. sb_findcoreidx(void *sbh, uint coreid, uint coreunit)
  597. {
  598. sb_info_t *si;
  599. uint found;
  600. uint i;
  602. si = SB_INFO(sbh);
  603. found = 0;
  605. for (i = 0; i < si->numcores; i++)
  606. if (si->coreid[i] == coreid) {
  607. if (found == coreunit)
  608. return (i);
  609. found++;
  610. }
  612. return (BADIDX);
  613. }
  615. /* change logical "focus" to the indiciated core */
  616. void*
  617. sb_setcoreidx(void *sbh, uint coreidx)
  618. {
  619. sb_info_t *si;
  620. uint32 sbaddr;
  621. uint8 tmp;
  623. si = SB_INFO(sbh);
  625. if (coreidx >= si->numcores)
  626. return (NULL);
  628. sbaddr = SB_ENUM_BASE + (coreidx * SB_CORE_SIZE);
  630. switch (si->bus) {
  631. case SB_BUS:
  632. /* unmap any previous one */
  633. if (si->curmap && (si->curmap != si->origregs)) {
  634. ASSERT(GOODREGS(si->curmap));
  635. REG_UNMAP(si->curmap);
  636. si->curmap = NULL;
  637. }
  639. /* keep and reuse the initial register mapping */
  640. if (coreidx == si->origcoreidx) {
  641. si->curmap = si->origregs;
  642. return (si->curmap);
  643. }
  645. /* map new one */
  646. si->curmap = (void*)REG_MAP(sbaddr, SB_CORE_SIZE);
  647. ASSERT(GOODREGS(si->curmap));
  648. break;
  650. case PCI_BUS:
  651. /* point bar0 window */
  652. OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN, 4, sbaddr);
  653. break;
  655. case PCMCIA_BUS:
  656. tmp = (sbaddr >> 12) & 0x0f;
  657. OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
  658. tmp = (sbaddr >> 16) & 0xff;
  659. OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
  660. tmp = (sbaddr >> 24) & 0xff;
  661. OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
  662. break;
  663. }
  665. return (si->curmap);
  666. }
  668. /* change logical "focus" to the indicated core */
  669. void*
  670. sb_setcore(void *sbh, uint coreid, uint coreunit)
  671. {
  672. sb_info_t *si;
  673. uint idx;
  675. si = SB_INFO(sbh);
  677. idx = sb_findcoreidx(sbh, coreid, coreunit);
  678. if (!GOODIDX(idx))
  679. return (NULL);
  681. return (sb_setcoreidx(sbh, idx));
  682. }
  684. /* return chip number */
  685. uint
  686. sb_chip(void *sbh)
  687. {
  688. sb_info_t *si;
  690. si = SB_INFO(sbh);
  691. return (si->chip);
  692. }
  694. /* return chip revision number */
  695. uint
  696. sb_chiprev(void *sbh)
  697. {
  698. sb_info_t *si;
  700. si = SB_INFO(sbh);
  701. return (si->chiprev);
  702. }
  704. /* return board type */
  705. uint16
  706. sb_board(void *sbh)
  707. {
  708. sb_info_t *si;
  710. si = SB_INFO(sbh);
  711. return (si->board);
  712. }
  714. /* return board vendor id */
  715. uint16
  716. sb_boardvendor(void *sbh)
  717. {
  718. sb_info_t *si;
  720. si = SB_INFO(sbh);
  721. return (si->boardvendor);
  722. }
  724. /* return boolean if sbh device is in pci hostmode or client mode */
  725. uint
  726. sb_bus(void *sbh)
  727. {
  728. sb_info_t *si;
  730. si = SB_INFO(sbh);
  731. return (si->bus);
  732. }
  734. /* return list of found cores */
  735. uint
  736. sb_corelist(void *sbh, uint coreid[])
  737. {
  738. sb_info_t *si;
  740. si = SB_INFO(sbh);
  742. bcopy((uchar*)si->coreid, (uchar*)coreid, (si->numcores * sizeof (uint)));
  743. return (si->numcores);
  744. }
  746. /* do buffered registers update */
  747. void
  748. sb_commit(void *sbh)
  749. {
  750. sb_info_t *si;
  751. sbpciregs_t *pciregs;
  752. uint idx;
  754. si = SB_INFO(sbh);
  755. idx = BADIDX;
  757. /* switch over to the pci core if necessary */
  758. if (sb_coreid(sbh) == SB_PCI)
  759. pciregs = (sbpciregs_t*) si->curmap;
  760. else {
  761. /* save current core index */
  762. idx = sb_coreidx(sbh);
  763. ASSERT(GOODIDX(idx));
  765. /* switch over to pci core */
  766. pciregs = (sbpciregs_t*) sb_setcore(sbh, SB_PCI, 0);
  767. }
  769. /* do the buffer registers update */
  770. W_REG(&pciregs->bcastaddr, SB_COMMIT);
  771. W_REG(&pciregs->bcastdata, 0x0);
  773. /* restore core index */
  774. if (GOODIDX(idx))
  775. sb_setcoreidx(sbh, idx);
  776. }
  778. /* reset and re-enable a core */
  779. void
  780. sb_core_reset(void *sbh, uint32 bits)
  781. {
  782. sb_info_t *si;
  783. sbconfig_t *sb;
  784. volatile uint32 dummy;
  786. si = SB_INFO(sbh);
  787. ASSERT(GOODREGS(si->curmap));
  788. sb = REGS2SB(si->curmap);
  790. /*
  791.  * Must do the disable sequence first to work for arbitrary current core state.
  792.  */
  793. sb_core_disable(sbh, bits);
  795. /*
  796.  * Now do the initialization sequence.
  797.  */
  799. /* set reset while enabling the clock and forcing them on throughout the core */
  800. W_SBREG(sbh, &sb->sbtmstatelow, (SBTML_FGC | SBTML_CLK | SBTML_RESET | bits));
  801. dummy = R_SBREG(&sb->sbtmstatelow);
  803. /*
  804.  * PR6594 - 4610 iline100 overloads the clock enable bit with the
  805.  * oscillator/pll power up function which needs a much longer delay.
  806.  */
  807. if (sb_coreid(sbh) == SB_ILINE100) {
  808. msecs(50);
  809. } else {
  810. OSL_DELAY(1);
  811. }
  813. /* PR3158 - clear any serror */
  814. if (R_SBREG(&sb->sbtmstatehigh) & SBTMH_SERR) {
  815. W_SBREG(sbh, &sb->sbtmstatehigh, 0);
  816. }
  817. if ((dummy = R_SBREG(&sb->sbimstate)) & (SBIM_IBE | SBIM_TO)) {
  818. AND_SBREG(sbh, &sb->sbimstate, ~(SBIM_IBE | SBIM_TO));
  819. }
  821. /* clear reset and allow it to propagate throughout the core */
  822. W_SBREG(sbh, &sb->sbtmstatelow, (SBTML_FGC | SBTML_CLK | bits));
  823. dummy = R_SBREG(&sb->sbtmstatelow);
  824. OSL_DELAY(1);
  826. /* leave clock enabled */
  827. W_SBREG(sbh, &sb->sbtmstatelow, (SBTML_CLK | bits));
  828. dummy = R_SBREG(&sb->sbtmstatelow);
  829. OSL_DELAY(1);
  830. }
  832. /*
  833.  * Do the PR4755 workaround which require a call
  834.  * to sb_commit. sb_commit needs to access PCI
  835.  * configuration space which is not allowed in some
  836.  * versions of windows when going down. That is why
  837.  * this is not part of sb_core_reset above.
  838.  */
  839. void
  840. sb_core_tofixup(void *sbh)
  841. {
  842. sb_info_t *si;
  843. sbconfig_t *sb;
  845. si = SB_INFO(sbh);
  846. ASSERT(GOODREGS(si->curmap));
  847. sb = REGS2SB(si->curmap);
  849. /* PR 9962/4708: Set initiator timeouts. */
  850. if (si->bus == SB_BUS) {
  851. SET_SBREG(sbh, &sb->sbimconfiglow,
  852.   SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
  853.   (0x5 << SBIMCL_RTO_SHIFT) | 0x3);
  854. } else {
  855. if (sb_coreid(sbh) == SB_PCI) {
  856. SET_SBREG(sbh, &sb->sbimconfiglow,
  857.   SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
  858.   (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
  859. } else {
  860. SET_SBREG(sbh, &sb->sbimconfiglow, (SBIMCL_RTO_MASK | SBIMCL_STO_MASK), 0);
  861. }
  862. }
  864. sb_commit(sbh);
  865. }
  867. void
  868. sb_core_disable(void *sbh, uint32 bits)
  869. {
  870. sb_info_t *si;
  871. volatile uint32 dummy;
  872. sbconfig_t *sb;
  874. si = SB_INFO(sbh);
  876. ASSERT(GOODREGS(si->curmap));
  877. sb = REGS2SB(si->curmap);
  879. /* must return if core is already in reset */
  880. if (R_SBREG(&sb->sbtmstatelow) & SBTML_RESET)
  881. return;
  883. /* set the reject bit */
  884. W_SBREG(sbh, &sb->sbtmstatelow, (SBTML_CLK | SBTML_REJ));
  886. /* spin until reject is set */
  887. while ((R_SBREG(&sb->sbtmstatelow) & SBTML_REJ) == 0)
  888. OSL_DELAY(1);
  890. /* spin until sbtmstatehigh.busy is clear */
  891. while (R_SBREG(&sb->sbtmstatehigh) & SBTMH_BUSY)
  892. OSL_DELAY(1);
  894. /* set reset and reject while enabling the clocks */
  895. W_SBREG(sbh, &sb->sbtmstatelow, (bits | SBTML_FGC | SBTML_CLK | SBTML_REJ | SBTML_RESET));
  896. dummy = R_SBREG(&sb->sbtmstatelow);
  897. OSL_DELAY(10);
  899. /* leave reset and reject asserted */
  900. W_SBREG(sbh, &sb->sbtmstatelow, (bits | SBTML_REJ | SBTML_RESET));
  901. OSL_DELAY(1);
  902. }
  904. void
  905. sb_chip_reset(void *sbh)
  906. {
  907. sb_info_t *si = SB_INFO(sbh);
  909. /* instant NMI */
  910. switch (si->gpioid) {
  911. case SB_CC:
  912. sb_corereg(sbh, si->gpioidx, OFFSETOF(chipcregs_t, watchdog), ~0, 1);
  913. break;
  914. case SB_EXTIF:
  915. sb_corereg(sbh, si->gpioidx, OFFSETOF(extifregs_t, watchdog), ~0, 1);
  916. break;
  917. }
  918. }
  920. /* initialize the pcmcia core */
  921. void
  922. sb_pcmcia_init(void *sbh)
  923. {
  924. sb_info_t *si;
  925. void *regs;
  926. uint8 cor;
  928. si = SB_INFO(sbh);
  930. /* Set the d11 core instead of pcmcia */
  931. regs = sb_setcore(sbh, SB_D11, 0);
  933. /* Reset origregs, curmap and origcoreidx */
  934. si->origregs = si->curmap = regs;
  935. si->origcoreidx = sb_coreidx((void*)si);
  937. /* Enable interrupts via function 2 FCR */
  938. OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_FCR0 + PCMCIA_COR, &cor, 1);
  939. OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_FCR2 + PCMCIA_COR, &cor, 1);
  940. cor |= COR_IRQEN | COR_FUNEN;
  941. OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_FCR2 + PCMCIA_COR, &cor, 1);
  943. /* XXX What else */
  944. }
  946. /*
  947.  * Configure the pci core for pci client (NIC) action
  948.  * and get appropriate dma offset value.
  949.  * coremask is the bitvec of cores by index to be enabled.
  950.  */
  951. void
  952. sb_pci_setup(void *sbh, uint32 *dmaoffset, uint coremask)
  953. {
  954. sb_info_t *si;
  955. sbconfig_t *sb;
  956. sbpciregs_t *pciregs;
  957. uint32 sbflag;
  958. uint32 w;
  959. uint idx;
  961. ASSERT(coremask);
  963. si = SB_INFO(sbh);
  965. if (dmaoffset)
  966. *dmaoffset = 0;
  968. /* if not pci bus, we're done */
  969. if (si->bus != PCI_BUS)
  970. return;
  972. ASSERT(si->pciidx);
  974. /* get current core index */
  975. idx = sb_coreidx(sbh);
  977. /* we interrupt on this backplane flag number */
  978. ASSERT(GOODREGS(si->curmap));
  979. sb = REGS2SB(si->curmap);
  980. sbflag = R_SBREG(&sb->sbtpsflag) & SBTPS_NUM0_MASK;
  982. /* switch over to pci core */
  983. pciregs = (sbpciregs_t*) sb_setcoreidx(sbh, si->pciidx);
  984. sb = REGS2SB(pciregs);
  986. /*
  987.  * Enable sb->pci interrupts.  Assume
  988.  * PCI rev 2.3 support was added in pci core rev 6 and things changed..
  989.  */
  990. if (si->pcirev < 6) {
  991. /* set sbintvec bit for our flag number */
  992. /* PR6075 - both d11 cores on the 4309 use the same flag */
  993. OR_SBREG(sbh, &sb->sbintvec, (1 << sbflag));
  994. } else {
  995. /* pci config write to set this core bit in PCIIntMask */
  996. w = OSL_PCI_READ_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32));
  997. w |= (coremask << SBIM_SHIFT);
  998. OSL_PCI_WRITE_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32), w);
  999. }
  1001. /* enable prefetch and bursts for sonics-to-pci translation 2 */
  1002. OR_REG(&pciregs->sbtopci2, (SBTOPCI_PREF|SBTOPCI_BURST));
  1004. /* PR 9962/4708: Set initiator timeouts. */
  1005. SET_SBREG(sbh, &sb->sbimconfiglow, SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
  1006.   (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
  1007. sb_commit(sbh);
  1009. /* switch back to previous core */
  1010. sb_setcoreidx(sbh, idx);
  1012. /* use large sb pci dma window */
  1013. if (dmaoffset)
  1014. *dmaoffset = SB_PCI_DMA;
  1015. }
  1017. uint32
  1018. sb_base(uint32 admatch)
  1019. {
  1020. uint32 base;
  1021. uint type;
  1023. type = admatch & SBAM_TYPE_MASK;
  1024. ASSERT(type < 3);
  1026. base = 0;
  1028. if (type == 0) {
  1029. base = admatch & SBAM_BASE0_MASK;
  1030. } else if (type == 1) {
  1031. ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
  1032. base = admatch & SBAM_BASE1_MASK;
  1033. } else if (type == 2) {
  1034. ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
  1035. base = admatch & SBAM_BASE2_MASK;
  1036. }
  1038. return (base);
  1039. }
  1041. uint32
  1042. sb_size(uint32 admatch)
  1043. {
  1044. uint32 size;
  1045. uint type;
  1047. type = admatch & SBAM_TYPE_MASK;
  1048. ASSERT(type < 3);
  1050. size = 0;
  1052. if (type == 0) {
  1053. size = 1 << (((admatch & SBAM_ADINT0_MASK) >> SBAM_ADINT0_SHIFT) + 1);
  1054. } else if (type == 1) {
  1055. ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
  1056. size = 1 << (((admatch & SBAM_ADINT1_MASK) >> SBAM_ADINT1_SHIFT) + 1);
  1057. } else if (type == 2) {
  1058. ASSERT(!(admatch & SBAM_ADNEG)); /* neg not supported */
  1059. size = 1 << (((admatch & SBAM_ADINT2_MASK) >> SBAM_ADINT2_SHIFT) + 1);
  1060. }
  1062. return (size);
  1063. }
  1065. /* return the core-type instantiation # of the current core */
  1066. uint
  1067. sb_coreunit(void *sbh)
  1068. {
  1069. sb_info_t *si;
  1070. uint idx;
  1071. uint coreid;
  1072. uint coreunit;
  1073. uint i;
  1075. si = SB_INFO(sbh);
  1076. coreunit = 0;
  1078. idx = sb_coreidx(sbh);
  1080. ASSERT(GOODREGS(si->curmap));
  1081. coreid = sb_coreid(sbh);
  1083. /* count the cores of our type */
  1084. for (i = 0; i < idx; i++)
  1085. if (si->coreid[i] == coreid)
  1086. coreunit++;
  1088. return (coreunit);
  1089. }
  1091. static INLINE uint32
  1092. factor6(uint32 x)
  1093. {
  1094. switch (x) {
  1095. case CC_F6_2: return 2;
  1096. case CC_F6_3: return 3;
  1097. case CC_F6_4: return 4;
  1098. case CC_F6_5: return 5;
  1099. case CC_F6_6: return 6;
  1100. case CC_F6_7: return 7;
  1101. default: return 0;
  1102. }
  1103. }
  1105. /* calculate the speed the SB would run at given a set of clockcontrol values */
  1106. uint32
  1107. sb_clock_rate(uint32 n, uint32 m)
  1108. {
  1109. uint32 n1, n2, fastclock, m1, m2, m3;
  1111. n1 = factor6(n & CN_N1_MASK);
  1112. n2 = ((n & CN_N2_MASK) >> CN_N2_SHIFT) + CC_F5_BIAS;
  1114. fastclock = CC_CLOCK_BASE * n1 * n2;
  1116. if (fastclock == 0)
  1117. return 0;
  1119. m1 = factor6(m & CC_M1_MASK);
  1120. m2 = ((m & CC_M2_MASK) >> CC_M2_SHIFT) + CC_F5_BIAS;
  1121. m3 = factor6((m & CC_M3_MASK) >> CC_M3_SHIFT);
  1123. switch ((m & CC_MC_MASK) >> CC_MC_SHIFT) {
  1124. case CC_MC_BYPASS: return (fastclock);
  1125. case CC_MC_M1: return (fastclock / m1);
  1126. case CC_MC_M1M2: return (fastclock / (m1 * m2));
  1127. case CC_MC_M1M2M3: return (fastclock / (m1 * m2 * m3));
  1128. case CC_MC_M1M3: return (fastclock / (m1 * m3));
  1129. default: return (0);
  1130. }
  1131. }
  1133. /* returns the current speed the SB is running at */
  1134. uint32
  1135. sb_clock(void *sbh)
  1136. {
  1137. extifregs_t *eir;
  1138. chipcregs_t *cc;
  1139. volatile uint32 *clockcontrol_n, *clockcontrol_sb;
  1140. uint idx;
  1141. uint32 rate;
  1143. /* get index of the current core */
  1144. idx = sb_coreidx(sbh);
  1146. /* switch to extif or chipc core */
  1147. if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
  1148. clockcontrol_n = &eir->clockcontrol_n;
  1149. clockcontrol_sb = &eir->clockcontrol_sb;
  1150. } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
  1151. clockcontrol_n = &cc->clockcontrol_n;
  1152. clockcontrol_sb = &cc->clockcontrol_sb;
  1153. } else
  1154. return 0;
  1156. /* calculate rate */
  1157. rate = sb_clock_rate(R_REG(clockcontrol_n), R_REG(clockcontrol_sb));
  1159. /* switch back to previous core */
  1160. sb_setcoreidx(sbh, idx);
  1162. return rate;
  1163. }
  1165. /* set the current speed of the SB to the desired rate (as closely as possible) */
  1166. bool
  1167. sb_setclock(void *sbh, uint32 sb, uint32 pci)
  1168. {
  1169. extifregs_t *eir;
  1170. chipcregs_t *cc;
  1171. volatile uint32 *clockcontrol_n, *clockcontrol_sb, *clockcontrol_pci;
  1172. uint32 orig_n, orig_pci, orig_sb, pci_clock=0;
  1173. uint idx, i;
  1174. struct {
  1175. uint32 clock;
  1176. uint16 n;
  1177. uint32 sb;
  1178. uint32 pci33;
  1179. uint32 pci25;
  1180. } sb_clock_table[] = {
  1181. {  96000000, 0x0303, 0x04020011, 0x11030011, 0x11050011 }, /*  96.000 32.000 24.000 */
  1182. { 100000000, 0x0009, 0x04020011, 0x11030011, 0x11050011 }, /* 100.000 33.333 25.000 */
  1183. { 104000000, 0x0802, 0x04020011, 0x11050009, 0x11090009 }, /* 104.000 31.200 24.960 */
  1184. { 108000000, 0x0403, 0x04020011, 0x11050009, 0x02000802 }, /* 108.000 32.400 24.923 */
  1185. { 112000000, 0x0205, 0x04020011, 0x11030021, 0x02000403 }, /* 112.000 32.000 24.889 */
  1186. { 115200000, 0x0303, 0x04020009, 0x11030011, 0x11050011 }, /* 115.200 32.000 24.000 */
  1187. { 120000000, 0x0011, 0x04020011, 0x11050011, 0x11090011 }, /* 120.000 30.000 24.000 */
  1188. { 124800000, 0x0802, 0x04020009, 0x11050009, 0x11090009 }, /* 124.800 31.200 24.960 */
  1189. { 128000000, 0x0305, 0x04020011, 0x11050011, 0x02000305 }, /* 128.000 32.000 24.000 */
  1190. { 132000000, 0x0603, 0x04020011, 0x11050011, 0x02000305 }, /* 132.000 33.000 24.750 */
  1191. { 136000000, 0x0c02, 0x04020011, 0x11090009, 0x02000603 }, /* 136.000 32.640 24.727 */
  1192. { 140000000, 0x0021, 0x04020011, 0x11050021, 0x02000c02 }, /* 140.000 30.000 24.706 */
  1193. { 144000000, 0x0405, 0x04020011, 0x01020202, 0x11090021 }, /* 144.000 30.857 24.686 */
  1194. { 150857142, 0x0605, 0x04020021, 0x02000305, 0x02000605 }, /* 150.857 33.000 24.000 */
  1195. { 152000000, 0x0e02, 0x04020011, 0x11050021, 0x02000e02 }, /* 152.000 32.571 24.000 */
  1196. { 156000000, 0x0802, 0x04020005, 0x11050009, 0x11090009 }, /* 156.000 31.200 24.960 */
  1197. { 160000000, 0x0309, 0x04020011, 0x11090011, 0x02000309 }, /* 160.000 32.000 24.000 */
  1198. { 163200000, 0x0c02, 0x04020009, 0x11090009, 0x02000603 }, /* 163.200 32.640 24.727 */
  1199. { 168000000, 0x0205, 0x04020005, 0x11030021, 0x02000403 }, /* 168.000 32.000 24.889 */
  1200. { 176000000, 0x0602, 0x04020003, 0x11050005, 0x02000602 }, /* 176.000 33.000 24.000 */
  1201. };
  1203. /* get index of the current core */
  1204. idx = sb_coreidx(sbh);
  1206. /* switch to extif or chipc core */
  1207. if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
  1208. clockcontrol_n = &eir->clockcontrol_n;
  1209. clockcontrol_sb = &eir->clockcontrol_sb;
  1210. clockcontrol_pci = &eir->clockcontrol_pci;
  1211. } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
  1212. clockcontrol_n = &cc->clockcontrol_n;
  1213. clockcontrol_sb = &cc->clockcontrol_sb;
  1214. clockcontrol_pci = &cc->clockcontrol_pci;
  1215. } else
  1216. return 0;
  1218. /* Store the current clock reg values */
  1219. orig_n = R_REG(clockcontrol_n);
  1220. orig_sb = R_REG(clockcontrol_sb);
  1221. orig_pci = R_REG(clockcontrol_pci);
  1223. /* keep current pci clock if not specified */
  1224. if (!pci) {
  1225. pci = sb_clock_rate(R_REG(clockcontrol_n), R_REG(clockcontrol_pci));
  1226. pci = (pci <= 25000000) ? 25000000 : 33000000;
  1227. }
  1229. for (i = 1; i < (sizeof(sb_clock_table)/sizeof(sb_clock_table[0])); i++) {
  1230. if ((sb >= sb_clock_table[i-1].clock) && (sb < sb_clock_table[i].clock)) {
  1231. ASSERT(sb_clock_table[i-1].clock ==
  1232. sb_clock_rate(sb_clock_table[i-1].n, sb_clock_table[i-1].sb));
  1233. W_REG(clockcontrol_n, sb_clock_table[i-1].n);
  1234. W_REG(clockcontrol_sb, sb_clock_table[i-1].sb);
  1235. if (pci == 25000000)
  1236. pci_clock = sb_clock_table[i-1].pci25;
  1237. else
  1238. pci_clock = sb_clock_table[i-1].pci33;
  1239. W_REG(clockcontrol_pci, pci_clock);
  1240. break;
  1241. }
  1242. }
  1244. /* switch back to previous core */
  1245. sb_setcoreidx(sbh, idx);
  1247. /* Were the clock rates in the table */
  1248. if (i < (sizeof(sb_clock_table)/sizeof(sb_clock_table[0]))) {
  1249. /* reset if any clocks changed */
  1250. if ((orig_n != sb_clock_table[i-1].n) ||
  1251. (orig_sb != sb_clock_table[i-1].sb) ||
  1252. (orig_pci != pci_clock))
  1253. sb_chip_reset(sbh);
  1254. else
  1255. return TRUE;
  1256. }
  1258. return FALSE;
  1259. }
  1261. #include <ethernet.h> /* for sprom content groking */
  1263. /*
  1264.  * Read in and validate sprom.
  1265.  * Return 0 on success, nonzero on error.
  1266.  */
  1267. static int
  1268. spromread(uint16 *sprom, uint byteoff, uint16 *buf, uint nbytes, bool check_crc)
  1269. {
  1270. int off, nw;
  1271. uint8 chk8;
  1272. int i;
  1274. off = byteoff / 2;
  1275. nw = ROUNDUP(nbytes, 2) / 2;
  1277. /* read the sprom */
  1278. for (i = 0; i < nw; i++)
  1279. buf[i] = R_REG(&sprom[off + i]);
  1281. if (check_crc) {
  1282. /* fixup the endianness so crc8 will pass */
  1283. htol16_buf(buf, nw * 2);
  1284. if ((chk8 = crc8((uchar*)buf, nbytes, CRC8_INIT_VALUE)) != CRC8_GOOD_VALUE)
  1285. return (1);
  1286. /* now correct the endianness of the byte array */
  1287. ltoh16_buf(buf, nw * 2);
  1288. }
  1290. return (0);
  1291. }
  1293. #define VARS_MAX 4096
  1295. /*
  1296.  * Initialize nonvolatile variable table from sprom.
  1297.  * Return 0 on success, nonzero on error.
  1298.  */
  1300. static int
  1301. srominitvars(sb_info_t *si, char **vars, int *count)
  1302. {
  1303. uint16 w, b[64];
  1304. uint8 spromversion;
  1305. struct ether_addr ea;
  1306. char eabuf[32];
  1307. int c, woff, i;
  1308. char *vp, *base;
  1310. if (spromread((void *)((uint)si->curmap + PCI_BAR0_SPROM_OFFSET), 0, b, sizeof (b), TRUE))
  1311. return (-1);
  1313. /* top word of sprom contains version and crc8 */
  1314. spromversion = b[63] & 0xff;
  1315. if (spromversion != 1) {
  1316. return (-2);
  1317. }
  1319. ASSERT(vars);
  1320. ASSERT(count);
  1322. base = vp = MALLOC(VARS_MAX);
  1323. ASSERT(vp);
  1325. /* parameter section of sprom starts at byte offset 72 */
  1326. woff = 72/2;
  1328. /* first 6 bytes are il0macaddr */
  1329. ea.octet[0] = (b[woff] >> 8) & 0xff;
  1330. ea.octet[1] = b[woff] & 0xff;
  1331. ea.octet[2] = (b[woff+1] >> 8) & 0xff;
  1332. ea.octet[3] = b[woff+1] & 0xff;
  1333. ea.octet[4] = (b[woff+2] >> 8) & 0xff;
  1334. ea.octet[5] = b[woff+2] & 0xff;
  1335. woff += ETHER_ADDR_LEN/2 ;
  1336. bcm_ether_ntoa((uchar*)&ea, eabuf);
  1337. vp += sprintf(vp, "il0macaddr=%s", eabuf);
  1338. vp++;
  1340. /* next 6 bytes are et0macaddr */
  1341. ea.octet[0] = (b[woff] >> 8) & 0xff;
  1342. ea.octet[1] = b[woff] & 0xff;
  1343. ea.octet[2] = (b[woff+1] >> 8) & 0xff;
  1344. ea.octet[3] = b[woff+1] & 0xff;
  1345. ea.octet[4] = (b[woff+2] >> 8) & 0xff;
  1346. ea.octet[5] = b[woff+2] & 0xff;
  1347. woff += ETHER_ADDR_LEN/2 ;
  1348. bcm_ether_ntoa((uchar*)&ea, eabuf);
  1349. vp += sprintf(vp, "et0macaddr=%s", eabuf);
  1350. vp++;
  1352. /* next 6 bytes are et1macaddr */
  1353. ea.octet[0] = (b[woff] >> 8) & 0xff;
  1354. ea.octet[1] = b[woff] & 0xff;
  1355. ea.octet[2] = (b[woff+1] >> 8) & 0xff;
  1356. ea.octet[3] = b[woff+1] & 0xff;
  1357. ea.octet[4] = (b[woff+2] >> 8) & 0xff;
  1358. ea.octet[5] = b[woff+2] & 0xff;
  1359. woff += ETHER_ADDR_LEN/2 ;
  1360. bcm_ether_ntoa((uchar*)&ea, eabuf);
  1361. vp += sprintf(vp, "et1macaddr=%s", eabuf);
  1362. vp++;
  1364. /*
  1365.  * Enet phy settings one or two singles or a dual
  1366.  * Bits 4-0 : MII address for enet0 (0x1f for not there)
  1367.  * Bits 9-5 : MII address for enet1 (0x1f for not there)
  1368.  * Bit 14   : Mdio for enet0
  1369.  * Bit 15   : Mdio for enet1
  1370.  */
  1371. w = b[woff];
  1372. vp += sprintf(vp, "et0phyaddr=%d", (w & 0x1f));
  1373. vp++;
  1374. vp += sprintf(vp, "et1phyaddr=%d", ((w >> 5) & 0x1f));
  1375. vp++;
  1376. vp += sprintf(vp, "et0mdcport=%d", ((w >> 14) & 0x1));
  1377. vp++;
  1378. vp += sprintf(vp, "et1mdcport=%d", ((w >> 15) & 0x1));
  1379. vp++;
  1381. /* Word 46 has board rev, antennas 0/1 & Country code */
  1382. w = b[46];
  1383. vp += sprintf(vp, "boardrev=%d", w & 0xff);
  1384. vp++;
  1386. vp += sprintf(vp, "cc=%d", (w >> 8) & 0xf);
  1387. vp++;
  1389. vp += sprintf(vp, "aa0=%d", (w >> 12) & 0x3);
  1390. vp++;
  1392. vp += sprintf(vp, "aa1=%d", (w >> 14) & 0x3);
  1393. vp++;
  1395. /* Word 52 is max power 0/1 */
  1396. w = b[52];
  1397. vp += sprintf(vp, "pa0maxpwr=%d", w & 0xff);
  1398. vp++;
  1399. vp += sprintf(vp, "pa1maxpwr=%d", (w >> 8) & 0xff);
  1400. vp++;
  1402. /* set the (wl) pa settings */
  1403. woff = 47; /* start of pa param's section */
  1405. for (i = 0; i < 5; i++) {
  1406. vp += sprintf(vp, "pa0b%d=%d", i, b[woff+i]);
  1407. vp++;
  1408. vp += sprintf(vp, "pa1b%d=%d", i, b[woff+i+6]);
  1409. vp++;
  1410. }
  1412. /* Word 58 is antenna gain 0/1 */
  1413. w = b[58];
  1414. vp += sprintf(vp, "ag0=%d", w & 0xff);
  1415. vp++;
  1417. vp += sprintf(vp, "ag1=%d", (w >> 8) & 0xff);
  1418. vp++;
  1420. /* set the oem string */
  1421. vp += sprintf(vp, "oem=%02x%02x%02x%02x%02x%02x%02x%02x",
  1422. ((b[woff] >> 8) & 0xff), (b[woff] & 0xff),
  1423. ((b[woff+1] >> 8) & 0xff), (b[woff+1] & 0xff),
  1424. ((b[woff+2] >> 8) & 0xff), (b[woff+2] & 0xff),
  1425. ((b[woff+3] >> 8) & 0xff), (b[woff+3] & 0xff));
  1426. vp++;
  1428. /* final nullbyte terminator */
  1429. *vp++ = '';
  1431. c = vp - base;
  1432. ASSERT(c <= VARS_MAX);
  1434. if (c == VARS_MAX) {
  1435. *vars = base;
  1436. } else {
  1437. vp = MALLOC(c);
  1438. ASSERT(vp);
  1439. bcopy(base, vp, c);
  1440. MFREE(base, VARS_MAX);
  1441. *vars = vp;
  1442. }
  1443. *count = c;
  1445. return (0);
  1446. }
  1448. /* set PCMCIA sprom command register */
  1449. static int
  1450. pcsr_cmd(sb_info_t *si, uint8 cmd)
  1451. {
  1452. uint8 status;
  1453. uint wait_cnt = 1000;
  1455. /* write sprom command register */
  1456. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_CS, &cmd, 1);
  1458. /* wait status */
  1459. while (wait_cnt--) {
  1460. OSL_PCMCIA_READ_ATTR(si->osh, SROM_CS, &status, 1);
  1461. if (status & SROM_DONE)
  1462. return 0;
  1463. }
  1464. return 1;
  1465. }
  1467. /* read a word from the PCMCIA srom */
  1468. static int
  1469. pcsr_read(sb_info_t *si, uint16 addr, uint16 *data)
  1470. {
  1471. uint8 addr_l, addr_h, data_l, data_h;
  1473. addr_l = (uint8)((addr * 2) & 0xff);
  1474. addr_h = (uint8)(((addr * 2) >> 8) & 0xff);
  1476. /* set address */
  1477. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_ADDRH, &addr_h, 1);
  1478. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_ADDRL, &addr_l, 1);
  1480. /* do read */
  1481. if (pcsr_cmd(si, SROM_READ))
  1482. return 1;
  1484. /* read data */
  1485. OSL_PCMCIA_READ_ATTR(si->osh, SROM_DATAH, &data_h, 1);
  1486. OSL_PCMCIA_READ_ATTR(si->osh, SROM_DATAL, &data_l, 1);
  1488. *data = (data_h << 8) | data_l;
  1489. return 0;
  1490. }
  1492. /* write a word to the PCMCIA srom */
  1493. static int
  1494. pcsr_write(sb_info_t *si, uint16 addr, uint16 data)
  1495. {
  1496. uint8 addr_l, addr_h, data_l, data_h;
  1498. addr_l = (uint8)((addr * 2) & 0xff);
  1499. addr_h = (uint8)(((addr * 2) >> 8) & 0xff);
  1500. data_l = (uint8)(data & 0xff);
  1501. data_h = (uint8)((data >> 8) & 0xff);
  1503. /* set address */
  1504. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_ADDRH, &addr_h, 1);
  1505. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_ADDRL, &addr_l, 1);
  1507. /* write data */
  1508. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_DATAH, &data_h, 1);
  1509. OSL_PCMCIA_WRITE_ATTR(si->osh, SROM_DATAL, &data_l, 1);
  1511. /* do write */
  1512. return pcsr_cmd(si, SROM_WRITE);
  1513. }
  1515. /* support only 16-bit word read from srom */
  1516. int
  1517. sromread(void *sbh, uint byteoff, uint nbytes, uint16 *buf)
  1518. {
  1519. void *srom;
  1520. uint i, off, nw;
  1521. sb_info_t *si = SB_INFO(sbh);
  1523. /* check input - 16-bit access only */
  1524. if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
  1525. return 1;
  1527. if (si->bus == PCI_BUS) {
  1528. srom = (void *)((uint)si->curmap + PCI_BAR0_SPROM_OFFSET);
  1529. if (spromread(srom, byteoff, buf, nbytes, FALSE))
  1530. return 1;
  1531. } else if (si->bus == PCMCIA_BUS) {
  1532. off = byteoff / 2;
  1533. nw = nbytes / 2;
  1534. for (i = 0; i < nw; i++) {
  1535. if (pcsr_read(si, off + i, buf + i))
  1536. return 1;
  1537. }
  1538. } else {
  1539. return 1;
  1540. }
  1542. return 0;
  1543. }
  1545. /* support only 16-bit word write into srom */
  1546. int
  1547. sromwrite(void *sbh, uint byteoff, uint nbytes, uint16 *buf)
  1548. {
  1549. uint16 *srom;
  1550. sb_info_t *si = SB_INFO(sbh);
  1551. uint i, off, nw, crc_range;
  1552. uint16 image[SPROM_SIZE], *p;
  1553. uint8 crc;
  1554. volatile uint32 val32;
  1556. /* check input - 16-bit access only */
  1557. if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
  1558. return 1;
  1560. crc_range = ((si->bus == PCMCIA_BUS) ? SPROM_SIZE : SPROM_CRC_RANGE) * 2;
  1562. /* if changes made inside crc cover range */
  1563. if (byteoff < crc_range) {
  1564. nw = (((byteoff + nbytes) > crc_range) ? byteoff + nbytes : crc_range) / 2;
  1565. /* read data including entire first 64 words from srom */
  1566. if (sromread(sbh, 0, nw * 2, image))
  1567. return 1;
  1568. /* make changes */
  1569. bcopy((void*)buf, (void*)&image[byteoff / 2], nbytes);
  1570. /* calculate crc */
  1571. htol16_buf(image, crc_range);
  1572. crc = ~crc8((uint8 *)image, crc_range - 1, CRC8_INIT_VALUE);
  1573. ltoh16_buf(image, crc_range);
  1574. image[(crc_range / 2) - 1] = (crc << 8) | (image[(crc_range / 2) - 1] & 0xff);
  1575. p = image;
  1576. off = 0;
  1577. } else {
  1578. p = buf;
  1579. off = byteoff / 2;
  1580. nw = nbytes / 2;
  1581. }
  1583. if (si->bus == PCI_BUS) {
  1584. srom = (uint16*)((uint)si->curmap + PCI_BAR0_SPROM_OFFSET);
  1585. /* enable writes to the SPROM */
  1586. val32 = OSL_PCI_READ_CONFIG(si->osh, PCI_SPROM_CONTROL, sizeof(uint32));
  1587. val32 |= SPROM_WRITEEN;
  1588. OSL_PCI_WRITE_CONFIG(si->osh, PCI_SPROM_CONTROL, sizeof(uint32), val32);
  1589. msecs(500);
  1590. /* write srom */
  1591. for (i = 0; i < nw; i++) {
  1592. W_REG(&srom[off + i], p[i]);
  1593. msecs(20);
  1594. }
  1595. /* disable writes to the SPROM */
  1596. OSL_PCI_WRITE_CONFIG(si->osh, PCI_SPROM_CONTROL, sizeof(uint32), val32 & ~SPROM_WRITEEN);
  1597. } else if (si->bus == PCMCIA_BUS) {
  1598. /* enable writes to the SPROM */
  1599. if (pcsr_cmd(si, SROM_WEN))
  1600. return 1;
  1601. msecs(500);
  1602. /* write srom */
  1603. for (i = 0; i < nw; i++) {
  1604. pcsr_write(si, off + i, p[i]);
  1605. msecs(20);
  1606. }
  1607. /* disable writes to the SPROM */
  1608. if (pcsr_cmd(si, SROM_WDS))
  1609. return 1;
  1610. } else {
  1611. return 1;
  1612. }
  1614. msecs(500);
  1615. return 0;
  1616. }
  1618. /*
  1619.  * "The sprom" in PCMCIA cards is simply the standard PCMCIA
  1620.  * CIS (Card Information Structure); so we have to parse the
  1621.  * CIS and extract from it into name=value pairs the information
  1622.  * we need: the mac address is a standard tuple; plus we add
  1623.  * vendor specific tuples for chip/revision ids, board revision,
  1624.  * country code lock, PA parameters and OEM space.
  1625.  * XXX: Should check a crc (there is a crc tuple that we could add).
  1626.  *
  1627.  * Return 0 on success, nonzero on error.
  1628.  */
  1629. int
  1630. parsecis(uint8 *cis, char **vars, int *count)
  1631. {
  1632. char eabuf[32];
  1633. char *vp, *base;
  1634. uint8 tup, tlen;
  1635. int i, j;
  1636. uint varsize;
  1637. bool ag_init = FALSE;
  1639. ASSERT(vars);
  1640. ASSERT(count);
  1642. base = vp = MALLOC(VARS_MAX);
  1643. ASSERT(vp);
  1645. i = 0;
  1646. do {
  1647. tup = cis[i++];
  1648. tlen = cis[i++];
  1650. switch (tup) {
  1651. case CISTPL_MANFID:
  1652. vp += sprintf(vp, "manfid=%d", (cis[i + 1] << 8) + cis[i]);
  1653. vp++;
  1654. vp += sprintf(vp, "prodid=%d", (cis[i + 3] << 8) + cis[i + 2]);
  1655. vp++;
  1656. break;
  1658. case CISTPL_FUNCE:
  1659. if (cis[i] == LAN_NID) {
  1660. ASSERT(cis[i + 1] == ETHER_ADDR_LEN);
  1661. bcm_ether_ntoa((uchar*)&cis[i + 2], eabuf);
  1662. vp += sprintf(vp, "il0macaddr=%s", eabuf);
  1663. vp++;
  1664. }
  1665. break;
  1667. case CISTPL_BRCM_HNBU:
  1668. switch (cis[i]) {
  1669. case HNBU_CHIPID:
  1670. vp += sprintf(vp, "vendid=%d", (cis[i + 2] << 8) + cis[i + 1]);
  1671. vp++;
  1672. vp += sprintf(vp, "devid=%d", (cis[i + 4] << 8) + cis[i + 3]);
  1673. vp++;
  1674. vp += sprintf(vp, "chiprev=%d", (cis[i + 6] << 8) + cis[i + 5]);
  1675. vp++;
  1676. break;
  1678. case HNBU_BOARDREV:
  1679. vp += sprintf(vp, "boardrev=%d", cis[i + 1]);
  1680. vp++;
  1681. break;
  1683. case HNBU_AA:
  1684. vp += sprintf(vp, "aa0=%d", cis[i + 1]);
  1685. vp++;
  1686. break;
  1688. case HNBU_AG:
  1689. vp += sprintf(vp, "ag0=%d", cis[i + 1]);
  1690. vp++;
  1691. ag_init = TRUE;
  1692. break;
  1694. case HNBU_CC:
  1695. vp += sprintf(vp, "cc=%d", cis[i + 1]);
  1696. vp++;
  1697. break;
  1699. case HNBU_PAPARMS:
  1700. for (j = 0; j < 5; j++) {
  1701. vp += sprintf(vp, "pa0b%d=%d", j,
  1702. (cis[i + (j * 2) + 2] << 8) + cis[i + (j * 2) + 1]);
  1703. vp++;
  1704. }
  1705. vp += sprintf(vp, "pa0maxpwr=%d", cis[i + 11]);
  1706. vp++;
  1707. break;
  1709. case HNBU_OEM:
  1710. vp += sprintf(vp, "oem=%02x%02x%02x%02x%02x%02x%02x%02x",
  1711. cis[i + 1], cis[i + 2], cis[i + 3], cis[i + 4],
  1712. cis[i + 5], cis[i + 6], cis[i + 7], cis[i + 8]);
  1713. vp++;
  1714. break;
  1715. }
  1716. break;
  1718. }
  1719. i += tlen;
  1720. } while (tup != 0xff);
  1722. /* if there is no antenna gain field, set default */
  1723. if (ag_init == FALSE) {
  1724. vp += sprintf(vp, "ag0=%d", 0xff);
  1725. vp++;
  1726. }
  1728. /* final nullbyte terminator */
  1729. *vp++ = '';
  1730. varsize = (uint)vp - (uint)base;
  1732. ASSERT(varsize < VARS_MAX);
  1734. if (varsize == VARS_MAX) {
  1735. *vars = base;
  1736. } else {
  1737. vp = MALLOC(varsize);
  1738. ASSERT(vp);
  1739. bcopy(base, vp, varsize);
  1740. MFREE(base, VARS_MAX);
  1741. *vars = vp;
  1742. }
  1743. *count = varsize;
  1745. return (0);
  1746. }
  1748. /*
  1749.  * Read the cis and call parsecis to initialize the vars.
  1750.  * Return 0 on success, nonzero on error.
  1751.  */
  1752. static int
  1753. cisinitvars(sb_info_t *si, char **vars, int *count)
  1754. {
  1755. uint8 *cis = NULL;
  1756. int rc;
  1758. if ((cis = MALLOC(CIS_SIZE)) == NULL)
  1759. return (-1);
  1761. OSL_PCMCIA_READ_ATTR(si->osh, 0, cis, CIS_SIZE);
  1763. rc = parsecis(cis, vars, count);
  1765. MFREE(cis, CIS_SIZE);
  1767. return (rc);
  1768. }
  1770. /*
  1771.  * Initialize the vars from the right source for this platform.
  1772.  * Return 0 on success, nonzero on error.
  1773.  */
  1774. static int
  1775. sb_initvars(sb_info_t *si, char **vars, int *count)
  1776. {
  1777. if (vars == NULL)
  1778. return (0);
  1780. switch (si->bus) {
  1781. case SB_BUS:
  1782. /* These two could be asserts ... */
  1783. *vars = NULL;
  1784. *count = 0;
  1785. return(0);
  1787. case PCI_BUS:
  1788. return(srominitvars(si, vars, count));
  1790. case PCMCIA_BUS:
  1791. return(cisinitvars(si, vars, count));
  1793. default:
  1794. ASSERT(0);
  1795. }
  1796. return (-1);
  1797. }
  1799. #ifndef BROADCOM_BSP
  1800. /*
  1801.  * Search the vars for a specific one and return its value.
  1802.  * Returns NULL if not found.
  1803.  */
  1804. char*
  1805. getvar(char *vars, char *name)
  1806. {
  1807. char *s;
  1808. int len;
  1810. len = strlen(name);
  1812. if (vars == NULL)
  1813. return(nvram_get(name));
  1815. for (s = vars; s && *s; ) {
  1816. if ((bcmp(s, name, len) == 0) && (s[len] == '='))
  1817. return (&s[len+1]);
  1819. while (*s++)
  1820. ;
  1821. }
  1822. return (NULL);
  1823. }
  1825. /*
  1826.  * Search the vars for a specific one and return its value as
  1827.  * an integer. Returns 0 if not found.
  1828.  */
  1829. int
  1830. getintvar(char *vars, char *name)
  1831. {
  1832. char *val;
  1834. if ((val = getvar(vars, name)) == NULL)
  1835. return (0);
  1837. return (bcm_strtoul(val, NULL, 0));
  1838. }
  1839. #endif
  1841. /* change logical "focus" to the gpio core for optimized access */
  1842. void*
  1843. sb_gpiosetcore(void *sbh)
  1844. {
  1845. sb_info_t *si;
  1847. si = SB_INFO(sbh);
  1849. return (sb_setcoreidx(sbh, si->gpioidx));
  1850. }
  1852. /* mask&set gpiocontrol bits */
  1853. uint32
  1854. sb_gpiocontrol(void *sbh, uint32 mask, uint32 val)
  1855. {
  1856. sb_info_t *si;
  1857. uint regoff;
  1859. si = SB_INFO(sbh);
  1860. regoff = 0;
  1862. switch (si->gpioid) {
  1863. case SB_CC:
  1864. regoff = OFFSETOF(chipcregs_t, gpiocontrol);
  1865. break;
  1867. case SB_PCI:
  1868. regoff = OFFSETOF(sbpciregs_t, gpiocontrol);
  1869. break;
  1871. case SB_EXTIF:
  1872. return (0);
  1873. }
  1875. return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
  1876. }
  1878. /* mask&set gpio output enable bits */
  1879. uint32
  1880. sb_gpioouten(void *sbh, uint32 mask, uint32 val)
  1881. {
  1882. sb_info_t *si;
  1883. uint regoff;
  1885. si = SB_INFO(sbh);
  1886. regoff = 0;
  1888. switch (si->gpioid) {
  1889. case SB_CC:
  1890. regoff = OFFSETOF(chipcregs_t, gpioouten);
  1891. break;
  1893. case SB_PCI:
  1894. regoff = OFFSETOF(sbpciregs_t, gpioouten);
  1895. break;
  1897. case SB_EXTIF:
  1898. regoff = OFFSETOF(extifregs_t, gpio[0].outen);
  1899. break;
  1900. }
  1902. return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
  1903. }
  1905. /* mask&set gpio output bits */
  1906. uint32
  1907. sb_gpioout(void *sbh, uint32 mask, uint32 val)
  1908. {
  1909. sb_info_t *si;
  1910. uint regoff;
  1912. si = SB_INFO(sbh);
  1913. regoff = 0;
  1915. switch (si->gpioid) {
  1916. case SB_CC:
  1917. regoff = OFFSETOF(chipcregs_t, gpioout);
  1918. break;
  1920. case SB_PCI:
  1921. regoff = OFFSETOF(sbpciregs_t, gpioout);
  1922. break;
  1924. case SB_EXTIF:
  1925. regoff = OFFSETOF(extifregs_t, gpio[0].out);
  1926. break;
  1927. }
  1929. return (sb_corereg(sbh, si->gpioidx, regoff, mask, val));
  1930. }
  1932. /* return the current gpioin register value */
  1933. uint32
  1934. sb_gpioin(void *sbh)
  1935. {
  1936. sb_info_t *si;
  1937. uint regoff;
  1939. si = SB_INFO(sbh);
  1940. regoff = 0;
  1942. switch (si->gpioid) {
  1943. case SB_CC:
  1944. regoff = OFFSETOF(chipcregs_t, gpioin);
  1945. break;
  1947. case SB_PCI:
  1948. regoff = OFFSETOF(sbpciregs_t, gpioin);
  1949. break;
  1951. case SB_EXTIF:
  1952. regoff = OFFSETOF(extifregs_t, gpioin);
  1953. break;
  1954. }
  1956. return (sb_corereg(sbh, si->gpioidx, regoff, 0, 0));
  1957. }
  1959. void
  1960. sb_dump(void *sbh, char *buf)
  1961. {
  1962. sb_info_t *si;
  1963. uint i;
  1965. si = SB_INFO(sbh);
  1967. buf += sprintf(buf, "si 0x%x chip 0x%x chiprev 0x%x board 0x%x boardvendor 0x%x bus %dn",
  1968. (uint)si, si->chip, si->chiprev, si->board, si->boardvendor, si->bus);
  1969. buf += sprintf(buf, "osh 0x%x curmap 0x%x origregs 0x%x origcoreidx %dn",
  1970. (uint)si->osh, (uint)si->curmap, (uint)si->origregs, si->origcoreidx);
  1971. buf += sprintf(buf, "pciidx %d gpioidx %d gpioid 0x%xn",
  1972. si->pciidx, si->gpioidx, si->gpioid);
  1973. buf += sprintf(buf, "cores:  ");
  1974. for (i = 0; i < si->numcores; i++)
  1975. buf += sprintf(buf, "0x%x ", si->coreid[i]);
  1976. buf += sprintf(buf, "n");
  1977. }
  1979. /* Doing really long delays with DELAY breaks Linux:
  1980.  * it claims they would not be accurate on fast machines.
  1981.  */
  1982. static void
  1983. msecs(uint ms)
  1984. {
  1985. uint i;
  1987. for (i = 0; i < ms; i++) {
  1988. OSL_DELAY(1000);
  1989. }
  1990. }
  1992. #ifdef BROADCOM_BSP
  1993. void
  1994. gpioIntInit(void)
  1995. {
  1996.     extifregs_t *eir;
  1997.     void *sbh;
  1999.     sbh = sb_kattach (BCM4710_DEVICE_ID, 0);
  2000.     ASSERT (sbh);
  2002.     eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0);
  2004.     W_REG(&eir->gpio[0].out, 0);
  2005.     W_REG(&eir->gpio[0].outen, 0x44);
  2006.     OSL_DELAY(2000);
  2007.     W_REG(&eir->gpio[0].out, 0x44);
  2008.     W_REG(&eir->gpio[0].outen, 0);
  2010.     /* Setup gpio bit 1 to be the external uart interrupt */
  2011.     W_REG(&eir->gpiointpolarity, 0);    /* UART int is active high */
  2012.     W_REG(&eir->gpiointmask, 2);        /* bit 1 */
  2013.     sb_detach (sbh);
  2014. }
  2015. #endif
  2017. /* ROBO stuff */
  2018. #ifdef ROBO
  2019. #include "if_robo.h"
  2020. #include "if_robo.c"
  2021. #endif