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

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

VxWorks

开发平台：

C/C++

etc47xx.c：源码内容
  1. /*
  2.     EXTERNAL SOURCE RELEASE on 12/03/2001 3.0 - Subject to change without notice.
  4. */
  5. /*
  6.     Copyright 2001, Broadcom Corporation
  7.     All Rights Reserved.
  8.     
  9.     This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
  10.     the contents of this file may not be disclosed to third parties, copied or
  11.     duplicated in any form, in whole or in part, without the prior written
  12.     permission of Broadcom Corporation.
  13. */
  14. /*
  15.  * Broadcom Home Networking Division 10/100 Mbit/s Ethernet core.
  16.  *
  17.  * This file implements the chip-specific routines
  18.  * for Broadcom HNBU Sonics SiliconBackplane enet cores.
  19.  *
  20.  * Copyright(c) 2001 Broadcom, Inc.
  21.  * $Id: etc47xx.c,v 1.1 Broadcom SDK $
  22.  */
  24. #include <osl.h>
  25. #include <bcmendian.h>
  26. #include <ethernet.h>
  27. #include <hnddma.h>
  28. #include <et_dbg.h>
  29. #include <sbconfig.h>
  30. #include <sbutils.h>
  31. #include <bcmenet47xx.h>
  32. #include <bcmutils.h>
  33. #ifndef BROADCOM_BSP
  34. #include <bcmnvram.h>
  35. #endif
  36. #include <et_export.h> /* for et_phyxx() routines */
  38. struct bcm4xxx; /* forward declaration */
  39. #define ch_t struct bcm4xxx
  40. #include <etc.h>
  42. #ifdef BROADCOM_BSP
  43. STATUS (* _func_etEnetAddrGet)
  44.     (char *dev,int unit,unsigned char *pMac) = NULL;
  45. #else
  46. #define NVRAM_GET(name, vars) nvram_get(name)
  47. #endif
  49. /* private chip state */
  50. struct bcm4xxx {
  51. void  *et; /* pointer to et private state */
  52. etc_info_t *etc; /* pointer to etc public state */
  54. bcmenetregs_t *regs; /* pointer to chip registers */
  55. void  *dev; /* device handle */
  57. void  *etphy; /* pointer to et for shared mdc/mdio contortion */
  59. uint32 intstatus; /* saved interrupt condition bits */
  60. uint32 intmask; /* current software interrupt mask */
  62. void  *di; /* dma engine software state */
  64. bool mibgood; /* true once mib registers have been cleared */
  65.         void            *sbh;           /* sb utils handle */
  67.         char            *vars;          /* sprom name=value */
  68.         int             vars_size;
  70.         void            *robo;          /* robo utils handle */
  71. };
  73. static struct bcm4xxx *mpCh[2];
  74. /* local prototypes */
  75. static bool chipid(uint vendor, uint device);
  76. static void *chipattach(etc_info_t *etc, void *dev, void *regsva);
  77. static void chipdetach(ch_t *ch);
  78. static void chipreset(ch_t *ch);
  79. static void chipinit(ch_t *ch, bool full);
  80. static void chiptx(ch_t *ch, void *p);
  81. static void *chiprx(ch_t *ch);
  82. static void chiprxfill(ch_t *ch);
  83. static int chipgetintrevents(ch_t *ch);
  84. static bool chiperrors(ch_t *ch);
  85. static void chipintrson(ch_t *ch);
  86. static void chipintrsoff(ch_t *ch);
  87. static void chiptxreclaim(ch_t *ch, bool all);
  88. static void chiprxreclaim(ch_t *ch);
  89. static void chipstatsupd(ch_t *ch);
  90. static void chipenablepme(ch_t *ch);
  91. static void chipdisablepme(ch_t *ch);
  92. static void chipphyreset(ch_t *ch, uint phyaddr);
  93. static void chipphyinit(ch_t *ch, uint phyaddr);
  94. static uint16 chipphyrd(ch_t *ch, uint phyaddr, uint reg);
  95. static void chipdump(ch_t *ch, char *buf);
  96. static void chiplongname(ch_t *ch, char *buf, uint bufsize);
  97. static void chipduplexupd(ch_t *ch);
  98. static void chipwrcam(struct bcm4xxx *ch, struct ether_addr *ea, uint camindex);
  99. static void chipphywr(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v);
  100. static void chipphyor(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v);
  101. static void chipphyand(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v);
  102. static void chipphyforce(struct bcm4xxx *ch, uint phyaddr);
  103. static void chipphyadvertise(struct bcm4xxx *ch, uint phyaddr);
  104. static char *chipdumpregs(struct bcm4xxx *ch, bcmenetregs_t *regs, char *buf);
  106. /* chip interrupt bit error summary */
  107. #define I_ERRORS (I_PC | I_PD | I_DE | I_RU | I_RO | I_XU)
  108. #define DEF_INTMASK (I_XI | I_RI | I_ERRORS)
  110. struct chops bcm47xx_et_chops = {
  111. chipid,
  112. chipattach,
  113. chipdetach,
  114. chipreset,
  115. chipinit,
  116. chiptx,
  117. chiprx,
  118. chiprxfill,
  119. chipgetintrevents,
  120. chiperrors,
  121. chipintrson,
  122. chipintrsoff,
  123. chiptxreclaim,
  124. chiprxreclaim,
  125. chipstatsupd,
  126.         chipenablepme,
  127.         chipdisablepme,
  128. chipphyreset,
  129. chipphyrd,
  130. chipphywr,
  131. chipdump,
  132. chiplongname,
  133. chipduplexupd
  134. };
  136. static uint devices[] = {
  137. BCM47XX_ENET_ID,
  138. 0x0000 };
  140. static bool
  141. chipid(uint vendor, uint device)
  142. {
  143. int i;
  145. if (vendor != VENDOR_BROADCOM)
  146. return (FALSE);
  148. for (i = 0; devices[i]; i++) {
  149. if (device == devices[i])
  150. return (TRUE);
  151. }
  152. return (FALSE);
  153. }
  155. static void*
  156. chipattach(etc_info_t *etc, void *dev, void *regsva)
  157. {
  158. struct bcm4xxx *ch;
  159. bcmenetregs_t *regs;
  160. char ourname[8];
  161. uint ddoffset, dataoffset;
  162. #ifndef BROADCOM_BSP
  163. char name[16];
  164. char *var;
  165. #endif
  167. ET_TRACE(("et%d: chipattach: regsva 0x%xn", etc->unit, (uint)regsva));
  169. if ((ch = (struct bcm4xxx*) MALLOC(sizeof (struct bcm4xxx))) == NULL) {
  170. ET_ERROR(("et%d: chipattach: malloc failed!n", etc->unit));
  171. return (NULL);
  172. }
  173. bzero((char*)ch, sizeof (struct bcm4xxx));
  175.         ch->etc = etc;
  176.         ch->et = etc->et;
  178.         regs = (bcmenetregs_t*) regsva;
  179.         ch->regs = regs;
  180.         ch->dev = dev;
  182.         /* get sb handle */
  183.         if ((ch->sbh = sb_attach(etc->deviceid, ch->dev, regsva, &ch->vars, &ch->vars_size)) == NULL) {
  184.                 ET_ERROR(("et%d: chipattach: sb_attach errorn", etc->unit));
  185.                 goto fail;
  186.         }
  188.         ASSERT(sb_coreid(ch->sbh) == SB_ENET);
  190.         etc->chip = sb_chip(ch->sbh);
  191.         etc->chiprev = sb_chiprev(ch->sbh);
  192.         etc->nicmode = !(sb_bus(ch->sbh) == SB_BUS);
  193.         etc->coreunit = sb_coreunit(ch->sbh);
  195.         /* configure pci core */
  196.         sb_pci_setup(ch->sbh, &ddoffset, (1 << sb_coreidx(ch->sbh)));
  197.         dataoffset = ddoffset;
  199. #if defined(__mips__) && defined(IL_BIGENDIAN)
  200.         /* use sdram swapped region for data buffers but not dma descriptors */
  201.         /* XXX this assumes that we are running on a 47xx mips with a swap window at 0x1 000000 */
  202.         dataoffset |= SB_SDRAM_SWAPPED;
  203. #endif
  205. /* dma attach */
  206. if ((ch->di = dma_attach(etc->et, dev, ourname, &regs->dmaregs,
  207.             NTXD, NRXD, RXBUFSZ, NRXBUFPOST, HWRXOFF, ddoffset, dataoffset,
  208.             &et_msg_level)) == NULL) {
  209. ET_ERROR(("et%d: chipattach: dma_attach failedn", etc->unit));
  210. goto fail;
  211. }
  212. etc->txavail = (uint*) dma_getvar(ch->di, "&txavail");
  215. /* get our local ether addr */
  217. #ifdef BROADCOM_BSP
  218.         if (_func_etEnetAddrGet == NULL || _func_etEnetAddrGet ("et", etc->unit, 
  219.             (unsigned char *) &etc->perm_etheraddr) != OK)
  220.             {
  221.     ET_ERROR(("et%d: chipattach: MAC address not foundn", etc->unit));
  222.             goto fail;
  223.             }
  224. #else
  225. sprintf(name, "et%dmacaddr", etc->coreunit);
  226. if ((var = NVRAM_GET(name, ch->vars)) == NULL) {
  227. ET_ERROR(("et%d: chipattach: NVRAM_GET(%s) not foundn", etc->unit, name));
  228. goto fail;
  229. }
  231. bcm_ether_atoe(var, (uchar*) &etc->perm_etheraddr);
  232. #endif  /* BROADCOM_BSP */
  234. if (ETHER_ISNULLADDR(&etc->perm_etheraddr)) {
  235. #ifndef BROADCOM_BSP
  236. ET_ERROR(("et%d: chipattach: invalid format: %s=%sn", etc->unit, name, var));
  237. #endif
  238. goto fail;
  239. }
  240. bcopy((char*)&etc->perm_etheraddr, (char*)&etc->cur_etheraddr, ETHER_ADDR_LEN);
  242. /*
  243.  * Rather than scan the mdio space looking for phys that
  244.  * respond and then guessing which one is ours and which
  245.  * might be used in the dualphy case by another emac,
  246.  * we instead explicitly require the environment var
  247.  * "et<coreunit>phyaddr=<val>".
  248.  */
  250. /* get our phyaddr value */
  252. #ifdef BROADCOM_BSP
  253.         if (_func_etEnetAddrGet == NULL || _func_etEnetAddrGet ("phy", etc->unit, 
  254.             (unsigned char *) &etc->phyaddr) != OK)
  255.             {
  256.     ET_ERROR(("et%d: chipattach: PHY address not foundn", etc->unit));
  257.             goto fail;
  258.             }
  259. #else
  260. sprintf(name, "et%dphyaddr", etc->coreunit);
  261. if ((var = NVRAM_GET(name, ch->vars)) == NULL) {
  262. ET_ERROR(("et%d: chipattach: NVRAM_GET(%s) not foundn", etc->unit, name));
  263. goto fail;
  264. }
  265. etc->phyaddr = bcm_atoi(var);
  266. #endif
  268. /* special 5bit phyaddr value indicating no phy present */
  269. if (etc->phyaddr == PHY_NONE) {
  270. ET_ERROR(("et%d: chipattach: phy not presentn", etc->unit));
  271. goto fail;
  272. }
  274. /* get our mdc/mdio port number */
  275. #ifdef BROADCOM_BSP
  276.         if (_func_etEnetAddrGet == NULL || _func_etEnetAddrGet ("mdc", etc->unit, 
  277.             (unsigned char *) &etc->mdcport) != OK)
  278.             {
  279.     ET_ERROR(("et%d: chipattach: MDC port not foundn", etc->unit));
  280.             goto fail;
  281.             }
  282. #else
  283. sprintf(name, "et%dmdcport", etc->coreunit);
  284. if ((var = NVRAM_GET(name, ch->vars)) == NULL) {
  285. ET_ERROR(("et%d: chipattach: NVRAM_GET(%s) not foundn", etc->unit, name));
  286. goto fail;
  287. }
  288. etc->mdcport = bcm_atoi(var);
  289. #endif
  291. /* reset the enet core */
  292. chipreset(ch);
  294. /* set default sofware intmask */
  295. ch->intmask = DEF_INTMASK;
  297. /*
  298.  * For the 5222 dual phy shared mdio contortion, our phy is
  299.  * on someone elses mdio pins.  This other enet enet
  300.  * may not yet be attached so we must defer the et_phyfind().
  301.  */
  302. /* if local phy: reset it once now */
  303. if (etc->mdcport == etc->coreunit)
  304. chipphyreset(ch, etc->phyaddr);
  305. mpCh[etc->unit] = ch;
  306. return ((void*) ch);
  308. fail:
  309. chipdetach(ch);
  310. return (NULL);
  311. }
  313. static void
  314. chipdetach(struct bcm4xxx *ch)
  315. {
  316. if (ch == NULL)
  317. return;
  319. ET_TRACE(("et%d: chipdetachn", ch->etc->unit));
  321. /* put the core back into reset */
  322.         sb_core_disable(ch->sbh, 0);
  324.         /* free dma state */
  325.         dma_detach(ch->di);
  326.         ch->di = NULL;
  328.         /* free sb handle */
  329.         sb_detach(ch->sbh);
  330.         ch->sbh = NULL;
  332.         /* free vars */
  333.         if (ch->vars)
  334.                 MFREE(ch->vars, ch->vars_size);
  336.         /* free chip private state */
  337.         MFREE(ch, sizeof (struct bcm4xxx));
  338. }
  340. static void
  341. chiplongname(struct bcm4xxx *ch, char *buf, uint bufsize)
  342. {
  343. char *s = "Broadcom BCM47xx 10/100 Mbps Ethernet Controller";
  345. strncpy(buf, s, bufsize);
  346. buf[bufsize - 1] = '';
  347. }
  349. static void
  350. chipdump(struct bcm4xxx *ch, char *buf)
  351. {
  352. buf += sprintf(buf, "regs 0x%x etphy 0x%x ch->intstatus 0x%x intmask 0x%x n",
  353. (uint)ch->regs, (uint)ch->etphy, ch->intstatus, ch->intmask);
  354. buf += sprintf(buf, "n");
  356. /* dma engine state */
  357. buf = dma_dump(ch->di, buf);
  358. buf += sprintf(buf, "n");
  360. /* registers */
  361. buf = chipdumpregs(ch, ch->regs, buf);
  362. }
  364. #define PRREG(name) buf += sprintf(buf, #name " 0x%x ", R_REG(&regs->name))
  365. #define PRMIBREG(name) buf += sprintf(buf, #name " 0x%x ", R_REG(&regs->mib.name))
  367. static char*
  368. chipdumpregs(struct bcm4xxx *ch, bcmenetregs_t *regs, char *buf)
  369. {
  370. uint phyaddr;
  372. phyaddr = ch->etc->phyaddr;
  374. PRREG(devcontrol); PRREG(biststatus); PRREG(wakeuplength);
  375. buf += sprintf(buf, "n");
  376. PRREG(intstatus); PRREG(intmask); PRREG(gptimer);
  377. buf += sprintf(buf, "n");
  378. PRREG(emactxmaxburstlen); PRREG(emacrxmaxburstlen);
  379. PRREG(emaccontrol); PRREG(emacflowcontrol);
  380. buf += sprintf(buf, "n");
  381. PRREG(intrecvlazy);
  382. buf += sprintf(buf, "n");
  384. /* emac registers */
  385. PRREG(rxconfig); PRREG(rxmaxlength); PRREG(txmaxlength);
  386. buf += sprintf(buf, "n");
  387. PRREG(mdiocontrol); PRREG(camcontrol); PRREG(enetcontrol);
  388. buf += sprintf(buf, "n");
  389. PRREG(txcontrol); PRREG(txwatermark); PRREG(mibcontrol);
  390. buf += sprintf(buf, "n");
  392. /* mib registers */
  393. PRMIBREG(tx_good_octets); PRMIBREG(tx_good_pkts); PRMIBREG(tx_octets); PRMIBREG(tx_pkts);
  394. buf += sprintf(buf, "n");
  395. PRMIBREG(tx_broadcast_pkts); PRMIBREG(tx_multicast_pkts);
  396. buf += sprintf(buf, "n");
  397. PRMIBREG(tx_jabber_pkts); PRMIBREG(tx_oversize_pkts); PRMIBREG(tx_fragment_pkts);
  398. buf += sprintf(buf, "n");
  399. PRMIBREG(tx_underruns); PRMIBREG(tx_total_cols); PRMIBREG(tx_single_cols);
  400. buf += sprintf(buf, "n");
  401. PRMIBREG(tx_multiple_cols); PRMIBREG(tx_excessive_cols); PRMIBREG(tx_late_cols);
  402. buf += sprintf(buf, "n");
  403. PRMIBREG(tx_defered); PRMIBREG(tx_carrier_lost); PRMIBREG(tx_pause_pkts);
  404. buf += sprintf(buf, "n");
  406. PRMIBREG(rx_good_octets); PRMIBREG(rx_good_pkts); PRMIBREG(rx_octets); PRMIBREG(rx_pkts);
  407. buf += sprintf(buf, "n");
  408. PRMIBREG(rx_broadcast_pkts); PRMIBREG(rx_multicast_pkts);
  409. buf += sprintf(buf, "n");
  410. PRMIBREG(rx_jabber_pkts); PRMIBREG(rx_oversize_pkts); PRMIBREG(rx_fragment_pkts);
  411. buf += sprintf(buf, "n");
  412. PRMIBREG(rx_missed_pkts); PRMIBREG(rx_crc_align_errs); PRMIBREG(rx_undersize);
  413. buf += sprintf(buf, "n");
  414. PRMIBREG(rx_crc_errs); PRMIBREG(rx_align_errs); PRMIBREG(rx_symbol_errs);
  415. buf += sprintf(buf, "n");
  416. PRMIBREG(rx_pause_pkts); PRMIBREG(rx_nonpause_pkts);
  417. buf += sprintf(buf, "n");
  418. buf += sprintf(buf, "n");
  420. if (phyaddr != PHY_NOMDC) {
  421. /* print a few interesting phy registers */
  422. buf += sprintf(buf, "phy0 0x%x phy1 0x%x phy2 0x%x phy3 0x%xn",
  423.        chipphyrd(ch, phyaddr, 0),
  424.        chipphyrd(ch, phyaddr, 1),
  425.        chipphyrd(ch, phyaddr, 2),
  426.        chipphyrd(ch, phyaddr, 3));
  427. buf += sprintf(buf, "phy4 0x%x phy5 0x%x phy24 0x%x phy25 0x%xn",
  428.        chipphyrd(ch, phyaddr, 4),
  429.        chipphyrd(ch, phyaddr, 5),
  430.        chipphyrd(ch, phyaddr, 24),
  431.        chipphyrd(ch, phyaddr, 25));
  432. }
  434. return (buf);
  435. }
  437. static void
  438. chipreset(struct bcm4xxx *ch)
  439. {
  440. bcmenetregs_t *regs;
  441.         uint32 offset;
  443. ET_TRACE(("et%d: chipresetn", ch->etc->unit));
  445. regs = ch->regs;
  447.         if (!sb_iscoreup(ch->sbh)) {
  448.                 if (!ch->etc->nicmode)
  449.                         sb_pci_setup(ch->sbh, &offset, (1 << sb_coreidx(ch->sbh)));
  450.                 /* power on reset: reset the enet core */
  451.                 sb_core_reset(ch->sbh, 0);
  452.                 goto chipinreset;
  453.         }
  455. /* read counters before resetting the chip */
  456. if (ch->mibgood)
  457. chipstatsupd(ch);
  459. /* reset the dma engines */
  460. dma_txreset(ch->di);
  461. dma_rxreset(ch->di);
  463.         /* reset core */
  464.         /* 4402A0 requires PR3714 workaround */
  465.         if ((ch->etc->deviceid == BCM4402_ENET_ID) && (ch->etc->chiprev == 0)) {
  466.                 W_REG(&regs->enetcontrol, EC_ES);
  467.                 SPINWAIT((R_REG(&regs->enetcontrol) & EC_ES), 100);
  468.                 ASSERT((R_REG(&regs->enetcontrol) & EC_ES) == 0);
  469.                 W_REG(&regs->intmask, 0);
  470.                 W_REG(&regs->intstatus, R_REG(&regs->intstatus));
  471.                 ASSERT(R_REG(&regs->intstatus) == 0);
  472.                 W_REG(&regs->biststatus, 0);
  473.                 W_REG(&regs->wakeuplength, 0);
  474.                 W_REG(&regs->gptimer, 0);
  475.                 W_REG(&regs->emaccontrol, 0);
  476.                 W_REG(&regs->emacflowcontrol, 0);
  477.                 W_REG(&regs->intrecvlazy, 0);
  478.         } else
  479.                 sb_core_reset(ch->sbh, 0);
  481. chipinreset:
  483. /* must clear mib registers by hand */
  484. W_REG(&regs->mibcontrol, EMC_RZ);
  485. (void) R_REG(&regs->mib.tx_broadcast_pkts);
  486. (void) R_REG(&regs->mib.tx_multicast_pkts);
  487. (void) R_REG(&regs->mib.tx_len_64);
  488. (void) R_REG(&regs->mib.tx_len_65_to_127);
  489. (void) R_REG(&regs->mib.tx_len_128_to_255);
  490. (void) R_REG(&regs->mib.tx_len_256_to_511);
  491. (void) R_REG(&regs->mib.tx_len_512_to_1023);
  492. (void) R_REG(&regs->mib.tx_len_1024_to_max);
  493. (void) R_REG(&regs->mib.tx_jabber_pkts);
  494. (void) R_REG(&regs->mib.tx_oversize_pkts);
  495. (void) R_REG(&regs->mib.tx_fragment_pkts);
  496. (void) R_REG(&regs->mib.tx_underruns);
  497. (void) R_REG(&regs->mib.tx_total_cols);
  498. (void) R_REG(&regs->mib.tx_single_cols);
  499. (void) R_REG(&regs->mib.tx_multiple_cols);
  500. (void) R_REG(&regs->mib.tx_excessive_cols);
  501. (void) R_REG(&regs->mib.tx_late_cols);
  502. (void) R_REG(&regs->mib.tx_defered);
  503. (void) R_REG(&regs->mib.tx_carrier_lost);
  504. (void) R_REG(&regs->mib.tx_pause_pkts);
  505. (void) R_REG(&regs->mib.rx_broadcast_pkts);
  506. (void) R_REG(&regs->mib.rx_multicast_pkts);
  507. (void) R_REG(&regs->mib.rx_len_64);
  508. (void) R_REG(&regs->mib.rx_len_65_to_127);
  509. (void) R_REG(&regs->mib.rx_len_128_to_255);
  510. (void) R_REG(&regs->mib.rx_len_256_to_511);
  511. (void) R_REG(&regs->mib.rx_len_512_to_1023);
  512. (void) R_REG(&regs->mib.rx_len_1024_to_max);
  513. (void) R_REG(&regs->mib.rx_jabber_pkts);
  514. (void) R_REG(&regs->mib.rx_oversize_pkts);
  515. (void) R_REG(&regs->mib.rx_fragment_pkts);
  516. (void) R_REG(&regs->mib.rx_missed_pkts);
  517. (void) R_REG(&regs->mib.rx_crc_align_errs);
  518. (void) R_REG(&regs->mib.rx_undersize);
  519. (void) R_REG(&regs->mib.rx_crc_errs);
  520. (void) R_REG(&regs->mib.rx_align_errs);
  521. (void) R_REG(&regs->mib.rx_symbol_errs);
  522. (void) R_REG(&regs->mib.rx_pause_pkts);
  523. (void) R_REG(&regs->mib.rx_nonpause_pkts);
  524. ch->mibgood = TRUE;
  526. /*
  527.  * We want the phy registers to be accessible even when
  528.  * the driver is "downed" so initialize MDC preamble, frequency,
  529.  * and whether internal or external phy here.
  530.  */
  531.         if (ch->etc->deviceid == BCM47XX_ENET_ID) {
  532.                 /* 4710A0 has a 100Mhz SB clock and external phy */
  533.                 W_REG(&regs->mdiocontrol, 0x94);
  534.         } else if (ch->etc->deviceid == BCM4402_ENET_ID) {
  535.                 /* 4402 has 62.5Mhz SB clock and internal phy */
  536.                 W_REG(&regs->mdiocontrol, 0x8d);
  537. #ifdef BCMINTERNAL
  538.         } else if ((ch->etc->deviceid == BCM4307_ENET_ID) ||
  539.                    (ch->etc->deviceid == BCM4309_ENET_ID)) {
  540.                 /* 4307/4309 have 88Mhz SB clock and external phy */
  541.                 W_REG(&regs->mdiocontrol, 0x92);
  542.         } else if (ch->etc->deviceid == BCM4310_ENET_ID) {
  543.                 /* 4310 has a 124.8Mhz SB clock and external phy */
  544.                 W_REG(&regs->mdiocontrol, 0x99);
  545. #else
  546.         } else if (ch->etc->deviceid == BCM4307_ENET_ID) {
  547.                 /* 4307 has 88 MHz SB clock and external phy */
  548.                 W_REG(&regs->mdiocontrol, 0x92);
  549. #endif
  550.         } else
  551.                 ASSERT(0);
  553. /* some chips have internal phy, some don't */
  554. if (!(R_REG(&regs->devcontrol) & DC_IP)) {
  555. W_REG(&regs->enetcontrol, EC_EP);
  556. } else if (R_REG(&regs->devcontrol) & DC_ER) {
  557. AND_REG(&regs->devcontrol, ~DC_ER);
  558. OSL_DELAY(100);
  559. chipphyinit(ch, ch->etc->phyaddr);
  560. }
  562. /* clear persistent sw intstatus */
  563. ch->intstatus = 0;
  564. }
  566. /*
  567.  * Initialize all the chip registers.  If dma mode, init tx and rx dma engines
  568.  * but leave the devcontrol tx and rx (fifos) disabled.
  569.  */
  570. static void
  571. chipinit(struct bcm4xxx *ch, bool full)
  572. {
  573. etc_info_t *etc;
  574. bcmenetregs_t *regs;
  575. uint idx;
  576. uint i;
  578. regs = ch->regs;
  579. etc = ch->etc;
  580. idx = 0;
  582. ET_TRACE(("et%d: chipinitn", etc->unit));
  584. /* enable crc32 generation */
  585. OR_REG(&regs->emaccontrol, EMC_CG);
  587. /* enable one rx interrupt per received frame */
  588. W_REG(&regs->intrecvlazy, (1 << IRL_FC_SHIFT));
  590. /* enable 802.3x tx flow control (honor received PAUSE frames) */
  591. W_REG(&regs->rxconfig, ERC_FE | ERC_UF);
  593. /* initialize CAM */
  594. if (etc->promisc)
  595. OR_REG(&regs->rxconfig, ERC_PE);
  596. else {
  597. /* our local address */
  598. chipwrcam(ch, &etc->cur_etheraddr, idx++);
  600. /* allmulti or a list of discrete multicast addresses */
  601. if (etc->allmulti)
  602. OR_REG(&regs->rxconfig, ERC_AM);
  603. else if (etc->nmulticast) {
  604. for (i = 0; i < etc->nmulticast; i++)
  605. chipwrcam(ch, &etc->multicast[i], idx++);
  606. }
  608. /* enable cam */
  609. OR_REG(&regs->camcontrol, CC_CE);
  610. }
  612. /* optionally enable mac-level loopback */
  613. if (etc->loopbk)
  614. OR_REG(&regs->rxconfig, ERC_LE);
  616. /* set max frame lengths - account for possible vlan tag */
  617. W_REG(&regs->rxmaxlength, ETHER_MAX_LEN + 32);
  618. W_REG(&regs->txmaxlength, ETHER_MAX_LEN + 32);
  620. /* set tx watermark */
  621. W_REG(&regs->txwatermark, 56);
  623. /*
  624.  * Optionally, disable phy autonegotiation and force our speed/duplex
  625.  * or constrain our advertised capabilities.
  626.  */
  627. if (etc->forcespeed != ET_AUTO)
  628. chipphyforce(ch, etc->phyaddr);
  629. else if (etc->advertise && etc->needautoneg)
  630. chipphyadvertise(ch, etc->phyaddr);
  632. if (full) {
  633. /* initialize the tx and rx dma channels */
  634. dma_txinit(ch->di);
  635. dma_rxinit(ch->di);
  637. /* post dma receive buffers */
  638. dma_rxfill(ch->di);
  640. /* lastly, enable interrupts */
  641. W_REG(&regs->intmask, ch->intmask);
  642. }
  643. else
  644. dma_rxenable(ch->di);
  646. /* turn on the emac */
  647. OR_REG(&regs->enetcontrol, EC_EE);
  648. }
  650. /* dma transmit */
  651. static void
  652. chiptx(struct bcm4xxx *ch, void *p0)
  653. {
  654. int error;
  656. ET_TRACE(("et%d: chiptxn", ch->etc->unit));
  657. ET_LOG("chiptx", 0);
  659. error = dma_txfast(ch->di, p0, 0);
  661. if (error) {
  662. ET_ERROR(("et%d: chiptx: out of txdsn", ch->etc->unit));
  663. ch->etc->txnobuf++;
  664. }
  665. }
  667. /* reclaim complete transmit descriptors and packets */
  668. static void
  669. chiptxreclaim(struct bcm4xxx *ch, bool forceall)
  670. {
  671. ET_TRACE(("et%d: chiptxreclaimn", ch->etc->unit));
  672. dma_txreclaim(ch->di, forceall);
  673. ch->intstatus &= ~I_XI;
  674. }
  676. /* dma receive: returns a pointer to the next frame received, or NULL if there are no more */
  677. static void*
  678. chiprx(struct bcm4xxx *ch)
  679. {
  680. void *p;
  682. ET_TRACE(("et%d: chiprxn", ch->etc->unit));
  683. ET_LOG("chiprx", 0);
  685. if ((p = dma_rx(ch->di)) == NULL)
  686. ch->intstatus &= ~I_RI;
  688. return (p);
  689. }
  691. /* reclaim completes dma transmit descriptors and packets */
  692. static void
  693. chiprxreclaim(struct bcm4xxx *ch)
  694. {
  695. ET_TRACE(("et%d: chiprxreclaimn", ch->etc->unit));
  696. dma_rxreclaim(ch->di);
  697. ch->intstatus &= ~I_RI;
  698. }
  700. /* allocate and post dma receive buffers */
  701. static void
  702. chiprxfill(struct bcm4xxx *ch)
  703. {
  704. ET_TRACE(("et%d: chiprxfilln", ch->etc->unit));
  705. ET_LOG("chiprx", 0);
  706. dma_rxfill(ch->di);
  707. }
  709. /* get current and pending interrupt events */
  710. static int
  711. chipgetintrevents(struct bcm4xxx *ch)
  712. {
  713. bcmenetregs_t *regs;
  714. uint32 intstatus;
  715. int events;
  717. regs = ch->regs;
  718. events = 0;
  720. /* read the interrupt status register */
  721. intstatus = R_REG(&regs->intstatus);
  723. /* if there are new events */
  724. if (intstatus & ch->intmask)
  725. events |= INTR_NEW;
  727. /* or new bits into persistent intstatus */
  728. intstatus = (ch->intstatus |= intstatus);
  730. /* return if no events */
  731. if (intstatus == 0)
  732. return (0);
  734. /* clear non-error interrupt conditions */
  735. W_REG(&regs->intstatus, intstatus);
  737. /* convert chip-specific intstatus bits into generic intr event bits */
  738. if (intstatus & I_RI)
  739. events |= INTR_RX;
  740. if (intstatus & I_XI)
  741. events |= INTR_TX;
  742. if (intstatus & I_ERRORS)
  743. events |= INTR_ERROR;
  744. if (intstatus & I_TO)
  745. events |= INTR_TO;
  747. return (events);
  748. }
  750. /* enable chip interrupts */
  751. static void
  752. chipintrson(struct bcm4xxx *ch)
  753. {
  754. ch->intmask = DEF_INTMASK;
  755. W_REG(&ch->regs->intmask, ch->intmask);
  756. }
  758. /* disable chip interrupts */
  759. static void
  760. chipintrsoff(struct bcm4xxx *ch)
  761. {
  762. ch->intmask = 0;
  763. W_REG(&ch->regs->intmask, ch->intmask);
  764. (void) R_REG(&ch->regs->intmask); /* sync readback */
  765. }
  767. /* return true of caller should re-initialize, otherwise false */
  768. static bool
  769. chiperrors(struct bcm4xxx *ch)
  770. {
  771. uint32 intstatus;
  772. etc_info_t *etc;
  774. etc = ch->etc;
  776. intstatus = ch->intstatus;
  777. ch->intstatus &= ~(I_ERRORS);
  779. ET_TRACE(("et%d: chiperrors: intstatus 0x%xn", etc->unit, intstatus));
  781. if (intstatus & I_PC) {
  782. ET_ERROR(("et%d: descriptor errorn", etc->unit));
  783. etc->dmade++;
  784. }
  786. if (intstatus & I_PD) {
  787. ET_ERROR(("et%d: data errorn", etc->unit));
  788. etc->dmada++;
  789. }
  791. if (intstatus & I_DE) {
  792. ET_ERROR(("et%d: descriptor protocol errorn", etc->unit));
  793. etc->dmape++;
  794. }
  796. if (intstatus & I_RU) {
  797. ET_ERROR(("et%d: receive descriptor underflown", etc->unit));
  798. etc->rxdmauflo++;
  799. }
  801. if (intstatus & I_RO) {
  802. ET_ERROR(("et%d: receive fifo overflown", etc->unit));
  803. etc->rxoflo++;
  804. }
  806. if (intstatus & I_XU) {
  807. ET_ERROR(("et%d: transmit fifo underflown", etc->unit));
  808. etc->txuflo++;
  809. }
  811. return (TRUE);
  812. }
  814. static void
  815. chipwrcam(struct bcm4xxx *ch, struct ether_addr *ea, uint camindex)
  816. {
  817. uint32 w;
  819. ASSERT((R_REG(&ch->regs->camcontrol) & (CC_CB | CC_CE)) == 0);
  821. w = (ea->octet[2] << 24) | (ea->octet[3] << 16) | (ea->octet[4] << 8)
  822. | ea->octet[5];
  823. W_REG(&ch->regs->camdatalo, w);
  824. w = CD_V | (ea->octet[0] << 8) | ea->octet[1];
  825. W_REG(&ch->regs->camdatahi, w);
  826. W_REG(&ch->regs->camcontrol, ((camindex << CC_INDEX_SHIFT) | CC_WR));
  828. /* spin until done */
  829. SPINWAIT((R_REG(&ch->regs->camcontrol) & CC_CB), 100);
  830. ASSERT((R_REG(&ch->regs->camcontrol) & CC_CB) == 0);
  831. }
  833. static void
  834. chipstatsupd(struct bcm4xxx *ch)
  835. {
  836. etc_info_t *etc;
  837. bcmenetregs_t *regs;
  839. etc = ch->etc;
  840. regs = ch->regs;
  842. /*
  843.  * mib counters are clear-on-read.
  844.  * Don't bother using the pkt and octet counters since they are only
  845.  * 16bits and wrap too quickly to be useful.
  846.  */
  847. etc->mib.tx_broadcast_pkts += R_REG(&regs->mib.tx_broadcast_pkts);
  848. etc->mib.tx_multicast_pkts += R_REG(&regs->mib.tx_multicast_pkts);
  849. etc->mib.tx_len_64 += R_REG(&regs->mib.tx_len_64);
  850. etc->mib.tx_len_65_to_127 += R_REG(&regs->mib.tx_len_65_to_127);
  851. etc->mib.tx_len_128_to_255 += R_REG(&regs->mib.tx_len_128_to_255);
  852. etc->mib.tx_len_256_to_511 += R_REG(&regs->mib.tx_len_256_to_511);
  853. etc->mib.tx_len_512_to_1023 += R_REG(&regs->mib.tx_len_512_to_1023);
  854. etc->mib.tx_len_1024_to_max += R_REG(&regs->mib.tx_len_1024_to_max);
  855. etc->mib.tx_jabber_pkts += R_REG(&regs->mib.tx_jabber_pkts);
  856. etc->mib.tx_oversize_pkts += R_REG(&regs->mib.tx_oversize_pkts);
  857. etc->mib.tx_fragment_pkts += R_REG(&regs->mib.tx_fragment_pkts);
  858. etc->mib.tx_underruns += R_REG(&regs->mib.tx_underruns);
  859. etc->mib.tx_total_cols += R_REG(&regs->mib.tx_total_cols);
  860. etc->mib.tx_single_cols += R_REG(&regs->mib.tx_single_cols);
  861. etc->mib.tx_multiple_cols += R_REG(&regs->mib.tx_multiple_cols);
  862. etc->mib.tx_excessive_cols += R_REG(&regs->mib.tx_excessive_cols);
  863. etc->mib.tx_late_cols += R_REG(&regs->mib.tx_late_cols);
  864. etc->mib.tx_defered += R_REG(&regs->mib.tx_defered);
  865. etc->mib.tx_carrier_lost += R_REG(&regs->mib.tx_carrier_lost);
  866. etc->mib.tx_pause_pkts += R_REG(&regs->mib.tx_pause_pkts);
  867. etc->mib.rx_broadcast_pkts += R_REG(&regs->mib.rx_broadcast_pkts);
  868. etc->mib.rx_multicast_pkts += R_REG(&regs->mib.rx_multicast_pkts);
  869. etc->mib.rx_len_64 += R_REG(&regs->mib.rx_len_64);
  870. etc->mib.rx_len_65_to_127 += R_REG(&regs->mib.rx_len_65_to_127);
  871. etc->mib.rx_len_128_to_255 += R_REG(&regs->mib.rx_len_128_to_255);
  872. etc->mib.rx_len_256_to_511 += R_REG(&regs->mib.rx_len_256_to_511);
  873. etc->mib.rx_len_512_to_1023 += R_REG(&regs->mib.rx_len_512_to_1023);
  874. etc->mib.rx_len_1024_to_max += R_REG(&regs->mib.rx_len_1024_to_max);
  875. etc->mib.rx_jabber_pkts += R_REG(&regs->mib.rx_jabber_pkts);
  876. etc->mib.rx_oversize_pkts += R_REG(&regs->mib.rx_oversize_pkts);
  877. etc->mib.rx_fragment_pkts += R_REG(&regs->mib.rx_fragment_pkts);
  878. etc->mib.rx_missed_pkts += R_REG(&regs->mib.rx_missed_pkts);
  879. etc->mib.rx_crc_align_errs += R_REG(&regs->mib.rx_crc_align_errs);
  880. etc->mib.rx_undersize += R_REG(&regs->mib.rx_undersize);
  881. etc->mib.rx_crc_errs += R_REG(&regs->mib.rx_crc_errs);
  882. etc->mib.rx_align_errs += R_REG(&regs->mib.rx_align_errs);
  883. etc->mib.rx_symbol_errs += R_REG(&regs->mib.rx_symbol_errs);
  884. etc->mib.rx_pause_pkts += R_REG(&regs->mib.rx_pause_pkts);
  885. etc->mib.rx_nonpause_pkts += R_REG(&regs->mib.rx_nonpause_pkts);
  887. /*
  888.  * Aggregate transmit and receive errors that probably resulted
  889.  * in the loss of a frame are computed on the fly.
  890.  *
  891.  * We seem to get lots of tx_carrier_lost errors when flipping
  892.  * speed modes so don't count these as tx errors.
  893.  *
  894.  * Arbitrarily lump the non-specific dma errors as tx errors.
  895.  */
  896. etc->txerror = etc->mib.tx_jabber_pkts + etc->mib.tx_oversize_pkts
  897. + etc->mib.tx_underruns + etc->mib.tx_excessive_cols
  898. + etc->mib.tx_late_cols + etc->txnobuf + etc->dmade
  899. + etc->dmada + etc->dmape + etc->txuflo + etc->txnobuf;
  900. etc->rxerror = etc->mib.rx_jabber_pkts + etc->mib.rx_oversize_pkts
  901. + etc->mib.rx_missed_pkts + etc->mib.rx_crc_align_errs
  902. + etc->mib.rx_undersize + etc->mib.rx_crc_errs
  903. + etc->mib.rx_align_errs + etc->mib.rx_symbol_errs
  904. + etc->rxnobuf + etc->rxdmauflo + etc->rxoflo + etc->rxbadlen;
  905. }
  907. static void
  908. chipenablepme(struct bcm4xxx *ch)
  909. {
  910.         bcmenetregs_t *regs;
  912.         regs = ch->regs;
  914.         /* enable chip wakeup pattern matching */
  915.         OR_REG(&regs->devcontrol, DC_PM);
  917.         /* enable sonics bus PME */
  918.         sb_coreflags(ch->sbh, SBTML_PE, SBTML_PE);
  919. }
  921. static void
  922. chipdisablepme(struct bcm4xxx *ch)
  923. {
  924.         bcmenetregs_t *regs;
  926.         regs = ch->regs;
  928.         AND_REG(&regs->devcontrol, ~DC_PM);
  929.         sb_coreflags(ch->sbh, SBTML_PE, 0);
  930. }
  934. static void
  935. chipduplexupd(struct bcm4xxx *ch)
  936. {
  937. uint32 txcontrol;
  939. txcontrol = R_REG(&ch->regs->txcontrol);
  940. if (ch->etc->duplex && !(txcontrol & EXC_FD))
  941. OR_REG(&ch->regs->txcontrol, EXC_FD);
  942. else if (!ch->etc->duplex && (txcontrol & EXC_FD))
  943. AND_REG(&ch->regs->txcontrol, ~EXC_FD);
  944. }
  946. char  mDbg_mdio = FALSE;
  947. static uint16
  948. chipphyrd(struct bcm4xxx *ch, uint phyaddr, uint reg)
  949. {
  950. bcmenetregs_t *regs;
  951. uint16 ret;
  952. ASSERT(phyaddr < PHY_NOMDC);
  953. ASSERT(reg < 32);
  955. /*
  956.  * BCM5222 dualphy shared mdio contortion.
  957.  * remote phy: another emac controls our phy.
  958.  */
  959. if (ch->etc->mdcport != ch->etc->coreunit) {
  960. if (ch->etphy == NULL) {
  961. ch->etphy = et_phyfind(ch->et, ch->etc->mdcport);
  963. /* first time reset */
  964. if (ch->etphy)
  965. chipphyreset(ch, ch->etc->phyaddr);
  966. }
  967. if (ch->etphy)
  968. return (et_phyrd(ch->etphy, phyaddr, reg));
  969. else
  970. return (0xffff);
  971. }
  973. /* local phy: our emac controls our phy */
  975. regs = ch->regs;
  977. /* clear mii_int */
  978. W_REG(&regs->emacintstatus, EI_MII);
  980. /* issue the read */
  981. W_REG(&regs->mdiodata,  (MD_SB_START | MD_OP_READ | (phyaddr << MD_PMD_SHIFT)
  982. | (reg << MD_RA_SHIFT) | MD_TA_VALID));
  984. /* wait for it to complete */
  985. SPINWAIT(((R_REG(&regs->emacintstatus) & EI_MII) == 0), 100);
  986. if ((R_REG(&regs->emacintstatus) & EI_MII) == 0) {
  987. ET_ERROR(("et%d: chipphyrd: did not completen", ch->etc->unit));
  988. }
  990. ret =  R_REG(&regs->mdiodata) & MD_DATA_MASK;
  991. if (mDbg_mdio) {
  992.     printf("%s(0x%x, 0x%x) -->0x%xn",__FUNCTION__, phyaddr, reg, ret);
  993. }
  994. return ret;
  995. }
  997. static void
  998. chipphywr(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v)
  999. {
  1000. bcmenetregs_t *regs;
  1002. ASSERT(phyaddr < PHY_NOMDC);
  1003. ASSERT(reg < 32);
  1005. /*
  1006.  * BCM5222 dualphy shared mdio contortion.
  1007.  * remote phy: another emac controls our phy.
  1008.  */
  1009. if (ch->etc->mdcport != ch->etc->coreunit) {
  1010. if (ch->etphy == NULL)
  1011. ch->etphy = et_phyfind(ch->et, ch->etc->mdcport);
  1012. if (ch->etphy)
  1013. et_phywr(ch->etphy, phyaddr, reg, v);
  1014. return;
  1015. }
  1017. if (mDbg_mdio) {
  1018.    printf("%s(0x%x, 0x%x, 0x%x)n",__FUNCTION__, phyaddr, reg, v);
  1019. }
  1021. /* local phy: our emac controls our phy */
  1023. regs = ch->regs;
  1025. /* clear mii_int */
  1026. W_REG(&regs->emacintstatus, EI_MII);
  1027. ASSERT((R_REG(&regs->emacintstatus) & EI_MII) == 0);;
  1029. /* issue the write */
  1030. W_REG(&regs->mdiodata,  (MD_SB_START | MD_OP_WRITE | (phyaddr << MD_PMD_SHIFT)
  1031. | (reg << MD_RA_SHIFT) | MD_TA_VALID | v));
  1033. /* wait for it to complete */
  1034. SPINWAIT(((R_REG(&regs->emacintstatus) & EI_MII) == 0), 100);
  1035. if ((R_REG(&regs->emacintstatus) & EI_MII) == 0) {
  1036. ET_ERROR(("et%d: chipphywr: did not completen", ch->etc->unit));
  1037. }
  1038. }
  1040. static void
  1041. chipphyor(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v)
  1042. {
  1043. uint16 tmp;
  1045. tmp = chipphyrd(ch, phyaddr, reg);
  1046. tmp |= v;
  1047. chipphywr(ch, phyaddr, reg, tmp);
  1048. }
  1050. static void
  1051. chipphyand(struct bcm4xxx *ch, uint phyaddr, uint reg, uint16 v)
  1052. {
  1053. uint16 tmp;
  1055. tmp = chipphyrd(ch, phyaddr, reg);
  1056. tmp &= v;
  1057. chipphywr(ch, phyaddr, reg, tmp);
  1058. }
  1060. static void
  1061. chipphyreset(struct bcm4xxx *ch, uint phyaddr)
  1062. {
  1063. if (phyaddr == PHY_NOMDC) return;
  1065. chipphywr(ch, phyaddr, 0, CTL_RESET);
  1066. OSL_DELAY(100);
  1067. if (chipphyrd(ch, phyaddr, 0) & CTL_RESET) {
  1068. ET_ERROR(("et%d: chipphyreset: reset not completen", ch->etc->unit));
  1069. }
  1071. chipphyinit(ch, phyaddr);
  1072. }
  1074. static void
  1075. chipphyinit(struct bcm4xxx *ch, uint phyaddr)
  1076. {
  1077.         uint    phyid = 0;
  1079.         /* enable activity led */
  1080.         chipphyand(ch, phyaddr, 26, 0x7fff);
  1082.         /* enable traffic meter led mode */
  1083.         chipphyor(ch, phyaddr, 27, (1 << 6));
  1085.         /* PR 10115 detecting MELCO specific link pulse. */
  1086.         phyid = chipphyrd( ch, phyaddr, 0x2);
  1087.         phyid |=  chipphyrd( ch, phyaddr, 0x3) << 16;
  1088.         if( phyid == 0x55210022) {
  1089.                 chipphywr( ch, phyaddr, 30, chipphyrd( ch, phyaddr, 30 ) | 0x3000);
  1090.                 chipphywr( ch, phyaddr, 19, chipphyrd( ch, phyaddr, 19 ) | 0x0010);
  1091.         }
  1092. }
  1094. static void
  1095. chipphyforce(struct bcm4xxx *ch, uint phyaddr)
  1096. {
  1097. etc_info_t *etc;
  1098. uint16 ctl;
  1100. if (phyaddr == PHY_NOMDC) return;
  1102. etc = ch->etc;
  1104. if (etc->forcespeed == ET_AUTO)
  1105. return;
  1107. ctl = chipphyrd(ch, phyaddr, 0);
  1108. ctl &= ~(CTL_SPEED | CTL_ANENAB | CTL_DUPLEX);
  1110. switch (etc->forcespeed) {
  1111. case ET_10HALF:
  1112. break;
  1114. case ET_10FULL:
  1115. ctl |= CTL_DUPLEX;
  1116. break;
  1118. case ET_100HALF:
  1119. ctl |= CTL_SPEED;
  1120. break;
  1122. case ET_100FULL:
  1123. ctl |= (CTL_SPEED | CTL_DUPLEX);
  1124. break;
  1125. }
  1127. chipphywr(ch, phyaddr, 0, ctl);
  1128. }
  1130. /* set selected capability bits in autonegotiation advertisement */
  1131. static void
  1132. chipphyadvertise(struct bcm4xxx *ch, uint phyaddr)
  1133. {
  1134. etc_info_t *etc;
  1135. uint16 adv;
  1137. if (phyaddr == PHY_NOMDC) return;
  1139. etc = ch->etc;
  1141. if ((etc->forcespeed != ET_AUTO) || !etc->needautoneg)
  1142. return;
  1144. ASSERT(etc->advertise);
  1146. /* reset our advertised capabilitity bits */
  1147. adv = chipphyrd(ch, phyaddr, 4);
  1148. adv &= ~(ADV_100FULL | ADV_100HALF | ADV_10FULL | ADV_10HALF);
  1149. adv |= etc->advertise;
  1150. chipphywr(ch, phyaddr, 4, adv);
  1152. /* restart autonegotiation */
  1153. chipphyor(ch, phyaddr, 0, CTL_RESTART);
  1155. etc->needautoneg = FALSE;
  1156. }
  1158. static struct mdioCtrlReg1{
  1159.     uint8     page;
  1160.     uint8     writeAll:1;
  1161.     uint8     reserved:4;
  1162.     uint8     chipId:2;
  1163.     uint8     mdioEnable:1;
  1164. }  mdioCtrl1;
  1166. static struct mdioCtrlReg2 {
  1167.     uint8    regOffset;
  1168.     uint8    reserved:6;
  1169.     uint8    op:2;   
  1170. } mdioCtrl2;
  1172. int     gSPIEnable = TRUE;
  1173. int  mdioDelay=100;
  1174. static uint16  *pMdioCtrl1 = (uint16 *) &mdioCtrl1;
  1175. static uint16  *pMdioCtrl2 = (uint16 *) &mdioCtrl2;
  1176. static uint16  mMdioBuf[4];
  1177. static  char mMdioUsed = FALSE;
  1178. #define    MII_PAGE_PORTmin 0x10
  1179. #define    MII_PAGE_PORTmax 0x18
  1180. #define    PSEUDO_PHY 0x1e
  1181. #define    MDIO_CTRL1_ADDR 16
  1182. #define    MDIO_CTRL2_ADDR 17
  1183. #define    MDIO_DATAREG_BASE    24
  1184. #define    MDIO_OP_RD 2
  1185. #define    MDIO_OP_WR    1
  1187. /*-------------------------------------------------------------
  1188. check if this access is at the same page as the previous access
  1189. if it is in different page, then need to set the mdio_ctrl1 
  1190. ---------------------------------------------------------------*/
  1191. #define    CHKSET_CHIP_PAGE(cid, page) 
  1192.         if ( !mMdioUsed ||mdioCtrl1.page != page || mdioCtrl1.chipId !=cid ) {
  1193.     mMdioUsed = TRUE;     
  1194.             mdioCtrl1.page = page; 
  1195.          mdioCtrl1.chipId = cid; 
  1196.     chipphywr(mpCh[1], PSEUDO_PHY, MDIO_CTRL1_ADDR, *pMdioCtrl1); 
  1197. }
  1199. void robo_mdio_reset() 
  1200. {
  1201. mMdioUsed = FALSE;
  1202. chipphywr(mpCh[1], PSEUDO_PHY, MDIO_CTRL1_ADDR, 0);
  1203. }
  1205. void setSPI(int fEnable)
  1206. {
  1207. gSPIEnable = fEnable;
  1208. mdioCtrl1.mdioEnable = 1-fEnable;
  1209. mMdioUsed = FALSE;
  1211. chipphywr(mpCh[1], PSEUDO_PHY, MDIO_CTRL1_ADDR, 1-fEnable);
  1212. }
  1214. void robo_mdio_rreg(uint8 cid, uint8 page, uint8 addr, uint8 *buf, uint len)
  1215. {
  1216. int i, nWord=(len+1)>>1;
  1217. uint16 ret;
  1218. uint8  *p = buf;
  1220. if (len>8) {
  1221.     ET_ERROR(("length should be no greater than 8 bytesn"));
  1222.     return;
  1223. }
  1225. if (page>= MII_PAGE_PORTmin && page <= MII_PAGE_PORTmax) {
  1226.     /* direct access */
  1227.     if (len!=2) {
  1228. ET_ERROR(("All MII registers are 2 bytes longn"));
  1229. return;
  1230.     }
  1232.     cid = cid<<3 |(page - MII_PAGE_PORTmin); 
  1233.     ret = chipphyrd(mpCh[1], cid, addr>>1);
  1234.     buf[0] = ret & 0x00ff;
  1235.     buf[1] = ret >>8;    
  1236.     return;
  1237. }
  1239. /* if the access is to pages/chips other than the previous one
  1240.    set the mdio_ctrl1 register again  */
  1241. CHKSET_CHIP_PAGE(cid, page); 
  1243. mdioCtrl2.op = MDIO_OP_RD;
  1244. mdioCtrl2.regOffset = addr;
  1245. chipphywr(mpCh[1], PSEUDO_PHY, MDIO_CTRL2_ADDR, *pMdioCtrl2);
  1247. do {
  1248.     *pMdioCtrl2 = chipphyrd(mpCh[1], PSEUDO_PHY, MDIO_CTRL2_ADDR);
  1249. } while (mdioCtrl2.op != 0);
  1251. for (i=0; i<nWord; i++ ) {
  1252.     ret = chipphyrd(mpCh[1], PSEUDO_PHY, MDIO_DATAREG_BASE+ i);
  1253.     *p++ = ret & 0x00ff;
  1254.     *p++ = ret >>8;
  1255. }
  1256. } 
  1258. void robo_mdio_wreg(uint8 cid, uint8 page, uint8 addr, uint8 *buf, uint len)
  1259. {
  1260. int i, nWord=(len+1)>>1;
  1262. if (len>8) {
  1263.     ET_ERROR(("length should be no greater than 8 bytesn"));
  1264.     return;
  1265. }
  1267. memcpy((uint8 *)mMdioBuf, buf, len);
  1269. /*odd number of bytes, move data from hibyte to lobyte for the last 
  1270.   byte */
  1271. if (len &0x01) 
  1272.     mMdioBuf[nWord] >>=8;
  1274. if (page>= MII_PAGE_PORTmin && page <= MII_PAGE_PORTmax) {
  1275.     /*direct access */
  1276.     if (len!=2) {
  1277. ET_ERROR(("All MII registers are 2 bytes longn"));
  1278. return;
  1279.     }
  1281.     cid = cid<<3 |(page - MII_PAGE_PORTmin);
  1282.     chipphywr(mpCh[1], cid, addr>>1, mMdioBuf[0]);
  1283.     return;
  1284. }
  1286. for (i=0; i<nWord; i++ )  {
  1287.     chipphywr(mpCh[1], PSEUDO_PHY, MDIO_DATAREG_BASE+ i, mMdioBuf[i]);
  1288. }
  1290. CHKSET_CHIP_PAGE(cid, page);
  1291. mdioCtrl2.op = MDIO_OP_WR;
  1292. mdioCtrl2.regOffset = addr;
  1293. chipphywr(mpCh[1], PSEUDO_PHY, MDIO_CTRL2_ADDR, *pMdioCtrl2);
  1295. do {
  1296.     *pMdioCtrl2 = chipphyrd(mpCh[1], PSEUDO_PHY, MDIO_CTRL2_ADDR);
  1297. } while (mdioCtrl2.op != 0);
  1299. }