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

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

VxWorks

开发平台：

C/C++

et_vx.c：源码内容
  1. /*
  2.     Copyright 2001, Broadcom Corporation
  3.     All Rights Reserved.
  5.     This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
  6.     the contents of this file may not be disclosed to third parties, copied or
  7.     duplicated in any form, in whole or in part, without the prior written
  8.     permission of Broadcom Corporation.
  9. */
  10. /*
  11.  * vxWorks 5.x END device driver for
  12.  * Broadcom BCM44XX/BCM47XX family 10/100 Mbps Ethernet Controller
  13.  *
  14.  * Copyright(c) 2000 Broadcom Corp.
  15.  * All Rights Reserved.
  16.  * $Id: et_vx.c,v 1.1 Broadcom SDK $
  17.  */
  19. #ifndef lint
  20. static const char cvsid[] = "$Id: et_vx.c,v 1.1 2004/02/24 07:47:01 csm Exp $";
  21. #endif
  23. #define __INCunixLibh /* XXX temp defeat unixLib.h MALLOC() definition */
  25. #include <vx_osl.h>
  26. #include <endLib.h>
  27. #include <intLib.h>
  28. #include <ioctl.h>
  29. #include <netLib.h>
  30. #include <wdLib.h>
  32. #ifndef MSI
  33. #include <drv/pci/pciConfigLib.h>
  34. #endif
  36. #undef ETHER_MAP_IP_MULTICAST
  37. #include <etherMultiLib.h>
  38. #include <config.h>
  40. #include <epivers.h>
  41. #include <bcmendian.h>
  42. #include <bcmutils.h>
  43. #include <ethernet.h>
  44. #include <bcmenetmib.h>
  45. #include <bcmenetrxh.h>
  46. #include <etsockio.h>
  47. #include <et_dbg.h>
  48. #include <etc.h>
  50. /* mblk queue */
  51. struct mblkq {
  52. M_BLK_ID head;
  53. M_BLK_ID tail;
  54. uint len;
  55. };
  57. /*
  58.  * Principle vx-specific, per-device software state.
  59.  *
  60.  * The END_OBJ must be the first field in this structure since
  61.  * we overload entry point END_OBJ* with et_info_t* .
  62.  */
  63. typedef struct et_info {
  64. END_OBJ endobj; /* end object */
  65. etc_info_t *etc; /* pointer to common os-independent data */
  66. SEM_ID mutex; /* private lock */
  67. bool netjobpend; /* netjob(et_intr) is pending */
  68. WDOG_ID watchdogid; /* 1 sec et_watchdog timer id */
  69. bool dogtimerset; /* if true: watchdog is running */
  70. void *descmem; /* uncached dma descriptor memory */
  71.     pciinfo_t   pciinfo;
  72. int     ivec; /* interrupt vector */
  73. int     irq; /* interrupt vector */
  75. struct mblkq txq; /* private transmit software queue */
  77. long flags; /* our local flags. */
  78. M_CL_CONFIG mclconfig; /* packet pool */
  79. CL_DESC cldesc[1]; /* cluster buffer pool descriptors */
  80. struct et_info *next; /* point to next et_info_t in chain */
  81. } et_info_t;
  83. #define MAXUNITS 8
  84. static et_info_t *et_global[MAXUNITS];
  85. static et_info_t *et_list = NULL;
  87. #define ONE_SECOND sysClkRateGet()
  89. #ifdef __i386__
  91. /* perf logging */
  92. #define rdtscl(low) 
  93. __asm__ __volatile__("rdtsc" : "=a" (low) : : "edx")
  94. #define rdmsr(msr,val1,val2) 
  95. __asm__ __volatile__("rdmsr" 
  96. : "=a" (val1), "=d" (val2) 
  97. : "c" (msr))
  98. #define wrmsr(msr,val1,val2) 
  99. __asm__ __volatile__("wrmsr" 
  100. : /* no outputs */ 
  101. : "c" (msr), "a" (val1), "d" (val2))
  103. #define INT_NUM(_a) (_a)
  104. #define INT_NUM_IRQ0 0x20
  105. #define INT_ENABLE(_a) sysIntEnablePIC(_a)
  107. #elif __mips__
  109. #include <vxbsp.h>
  110. #define INT_NUM(_a) (((_a) >= IV_RTIME_VEC)? INT_LVL_IORQ0: 
  111. (INT_LVL_IORQ0 << ((_a) - IV_IORQ0_VEC)))
  112. #undef INT_NUM_IRQ0
  113. #define INT_NUM_IRQ0 0
  114. #define INT_ENABLE(_a) intEnable(_a)
  116. #endif /* __mips__ */
  118. #define CLASS_NET_ETH 0x000200    /* 24 bit class value */
  119. #define DATAHIWAT     50
  121. /* functions called by etc.c */
  122. void et_init(et_info_t *et);
  123. void et_reset(et_info_t *et);
  124. void et_link_up(et_info_t *et);
  125. void et_link_down(et_info_t *et);
  126. void et_up(et_info_t *et);
  127. void et_down(et_info_t *et, int reset);
  128. int et_dump(et_info_t *et, uchar *buf, uint len);
  130. /* local functions */
  131. END_OBJ *et_load(char *initString, void *unused);
  132. static int et_find_device(int unit, int *bus, int *dev, int *func,
  133. uint16 *vendorid, uint16 *deviceid);
  134. static STATUS et_unload(et_info_t *et);
  135. static STATUS et_netpool_alloc(et_info_t *et);
  136. static void et_netpool_free(et_info_t *et);
  137. static void et_free(et_info_t *et);
  138. static void et_vxwatchdog(et_info_t *et);
  139. static void et_vxintr(et_info_t *et);
  140. static void et_sendnext(et_info_t *et);
  141. static void et_watchdog(et_info_t *et);
  142. static void et_sendup(et_info_t *et, struct mbuf *m);
  143. static void et_loginit(void);
  144. static STATUS et_end_start(et_info_t *et);
  145. static STATUS et_end_stop(et_info_t *et);
  146. static int et_ioctl(et_info_t *et, int cmd, caddr_t data);
  147. static STATUS et_send(et_info_t *et, M_BLK_ID pBuf);
  148. static STATUS et_mcastAdd(et_info_t *et, char* pAddress);
  149. static STATUS et_mcastDel(et_info_t *et, char* pAddress);
  150. static STATUS et_mcastGet(et_info_t *et, MULTI_TABLE* pTable);
  151. static void et_config(et_info_t *et);
  152. static void et_enq(struct mblkq *q, M_BLK_ID m);
  153. static M_BLK_ID et_deq(struct mblkq *q);
  154. #ifdef BCMDBG
  155. static void et_dumpet(et_info_t *et, uchar *buf, uint len);
  156. #endif
  157. #ifdef ROBO 
  158. static M_BLK_ID
  159. et_endEtherAddressForm(M_BLK_ID p, M_BLK_ID s, M_BLK_ID d, BOOL bcastFlag);
  160. #else
  161. #define et_endEtherAddressForm endEtherAddressForm
  162. #endif
  164. static NET_FUNCS etFuncTable = {
  165. (FUNCPTR) et_end_start, /* function to start the device. */
  166. (FUNCPTR) et_end_stop, /* function to stop the device. */
  167. (FUNCPTR) et_unload, /* unloading function for the driver. */
  168. (FUNCPTR) et_ioctl, /* ioctl function for the driver. */
  169. (FUNCPTR) et_send, /* send function for the driver. */
  170. (FUNCPTR) et_mcastAdd, /* multicast add function for the driver. */
  171. (FUNCPTR) et_mcastDel, /* multicast delete function for the driver. */
  172. (FUNCPTR) et_mcastGet, /* multicast retrieve function for the driver. */
  173. (FUNCPTR) NULL, /* polling send function -  not supported*/
  174. (FUNCPTR) NULL, /* polling receive function  -  not supported */
  175. et_endEtherAddressForm, /* put address info into a NET_BUFFER */
  176. endEtherPacketDataGet, /* get pointer to data in NET_BUFFER */
  177. endEtherPacketAddrGet /* get packet addresses. */
  178. };
  180. #define ET_LOCK(et)     semTake((et)->mutex, WAIT_FOREVER)
  181. #define ET_UNLOCK(et) semGive((et)->mutex)
  183. /*
  184.  * vxWorks 5.x does not directly support shared interrupts.  Unbelievable.
  185.  * Redefine intConnect().
  186.  */
  187. #ifndef __mips__
  188. #if defined(INCLUDE_IL_END) || defined(INCLUDE_IL)
  189. extern STATUS cmn_int_connect(VOIDFUNCPTR *ivec, VOIDFUNCPTR dev_vxintr, int param);
  190. #define intConnect  cmn_int_connect
  191. #endif
  192. #endif
  194. END_OBJ*
  195. et_load(char *initString, void *unused)
  196. {
  197. et_info_t *et;
  198. char *tok;
  199. int unit;
  200. uint16 vendorid, deviceid;
  201. uint32 regaddr;
  202. char irq;
  203. int bus, dev, func;
  205. et = NULL;
  206. bus = dev = func = 0;
  207. regaddr = 0;
  208. irq = 0;
  210. if (initString == NULL)
  211. return (NULL);
  213. /* end driver first pass init */
  214. if (initString[0] == '') {
  215. bcopy("et", initString, 3);
  216. return (NULL);
  217. }
  219. /* get our unit number from the init string */
  220. if ((tok = strtok(initString, ":")) == NULL) {
  221. ET_ERROR(("et_load: garbled initString (%s) - unit number not foundn",
  222. initString));
  223. goto fail;
  224. }
  225. unit = bcm_atoi(tok);
  227. ET_TRACE(("et%d: et_loadn", unit));
  230. #ifndef MSI
  231. if (et_find_device(unit, &bus, &dev, &func, &vendorid, &deviceid) == ERROR) {
  232. ET_ERROR(("et%d: et_load: et_find_device() failed n", unit));
  233. goto fail;
  234. }
  236. pciConfigInLong(bus, dev, func, PCI_CFG_BASE_ADDRESS_0, &regaddr);
  237. pciConfigInByte(bus, dev, func, PCI_CFG_DEV_INT_LINE, &irq);
  239. /* map chip registers */
  240. regaddr = REG_MAP(regaddr, 0);
  241. #endif
  243. /* allocate our private device structure */
  244. if ((et = (et_info_t*) MALLOC(sizeof (et_info_t))) == NULL) {
  245. ET_ERROR(("et%d: et_load: malloc et_info_t failed!n", unit));
  246. goto fail;
  247. }
  248. bzero((char*) et, sizeof (et_info_t));
  250. et->irq = INT_NUM(irq);
  251. et->ivec = (int) INUM_TO_IVEC(irq + INT_NUM_IRQ0);
  252. et->pciinfo.bus = bus;
  253. et->pciinfo.dev = dev;
  254. et->pciinfo.func = func;
  256. ET_TRACE(("et%d: et_load: regaddr %x ivec %d irq %dn",
  257. unit, regaddr, et->ivec, et->irq));
  259. /* initialize private semaphore */
  260. if ((et->mutex = semBCreate(SEM_Q_FIFO, SEM_FULL)) == NULL) {
  261. ET_ERROR(("et%d: et_load: semBCreate failn", unit));
  262. goto fail;
  263. }
  265. /* common load-time initialization */
  266. if ((et->etc = etc_attach((void*)et, vendorid, deviceid, unit, &et->pciinfo,
  267. (void*)regaddr)) == NULL) {
  268. ET_ERROR(("et%d: etc_attach failedn", unit));
  269. goto fail;
  270. }
  272. /* create a watchdog timer */
  273. if ((et->watchdogid = wdCreate()) == NULL ) {
  274. ET_ERROR(("et%d: error creating watchdog timern", unit));
  275. goto fail;
  276. }
  277. et->dogtimerset = FALSE;
  279. /* initialize the END and MIB2 parts of the structure */
  280. if (END_OBJ_INIT(&et->endobj, (DEV_OBJ*)et, "et", unit, &etFuncTable, "END et Driver")
  281. == ERROR)
  282. goto fail;
  284. if (END_MIB_INIT(&et->endobj, M2_ifType_ethernet_csmacd, (char *)&et->etc->cur_etheraddr,
  285. ETHER_ADDR_LEN, ETHERMTU, 100000000) == ERROR)
  286. goto fail;
  288. /* allocate and initialize our private mblk/clblk netpool */
  289. if (et_netpool_alloc(et) == ERROR)
  290. goto fail;
  292. /* set the flags to indicate readiness */
  293. END_OBJ_READY(&et->endobj, (IFF_NOTRAILERS|IFF_BROADCAST|IFF_MULTICAST));
  295. /* register our interrupt handler */
  296. if (intConnect((VOIDFUNCPTR*)et->ivec, (VOIDFUNCPTR)et_vxintr, (int)et) == ERROR) {
  297. ET_ERROR(("et%d: et_load: interrupt connect errorn", unit));
  298. goto fail;
  299. }
  301. et_global[unit] = et;
  303. /* add us to the global linked list */
  304. et->next = et_list;
  305. et_list = et;
  307. return (&et->endobj);
  309. fail:
  310. et_free(et);
  311. return (NULL);
  312. }
  314. /*
  315.  * et_unload - unload a driver from the system
  316.  */
  317. static STATUS
  318. et_unload(et_info_t *et)
  319. {
  320. ET_TRACE(("et%d: et_unloadn", et->etc->unit));
  322. ASSERT(!et->etc->up);
  324. END_OBJECT_UNLOAD(&et->endobj);
  326. et_global[et->etc->unit] = NULL;
  328. et_free(et);
  330. return (OK);
  331. }
  333. static int
  334. et_find_device(int unit, int *bus, int *dev, int *func, uint16 *vendorid, uint16 *deviceid)
  335. {
  336. int found;
  337. int i;
  339. found = 0;
  341. /* find the unit'th instance of a recognized et device */
  342. for (i = 0; i < 32; i++) {
  343. if (pciFindClass(CLASS_NET_ETH, i, bus, dev, func) != OK)
  344. continue;
  345. if (pciConfigInWord(*bus, *dev, *func, 0, vendorid) != OK)
  346. continue;
  347. if (pciConfigInWord(*bus, *dev, *func, 2, deviceid) != OK)
  348. continue;
  349. if (!etc_chipmatch(*vendorid, *deviceid))
  350. continue;
  352. if (found == unit)
  353. return (OK);
  355. found++;
  356. }
  358. ET_ERROR(("et%d: et_find_device:  error finding devicen", unit));
  360. return (ERROR);
  361. }
  363. static void
  364. et_free(et_info_t *et)
  365. {
  366. et_info_t **prev;
  368. if (et == NULL)
  369. return;
  371. ET_TRACE(("et: et_freen"));
  373. /* delete the watchdog timer */
  374. if (et->watchdogid) {
  375. wdDelete(et->watchdogid);
  376. et->watchdogid = NULL;
  377. }
  379. /* free common resources */
  380. if (et->etc) {
  381. etc_detach(et->etc);
  382. et->etc = NULL;
  383. }
  385. /* free private netpool */
  386. et_netpool_free(et);
  388. /* remove us from the global linked list */
  389. for (prev = &et_list; *prev; prev = &(*prev)->next)
  390. if (*prev == et) {
  391. *prev = et->next;
  392. break;
  393. }
  395. free((char*)et);
  396. }
  398. /* alloc and init a private mblk/clblk netpool */
  399. STATUS
  400. et_netpool_alloc(et_info_t *et)
  401. {
  402. ET_TRACE(("et%d: et_netpool_allocn", et->etc->unit));
  404. /* alloc the netpool structure itself */
  405. if ((et->endobj.pNetPool = (NET_POOL_ID) MALLOC(sizeof (NET_POOL))) == NULL)
  406. goto error;
  408. et->mclconfig.mBlkNum = MIN_PKTS;
  409. et->mclconfig.clBlkNum = MIN_PKTS;
  411. /* sanity check */
  412. ASSERT(BUFSZ == VXCLSIZE);
  414. /* create a single 2Kbyte cluster buffer pool */
  415. et->cldesc[0].clNum = MIN_CLUSTERS;
  416. et->cldesc[0].clSize = VXCLSIZE;
  418. /* calculate the total memory for all the M_BLKs and CL_BLKs */
  419. et->mclconfig.memSize = (et->mclconfig.mBlkNum * (MSIZE + sizeof (long))) +
  420. (et->mclconfig.clBlkNum * (CL_BLK_SZ + sizeof(long)));
  422. /* allocate the M_BLK&CL_BLK pool */
  423. if ((et->mclconfig.memArea = MALLOC(et->mclconfig.memSize)) == NULL)
  424. goto error;
  426. /* calculate the memory size of all the clusters. */
  427. et->cldesc[0].memSize = (et->cldesc[0].clNum * (VXCLSIZE + 8)) + sizeof (int);
  429. /* allocate the cluster buffer pool */
  430. if ((et->cldesc[0].memArea = memalign(2048, et->cldesc[0].memSize)) == NULL)
  431. goto error;
  432. ASSERT(ISALIGNED(et->cldesc[0].memArea, 2048));
  434. /* now init the netpool */
  435. if (netPoolInit(et->endobj.pNetPool, &et->mclconfig, &et->cldesc[0], 1, NULL) == ERROR)
  436. goto error;
  438. return (OK);
  440. error:
  441. ET_ERROR(("et%d: et_netpool_alloc: malloc failed!n", et->etc->unit));
  442. et_netpool_free(et);
  443. return (ERROR);
  444. }
  446. static void
  447. et_netpool_free(et_info_t *et)
  448. {
  449. ET_TRACE(("et%d: et_netpool_freen", et->etc->unit));
  451. if (et->cldesc[0].memArea) {
  452. MFREE(et->cldesc[0].memArea, et->cldesc[0].memSize);
  453. et->cldesc[0].memSize = 0;
  454. et->cldesc[0].memArea = NULL;
  455. }
  457. if (et->mclconfig.memArea) {
  458. MFREE(et->mclconfig.memArea, et->mclconfig.memSize);
  459. et->mclconfig.memSize = 0;
  460. et->mclconfig.memArea = NULL;
  461. }
  463. if (et->endobj.pNetPool) {
  464. netPoolDelete(et->endobj.pNetPool);
  465. et->endobj.pNetPool = NULL;
  466. }
  467. }
  469. void
  470. et_init(et_info_t *et)
  471. {
  472. ET_TRACE(("et%d: et_initn", et->etc->unit));
  473. ET_LOG("et_init", 0);
  475. et_loginit();
  477. /* reset the interface */
  478. et_reset(et);
  480. /* initialize the driver and chip */
  481. etc_init(et->etc);
  483. et->endobj.flags |= (IFF_RUNNING | IFF_UP);
  484. }
  486. void
  487. et_reset(et_info_t *et)
  488. {
  489. ET_TRACE(("et%d: et_resetn", et->etc->unit));
  491. /* common reset code */
  492. etc_reset(et->etc);
  494. et->endobj.flags &= ~IFF_RUNNING;
  495. }
  497. void
  498. et_link_up(et_info_t *et)
  499. {
  500. et->endobj.mib2Tbl.ifOperStatus = 1;
  501. ET_ERROR(("et%d: link upn", et->etc->unit));
  502. }
  504. void
  505. et_link_down(et_info_t *et)
  506. {
  507. et->endobj.mib2Tbl.ifOperStatus = 0;
  508. ET_ERROR(("et%d: link downn", et->etc->unit));
  509. }
  511. void
  512. et_up(et_info_t *et)
  513. {
  514. ET_TRACE(("et%d: et_upn", et->etc->unit));
  516. etc_up(et->etc);
  518. END_FLAGS_SET (&et->endobj, IFF_UP | IFF_RUNNING);
  520. /* start a one second the watchdog timer */
  521. if (et->dogtimerset == FALSE) {
  522. if (wdStart(et->watchdogid, ONE_SECOND, (FUNCPTR)et_vxwatchdog, (int)et) != OK) {
  523. ET_ERROR(("et%d: et_up: Error starting the watchdogn", et->etc->unit));
  524. }
  525. et->dogtimerset = TRUE;
  526. }
  528. }
  530. void
  531. et_down(et_info_t *et, int reset)
  532. {
  533. etc_info_t *etc;
  534. M_BLK_ID m;
  536. etc = et->etc;
  538. ET_TRACE(("et%d: et_downn", etc->unit));
  540. /* cancel the watchdog timer */
  541. if (et->dogtimerset) {
  542. wdCancel(et->watchdogid);
  543. et->dogtimerset = FALSE;
  544. }
  546. etc_down(etc, reset);
  548.     /* mark the driver as down */
  549.     END_FLAGS_CLR (&et->endobj, IFF_UP | IFF_RUNNING);
  551. /* flush the txq */
  552. while ((m = (M_BLK_ID) et_deq(&et->txq)))
  553. netMblkClChainFree(m);
  554. }
  556. int
  557. et_dump(et_info_t *et, uchar *buf, uint len)
  558. {
  559. /* big enough? */
  560. if (len < 4096)
  561. return (4096);
  563. sprintf(buf, "et%d: %s %s version %sn", et->etc->unit,
  564. __DATE__, __TIME__, EPI_VERSION_STR);
  566. #ifdef BCMDBG
  567. et_dumpet(et, &buf[strlen(buf)], len - strlen(buf));
  568. etc_dump(et->etc, &buf[strlen(buf)], len - strlen(buf));
  569. #endif
  571. return (strlen(buf));
  572. }
  574. static void
  575. et_vxwatchdog(et_info_t *et)
  576. {
  577. netJobAdd((FUNCPTR)et_watchdog, (int)et, 0, 0, 0, 0);
  578. }
  580. static void
  581. et_watchdog(et_info_t *et)
  582. {
  583. #if 0
  584. ET_TRACE(("et%d: watchdogn", et->etc->unit));
  585. ET_LOG("et_watchdog", 0);
  586. #endif
  588. ET_LOCK(et);
  590. etc_watchdog(et->etc);
  592. /* restart timer */
  593. wdStart(et->watchdogid, ONE_SECOND, (FUNCPTR)et_vxwatchdog, (int)et);
  595. ET_UNLOCK(et);
  597. ET_LOG("et_watchdog retn", 0);
  598. }
  600. static void
  601. et_sendnext(et_info_t *et)
  602. {
  603. M_BLK_ID m;
  604. etc_info_t *etc;
  606. etc = et->etc;
  608. ET_TRACE(("et%d: et_sendnextn", etc->unit));
  609. ET_LOG("et_sendnext", 0);
  611. /* dequeue and send each packet */
  612. while ((*etc->txavail > 8)
  613. && (etc->pioactive == NULL)
  614. && (m = et_deq(&et->txq))) {
  616. ET_PRHDR("tx", (struct ether_header*) m->mBlkHdr.mData, etc_totlen(etc, (void*)m));
  617. ET_PRPKT("txpkt", m->mBlkHdr.mData, m->mBlkHdr.mLen);
  619. /* transmit the frame */
  620. (*etc->chops->tx)(etc->ch, (void*)m);
  622. etc->txframe++;
  623. etc->txbyte += m->mBlkHdr.mLen;
  624. }
  626. ET_LOG("et_sendnext retn", 0);
  627. }
  629. static void
  630. et_intr(et_info_t *et, uint events)
  631. {
  632. etc_info_t *etc;
  633. struct chops *chops;
  634. void *ch;
  635. M_BLK_ID m;
  637. etc = et->etc;
  638. chops = etc->chops;
  639. ch = etc->ch;
  641. ASSERT(events);
  643. ET_TRACE(("et%d: et_intr: events 0x%xn", etc->unit, events));
  644. ET_LOG("et_intr: events 0x%x", events);
  646. ET_LOCK(et);
  648. if (events & INTR_RX) {
  649. while ((m = (M_BLK_ID) (*chops->rx)(ch)))
  650. et_sendup(et, m);
  651. /* post more rx bufs */
  652. (*chops->rxfill)(ch);
  653. }
  655. if (events & INTR_TX)
  656. (*chops->txreclaim)(ch, FALSE);
  658. if (events & INTR_ERROR)
  659. if ((*chops->errors)(ch))
  660. et_init(et);
  662. /* run the tx queue */
  663. if (et->txq.len)
  664. et_sendnext(et);
  666. et->netjobpend = FALSE;
  668. /* re-enable interrupts */
  669. (*chops->intrson)(ch);
  671. ET_UNLOCK(et);
  672. ET_LOG("et_intr retn", 0);
  673. }
  675. /* just a wrapper for et_intr() */
  676. static void
  677. et_vxintr(et_info_t *et)
  678. {
  679. uint events;
  681. /* guard against shared interrupts */
  682. if (!et->etc->up)
  683. goto done;
  685. events = (*et->etc->chops->getintrevents)(et->etc->ch);
  687. ET_LOG("et_vxintr: events 0x%x", events);
  689. if (!(events & INTR_NEW) || et->netjobpend)
  690. goto done;
  692. /* disable device interrupts */
  693. (*et->etc->chops->intrsoff)(et->etc->ch);
  695. et->netjobpend = TRUE;
  696. netJobAdd((FUNCPTR)et_intr, (int)et, events, 0, 0 ,0);
  698. done:
  699. ET_LOG("et_vxintr retn", 0);
  700. }
  702. static void
  703. et_sendup(et_info_t *et, M_BLK_ID m)
  704. {
  705. bcmenetrxh_t *rxh;
  706. uint16 flags;
  707. uchar eabuf[32];
  709. #if 0
  710. sysSerialPrintString("et_sendupn");
  711. ET_PRPKT("rxpktraw", (uchar*)m->mBlkHdr.mData, m->mBlkHdr.mLen);
  712. #endif
  713. /* packet buffer starts with rxh */
  714. rxh = (bcmenetrxh_t*) m->mBlkHdr.mData;
  716. /* strip off rxh */
  717. m->mBlkHdr.mData += HWRXOFF;
  718. m->mBlkHdr.mLen -= HWRXOFF;
  720. ET_TRACE(("et%d: et_sendup: %d bytesn", et->etc->unit, m->mBlkHdr.mLen));
  721. ET_LOG("et_sendup: len %d", m->mBlkHdr.mLen);
  723. et->etc->rxframe++;
  724. et->etc->rxbyte += m->m_len;
  726. /* eh should now be aligned 2-mod-4 */
  727. ASSERT(((uint)m->mBlkHdr.mData & 3) == 2);
  729. /* strip off crc32 */
  730. m->mBlkHdr.mLen -= ETHER_CRC_LEN;
  732. ET_PRHDR("rx", (struct ether_header*)m->mBlkHdr.mData, m->mBlkHdr.mLen);
  733. ET_PRPKT("rxpkt", (uchar*)m->mBlkHdr.mData, m->mBlkHdr.mLen);
  735. /* check for reported frame errors */
  736. flags = ltoh16(rxh->flags);
  737. if (flags & (RXF_NO | RXF_RXER | RXF_CRC | RXF_OV))
  738. goto err;
  740. m->mBlkHdr.mFlags |= M_PKTHDR;
  741. m->mBlkPktHdr.len = m->mBlkHdr.mLen;
  743. /* The vx router 1.0 stack is reentrant so we 
  744. need to drop the perimeter lock here */
  745. ET_UNLOCK(et);
  746. END_RCV_RTN_CALL(&et->endobj, m);
  747. ET_LOCK(et);
  749. ET_LOG("et_sendup ret", 0);
  751. return;
  753. err:
  754. bcm_ether_ntoa(((struct ether_header*)m->mBlkHdr.mData)->ether_shost, eabuf);
  755. if (flags & RXF_NO) {
  756. ET_ERROR(("et%d: rx: crc error (odd nibbles) from %sn", et->etc->unit, eabuf));
  757. }
  758. if (flags & RXF_RXER) {
  759. ET_ERROR(("et%d: rx: symbol error from %sn", et->etc->unit, eabuf));
  760. }
  761. if ((flags & RXF_CRC) == RXF_CRC) {
  762. ET_ERROR(("et%d: rx: crc error from %sn", et->etc->unit, eabuf));
  763. }
  764. if (flags & RXF_OV) {
  765. ET_ERROR(("et%d: rx: fifo overflown", et->etc->unit));
  766. }
  767. netMblkClFree(m);
  768. return;
  769. }
  771. /*
  772.  * Debugging/Performance Logging Functions
  773.  */
  774. static void
  775. et_loginit(void)
  776. {
  777. #if defined(BCMDBG) && defined(__i386__)
  778. if (et_msg_level & 2048)
  779. wrmsr(0x186, 0x4700c0, 0); /* enable P6 instr counting */
  780. #ifdef notdef
  781. wrmsr(0x11, 0xd6, 0); /* enable Pentium instr counting */
  782. #endif
  783. #endif /* BCMDBG && __i386__ */
  784. }
  786. #ifdef BCMDBG
  787. static void
  788. et_dumpet(et_info_t *et, uchar *buf, uint len)
  789. {
  790. sprintf(&buf[strlen(buf)], "et %p flags 0x%x txq.len %dn",
  791. et, (uint)et->flags, et->txq.len);
  792. sprintf(&buf[strlen(buf)], "n");
  793. }
  795. /* obtaining cycle and instruction counts is processor specific */
  796. void
  797. et_log(char *fmt, ulong a1)
  798. {
  799. static uint32 lasttsc = 0;
  800. static uint32 lastinstr = 0;
  801. uint32 tsc, instr;
  803. #ifdef __i386__
  804. uint32 dummy;
  806. /* read cycle counter */
  807. rdtscl(tsc);
  809. /* read ctr1 value */
  810. rdmsr(0xc1, instr, dummy); /* read P6 CTR0 register */
  811. #ifdef notdef
  812. rdmsr(0x12, instr, dummy); /* read Pentium CTR0 register */
  813. #endif
  814. #endif /* __i386__ */
  816. #if defined(__mips__)
  817. /* readCount() and readInstr() must be provided by the bsp */
  818. tsc = readCount();
  819. instr = readInstr();
  820. #endif
  822. /* call common log handler */
  823. etc_log(tsc - lasttsc, instr - lastinstr, fmt, a1);
  825. /* update last values */
  826. lasttsc = tsc;
  827. lastinstr = instr;
  828. }
  829. #endif /* BCMDBG */
  831. /*
  832.  * et_end_start - start the device
  833.  */
  834. static STATUS
  835. et_end_start(et_info_t *et)
  836. {
  837. ET_TRACE(("et%d: et_end_startn", et->etc->unit));
  838. ET_LOCK(et);
  839. et_up(et);
  841. #ifndef MSI
  842. INT_ENABLE(et->irq);
  843. #endif
  845. ET_UNLOCK(et);
  846. return (OK);
  847. }
  849. /*
  850.  * et_end_stop - stop the device
  851.  */
  852. static STATUS
  853. et_end_stop(et_info_t *et)
  854. {
  855. ET_TRACE(("et%d: et_end_stopn", et->etc->unit));
  856. ET_LOCK(et);
  857. et_down(et, 1);
  858. ET_UNLOCK(et);
  859. return (OK);
  860. }
  862. /*
  863.  * et_send - the driver send routine
  864.  */
  865. static STATUS
  866. et_send(et_info_t *et, M_BLK_ID m)
  867. {
  868. ET_TRACE(("et%d: et_send: len %d n", et->etc->unit, m->mBlkPktHdr.len));
  870. END_TX_SEM_TAKE(&et->endobj, WAIT_FOREVER);
  871. ET_LOCK(et);
  873. /* discard if transmit queue is too full */
  874. if (et->txq.len > DATAHIWAT)
  875. goto qfull;
  877. et_enq(&et->txq, m);
  878. et_sendnext(et);
  880. ET_UNLOCK(et);
  881. END_TX_SEM_GIVE(&et->endobj);
  883. /* bump the statistic counter. */
  884. END_ERR_ADD(&et->endobj, MIB2_OUT_UCAST, +1);
  886. return (OK);
  888. qfull:
  889. ET_ERROR(("et%d: et_send: txq fulln", et->etc->unit));
  890. et->etc->txnobuf++;
  891. et->etc->txerror++;
  892. ET_UNLOCK(et);
  893. END_TX_SEM_GIVE(&et->endobj);
  894. return (END_ERR_BLOCK);
  895. }
  897. static int
  898. et_ioctl(et_info_t *et, int cmd, caddr_t data)
  899. {
  900. int error;
  901. long value;
  902. etc_info_t  *etc;
  904. etc = et->etc;
  905. error = 0;
  907. ET_TRACE(("et%d: et_ioctln", et->etc->unit));
  909. switch (cmd) {
  910. case EIOCSADDR:
  911. if (data == NULL)
  912. return (EINVAL);
  913. bcopy((char*)data, (char*)et->endobj.mib2Tbl.ifPhysAddress.phyAddress, ETHER_ADDR_LEN);
  914. bcopy((char*)data, (char*)&etc->cur_etheraddr, ETHER_ADDR_LEN);
  915. et_config(et);
  916. break;
  918. case EIOCGADDR:
  919. if (data == NULL)
  920. return (EINVAL);
  921. bcopy((char*)&etc->cur_etheraddr, (char *)data, ETHER_ADDR_LEN);
  922. break;
  924. case EIOCSFLAGS:
  925. value = (long)data;
  926. if (value < 0) {
  927. value = ~value;
  928. END_FLAGS_CLR(&et->endobj, value);
  929. }
  930. else {
  931. END_FLAGS_SET(&et->endobj, value);
  932. }
  933. et_config(et);
  934. break;
  936. case EIOCGFLAGS:
  937. *(int*)data = END_FLAGS_GET(&et->endobj);
  938. break;
  940. case EIOCPOLLSTART:
  941. ASSERT(0); /* not supported */
  942. break;
  944. case EIOCPOLLSTOP:
  945. ASSERT(0); /* not supported */
  946. break;
  948. case EIOCGMIB2: /* return MIB information */
  949. if (data == NULL)
  950. return (EINVAL);
  952. /* update some of the mib counters */
  953. et->endobj.mib2Tbl.ifInErrors = etc->rxerror;
  954. et->endobj.mib2Tbl.ifOutErrors = etc->txerror;
  955. et->endobj.mib2Tbl.ifInOctets = etc->rxbyte;
  956. et->endobj.mib2Tbl.ifOutOctets = etc->txbyte;
  957. et->endobj.mib2Tbl.ifInUcastPkts = etc->rxframe;
  958. et->endobj.mib2Tbl.ifOutUcastPkts = etc->txframe;
  959. bcopy((char *)&et->endobj.mib2Tbl, (char *)data,
  960. sizeof(et->endobj.mib2Tbl));
  961. break;
  963. case EIOCGFBUF: /* return minimum First Buffer for chaining */
  964. if (data == NULL)
  965. return (EINVAL);
  966. *(int *)data = ETHER_MAX_LEN;
  967. break;
  968. #ifdef ROBO
  969. case EIOCGNPT:
  970.         if (et->etc->unit == 1) {
  971.             return(OK);
  972.         } else {
  973.             return(EINVAL);
  974.         }
  975. #endif
  976. default:
  977. error = EINVAL;
  978. }
  980. return (error);
  981. }
  983. /*
  984.  * et_config - Reconfigure the interface to match the current flag/multicast settings
  985.  */
  986. static void
  987. et_config(et_info_t *et)
  988. {
  989. int i;
  990. ETHER_MULTI *pCurr;
  991. uchar *src, *dst;
  993. ET_TRACE(("et%d: et_confign", et->etc->unit));
  995. ET_LOCK(et);
  997. /* set promiscuous mode if it's asked for. */
  998. et->etc->promisc = (et->endobj.flags & IFF_PROMISC)? TRUE: FALSE;
  999. et->etc->allmulti = (et->endobj.flags & IFF_ALLMULTI)? TRUE: FALSE;
  1001. /* set up address filter for multicasting */
  1002. pCurr = END_MULTI_LST_FIRST(&et->endobj);
  1003. i = 0;
  1004. while (pCurr != NULL) {
  1005. src = (unsigned char *)&pCurr->addr;
  1006. dst = (unsigned char *)&et->etc->multicast[i];
  1007. bcopy(src, dst, ETHER_ADDR_LEN);
  1009. pCurr = END_MULTI_LST_NEXT(pCurr);
  1010. i++;
  1011. }
  1013. et->etc->nmulticast = i;
  1014. if (i) {
  1015. if (et->etc->nmulticast == et->endobj.nMulti) {
  1016. ET_ERROR(("et%d: et_config: etc.nmulticast %d, endobj.nMulti %dn",
  1017. et->etc->unit, et->etc->nmulticast, et->endobj.nMulti));
  1018. }
  1019. }
  1021. if (et->endobj.flags & IFF_UP)
  1022. et_up(et);
  1023. else if (et->endobj.flags & IFF_RUNNING)
  1024. et_down(et, 1);
  1026. ET_UNLOCK(et);
  1027. }
  1029. /*
  1030.  * et_mcastAdd - add a multicast address for the device
  1031.  */
  1032. static STATUS
  1033. et_mcastAdd(et_info_t *et, char* pAddress)
  1034. {
  1035. int error;
  1037. ET_TRACE(("et%d: et_mcastAddn", et->etc->unit));
  1039. if ((error = etherMultiAdd(&et->endobj.multiList, pAddress)) == ENETRESET)
  1040. et_config(et);
  1042. return(OK);
  1043. }
  1045. /*
  1046.  * et_mcastDel - delete a multicast address for the device
  1047.  */
  1048. static STATUS
  1049. et_mcastDel(et_info_t *et,char* pAddress)
  1050. {
  1051. int error;
  1053. ET_TRACE(("et%d: et_mcastDeln", et->etc->unit));
  1055. if ((error = etherMultiDel(&et->endobj.multiList, (char *)pAddress)) == ENETRESET)
  1056. et_config(et);
  1058. return (OK);
  1059. }
  1061. /*
  1062.  * et_mcastGet - get the multicast address list for the device
  1063.  */
  1064. static STATUS
  1065. et_mcastGet(et_info_t *et, MULTI_TABLE* pTable)
  1066. {
  1067. ET_TRACE(("et%d: et_mcastGetn", et->etc->unit));
  1069. return (etherMultiGet(&et->endobj.multiList, pTable));
  1070. }
  1072. #ifdef ROBO 
  1073. /*
  1074.  * et_endEtherAddressForm - src/dst mac updation routine
  1075.  */
  1076. M_BLK_ID
  1077. et_endEtherAddressForm(M_BLK_ID p, M_BLK_ID s, M_BLK_ID d, BOOL bcastFlag)
  1078. {
  1079.     char zd[] = {0,0,0,0,0,0};
  1080.     if (memcmp(d->mBlkHdr.mData,zd,6) == 0) {
  1081.         return(p);
  1082.     }
  1083.     return (endEtherAddressForm(p,s,d,bcastFlag));
  1084. }
  1085. #endif
  1087. /* enqueue mblk on queue */
  1088. static void
  1089. et_enq(struct mblkq *q, M_BLK_ID m)
  1090. {
  1091. ASSERT(m->mBlkHdr.mNextPkt == NULL);
  1093. if (q->tail == NULL) {
  1094. ASSERT(q->head == NULL);
  1095. q->head = q->tail = m;
  1096. }
  1097. else {
  1098. ASSERT(q->head);
  1099. ASSERT(q->tail->mBlkHdr.mNextPkt == NULL);
  1100. q->tail->mBlkHdr.mNextPkt = m;
  1101. q->tail = m;
  1102. }
  1103. q->len++;
  1104. }
  1106. /* dequeue mblk from queue */
  1107. static M_BLK_ID
  1108. et_deq(struct mblkq *q)
  1109. {
  1110. M_BLK_ID m;
  1112. if ((m = q->head)) {
  1113. ASSERT(q->tail);
  1114. q->head = m->mBlkHdr.mNextPkt;
  1115. m->mBlkHdr.mNextPkt = NULL;
  1116. q->len--;
  1117. if (q->head == NULL)
  1118. q->tail = NULL;
  1119. }
  1120. else {
  1121. ASSERT(q->tail == NULL);
  1122. }
  1124. return (m);
  1125. }
  1127. #ifdef BCM47XX_CHOPS
  1128. /*
  1129.  * 47XX-specific shared mdc/mdio contortion:
  1130.  * Find the et associated with the same chip as <et>
  1131.  * and coreunit matching <coreunit>.
  1132.  */
  1133. void*
  1134. et_phyfind(et_info_t *et, uint coreunit)
  1135. {
  1136. et_info_t *tmp;
  1138. /* walk the list et's */
  1139. for (tmp = et_list; tmp; tmp = tmp->next) {
  1140. if (et->etc == NULL)
  1141. continue;
  1142. if (tmp->pciinfo.bus != et->pciinfo.bus)
  1143. continue;  
  1144. if (tmp->etc->coreunit != coreunit)
  1145. continue;
  1146. break;
  1147. }
  1148. return (tmp);
  1149. }
  1151. /* shared phy read entry point */
  1152. uint16
  1153. et_phyrd(et_info_t *et, uint phyaddr, uint reg)
  1154. {
  1155. uint16 val;
  1157. ET_LOCK(et);
  1158. val = et->etc->chops->phyrd(et->etc->ch, phyaddr, reg);
  1159. ET_UNLOCK(et);
  1161. return (val);
  1162. }
  1164. /* shared phy write entry point */
  1165. void
  1166. et_phywr(et_info_t *et, uint phyaddr, uint reg, uint16 val)
  1167. {
  1168. ET_LOCK(et);
  1169. et->etc->chops->phywr(et->etc->ch, phyaddr, reg, val);
  1170. ET_UNLOCK(et);
  1171. }
  1172. #endif /* BCM47XX_CHOPS */
  1174. #ifdef BCMINTERNAL
  1175. #ifdef BCMDBG
  1176. /* debugging routines callable from the shell */
  1177. static uchar buf1[64 * 1024];
  1179. void
  1180. set_et_msg_level(int level) {
  1181. et_msg_level = level;
  1182. }
  1184. void
  1185. dump_etstats(int unit) {
  1186. et_dump(et_global[unit], buf1, 4096);
  1187. printf("%s", buf1);
  1188. }
  1190. void dump_etlog(int unit) {
  1191. etc_dumplog(buf1);
  1192. printf("%s", buf1);
  1193. }
  1195. void up_et(int unit) {
  1196. et_up(et_global[unit]);
  1197. }
  1199. #endif
  1200. #endif