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

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

VxWorks

开发平台：

C/C++

robotxrx.c：源码内容
  1. /*
  2.  * $Id: robotxrx.c,v 1.1 Broadcom SDK $
  3.  * $Copyright: (c) 2003 Broadcom Corp.
  4.  */
  6. #include <stdlib.h>
  7. #include <end.h>
  8. #include <taskLib.h>
  9. #include <muxLib.h>
  10. #include <muxTkLib.h>
  11. #include <netBufLib.h>
  12. #include <errnoLib.h>
  13. #include <time.h>
  14. #include <cacheLib.h>
  15. #include <logLib.h>
  16. #include <intLib.h>
  20. #define ROBO_TXRX_DEBUG
  21. #define ROBO_TX_TEST_XXXX
  23. #define ROBO_MII_DEVICE_NAME "et"
  24. #define ROBO_MII_DEV_UNIT 1
  25. #define LINK_HDR_LEN 14
  27. #define ROBO_TX_RX_PK_SZ    2048
  28. #define ROBO_TXRX_CLBLKS    256
  29. #define ROBO_TXRX_MBLKS     256
  30. #define ROBO_TXRX_CLBUFS    256
  33. typedef void (*cb_f)(void *b, int l);
  34. typedef void * (*alloc_f)(int l);
  35. typedef void (*free_f)(void *b);
  37. typedef struct robo_txrx_info_s {
  38.     void *          roboMuxBindID;
  39.     void *          roboNetPoolID;
  40.     M_CL_CONFIG     m_cl_blks;
  41.     CL_DESC         cluster;
  42.     CL_POOL_ID      clpool_id;
  43.     cb_f            rx_cb;
  44.     alloc_f         rx_alloc;
  45.     free_f          rx_free;
  46.     void *          rx_head;
  47.     void *          rx_tail;
  48.     UINT32          queue_rx_pkts;
  49.     UINT32          rx_out_of_mem;
  50.     UINT32          rx_cnt;
  51.     UINT32          tx_cnt;
  52.     UINT32          tx_fail;
  53. } robo_txrx_info_t;
  55. LOCAL robo_txrx_info_t robo_txrx_info;
  56. #ifdef ROBO_TXRX_DEBUG
  57. int  robo_txrx_debug = 0;
  58. #endif
  60. #define ROBO_TXRX_DEBUG_F   0x00000001
  61. #define ROBO_TXRX_DEBUG_P   0x00000002
  62. #define ROBO_TXRX_PRINT if (robo_txrx_debug & ROBO_TXRX_DEBUG_P) logMsg
  64. /* Public functions */
  65. void roboTxRxInit();
  66. int bcmRoboTx(UINT8 *b, int l);
  67. void bcm_robo_mii_rx(UINT8 *b, int *l);
  68. void bcm_robo_mii_rx_start();
  69. void bcm_robo_mii_rx_stop();
  71. int roboMIIRxHandlerRegister(cb_f cf, alloc_f af, free_f ff);
  72. int roboMIIRxHandlerUnRegister(cb_f f);
  74. #ifdef ROBO_TXRX_DEBUG
  75. /* debug test functions */
  76. void robo_tx_test(int l);
  77. void robo_rx_test();
  78. void robo_tx_netpool_show();
  80. #include <stdio.h>
  82. /* Debug */
  83. LOCAL void
  84. robo_txrx_pp(UINT8 *p, int l)
  85. {
  86.     int i;
  88.     for(i=0; i < l; i++) {
  89.         if ((i % 16) == 0) {
  90.             printf("n%02x :", i);
  91.         }
  92.         printf("%02x ", *p++);
  93.     }
  94.     printf("n");
  95. }
  97. /* Debug */
  98. LOCAL void
  99. robo_txrx_print_packet(M_BLK_ID pMblk)
  100. {
  101.     unsigned char *p;
  103.     pMblk->mBlkHdr.mFlags &=(~(M_BCAST | M_MCAST));
  105.     printf("pklen=%d mLen=%d mType=%d mNext=%08x mData=%08xn",
  106.         pMblk->mBlkPktHdr.len,
  107.         pMblk->mBlkHdr.mLen,
  108.         pMblk->mBlkHdr.mType,
  109.         (int)pMblk->mBlkHdr.mNext,
  110.         (int)pMblk->mBlkHdr.mData);
  112.     p = (unsigned char *)pMblk->mBlkHdr.mData;
  113.     robo_txrx_pp(p, pMblk->mBlkPktHdr.len);
  114. }
  116. UINT8 robo_tx_test_pkbuf[512] = {
  117.  0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 
  118. ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f 
  119. ,0x10 ,0x11 ,0x12 ,0x13 ,0x14 ,0x15 ,0x16 ,0x17 
  120. ,0x18 ,0x19 ,0x1a ,0x1b ,0x1c ,0x1d ,0x1e ,0x1f 
  121. ,0x20 ,0x21 ,0x22 ,0x23 ,0x24 ,0x25 ,0x26 ,0x27 
  122. ,0x28 ,0x29 ,0x2a ,0x2b ,0x2c ,0x2d ,0x2e ,0x2f 
  123. ,0x30 ,0x31 ,0x32 ,0x33 ,0x34 ,0x35 ,0x36 ,0x37 
  124. ,0x38 ,0x39 ,0x3a ,0x3b ,0x3c ,0x3d ,0x3e ,0x3f 
  125. ,0x40 ,0x41 ,0x42 ,0x43 ,0x44 ,0x45 ,0x46 ,0x47 
  126. ,0x48 ,0x49 ,0x4a ,0x4b ,0x4c ,0x4d ,0x4e ,0x4f 
  127. ,0x50 ,0x51 ,0x52 ,0x53 ,0x54 ,0x55 ,0x56 ,0x57 
  128. ,0x58 ,0x59 ,0x5a ,0x5b ,0x5c ,0x5d ,0x5e ,0x5f 
  129. ,0x60 ,0x61 ,0x62 ,0x63 ,0x64 ,0x65 ,0x66 ,0x67 
  130. ,0x68 ,0x69 ,0x6a ,0x6b ,0x6c ,0x6d ,0x6e ,0x6f 
  131. ,0x70 ,0x71 ,0x72 ,0x73 ,0x74 ,0x75 ,0x76 ,0x77 
  132. ,0x78 ,0x79 ,0x7a ,0x7b ,0x7c ,0x7d ,0x7e ,0x7f 
  133. ,0x80 ,0x81 ,0x82 ,0x83 ,0x84 ,0x85 ,0x86 ,0x87 
  134. ,0x88 ,0x89 ,0x8a ,0x8b ,0x8c ,0x8d ,0x8e ,0x8f 
  135. ,0x90 ,0x91 ,0x92 ,0x93 ,0x94 ,0x95 ,0x96 ,0x97 
  136. ,0x98 ,0x99 ,0x9a ,0x9b ,0x9c ,0x9d ,0x9e ,0x9f 
  137. ,0xa0 ,0xa1 ,0xa2 ,0xa3 ,0xa4 ,0xa5 ,0xa6 ,0xa7 
  138. ,0xa8 ,0xa9 ,0xaa ,0xab ,0xac ,0xad ,0xae ,0xaf 
  139. ,0xb0 ,0xb1 ,0xb2 ,0xb3 ,0xb4 ,0xb5 ,0xb6 ,0xb7 
  140. ,0xb8 ,0xb9 ,0xba ,0xbb ,0xbc ,0xbd ,0xbe ,0xbf 
  141. ,0xc0 ,0xc1 ,0xc2 ,0xc3 ,0xc4 ,0xc5 ,0xc6 ,0xc7 
  142. ,0xc8 ,0xc9 ,0xca ,0xcb ,0xcc ,0xcd ,0xce ,0xcf 
  143. ,0xd0 ,0xd1 ,0xd2 ,0xd3 ,0xd4 ,0xd5 ,0xd6 ,0xd7 
  144. ,0xd8 ,0xd9 ,0xda ,0xdb ,0xdc ,0xdd ,0xde ,0xdf 
  145. ,0xe0 ,0xe1 ,0xe2 ,0xe3 ,0xe4 ,0xe5 ,0xe6 ,0xe7 
  146. ,0xe8 ,0xe9 ,0xea ,0xeb ,0xec ,0xed ,0xee ,0xef 
  147. ,0xf0 ,0xf1 ,0xf2 ,0xf3 ,0xf4 ,0xf5 ,0xf6 ,0xf7 
  148. ,0xf8 ,0xf9 ,0xfa ,0xfb ,0xfc ,0xfd ,0xfe ,0xff 
  149. ,0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 
  150. ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f 
  151. ,0x10 ,0x11 ,0x12 ,0x13 ,0x14 ,0x15 ,0x16 ,0x17 
  152. ,0x18 ,0x19 ,0x1a ,0x1b ,0x1c ,0x1d ,0x1e ,0x1f 
  153. ,0x20 ,0x21 ,0x22 ,0x23 ,0x24 ,0x25 ,0x26 ,0x27 
  154. ,0x28 ,0x29 ,0x2a ,0x2b ,0x2c ,0x2d ,0x2e ,0x2f 
  155. ,0x30 ,0x31 ,0x32 ,0x33 ,0x34 ,0x35 ,0x36 ,0x37 
  156. ,0x38 ,0x39 ,0x3a ,0x3b ,0x3c ,0x3d ,0x3e ,0x3f 
  157. ,0x40 ,0x41 ,0x42 ,0x43 ,0x44 ,0x45 ,0x46 ,0x47 
  158. ,0x48 ,0x49 ,0x4a ,0x4b ,0x4c ,0x4d ,0x4e ,0x4f 
  159. ,0x50 ,0x51 ,0x52 ,0x53 ,0x54 ,0x55 ,0x56 ,0x57 
  160. ,0x58 ,0x59 ,0x5a ,0x5b ,0x5c ,0x5d ,0x5e ,0x5f 
  161. ,0x60 ,0x61 ,0x62 ,0x63 ,0x64 ,0x65 ,0x66 ,0x67 
  162. ,0x68 ,0x69 ,0x6a ,0x6b ,0x6c ,0x6d ,0x6e ,0x6f 
  163. ,0x70 ,0x71 ,0x72 ,0x73 ,0x74 ,0x75 ,0x76 ,0x77 
  164. ,0x78 ,0x79 ,0x7a ,0x7b ,0x7c ,0x7d ,0x7e ,0x7f 
  165. ,0x80 ,0x81 ,0x82 ,0x83 ,0x84 ,0x85 ,0x86 ,0x87 
  166. ,0x88 ,0x89 ,0x8a ,0x8b ,0x8c ,0x8d ,0x8e ,0x8f 
  167. ,0x90 ,0x91 ,0x92 ,0x93 ,0x94 ,0x95 ,0x96 ,0x97 
  168. ,0x98 ,0x99 ,0x9a ,0x9b ,0x9c ,0x9d ,0x9e ,0x9f 
  169. ,0xa0 ,0xa1 ,0xa2 ,0xa3 ,0xa4 ,0xa5 ,0xa6 ,0xa7 
  170. ,0xa8 ,0xa9 ,0xaa ,0xab ,0xac ,0xad ,0xae ,0xaf 
  171. ,0xb0 ,0xb1 ,0xb2 ,0xb3 ,0xb4 ,0xb5 ,0xb6 ,0xb7 
  172. ,0xb8 ,0xb9 ,0xba ,0xbb ,0xbc ,0xbd ,0xbe ,0xbf 
  173. ,0xc0 ,0xc1 ,0xc2 ,0xc3 ,0xc4 ,0xc5 ,0xc6 ,0xc7 
  174. ,0xc8 ,0xc9 ,0xca ,0xcb ,0xcc ,0xcd ,0xce ,0xcf 
  175. ,0xd0 ,0xd1 ,0xd2 ,0xd3 ,0xd4 ,0xd5 ,0xd6 ,0xd7 
  176. ,0xd8 ,0xd9 ,0xda ,0xdb ,0xdc ,0xdd ,0xde ,0xdf 
  177. ,0xe0 ,0xe1 ,0xe2 ,0xe3 ,0xe4 ,0xe5 ,0xe6 ,0xe7 
  178. ,0xe8 ,0xe9 ,0xea ,0xeb ,0xec ,0xed ,0xee ,0xef 
  179. ,0xf0 ,0xf1 ,0xf2 ,0xf3 ,0xf4 ,0xf5 ,0xf6 ,0xf7 
  180. ,0xf8 ,0xf9 ,0xfa ,0xfb ,0xfc ,0xfd ,0xfe ,0xff
  181. };
  182. #endif
  184. /* Netpool create */
  185. LOCAL int
  186. roboTxRxNetpoolCreate()
  187. {
  188.     robo_txrx_info.roboNetPoolID =  (NET_POOL_ID)calloc(1, sizeof(NET_POOL));
  190.     if (robo_txrx_info.roboNetPoolID == NULL) {
  191.         return(0);
  192.     }
  194.     robo_txrx_info.m_cl_blks.mBlkNum = ROBO_TXRX_MBLKS;
  195.     robo_txrx_info.m_cl_blks.clBlkNum = ROBO_TXRX_CLBLKS;
  196.     robo_txrx_info.m_cl_blks.memSize =
  197.             (robo_txrx_info.m_cl_blks.mBlkNum * (M_BLK_SZ + sizeof(long))) +
  198.             (robo_txrx_info.m_cl_blks.clBlkNum * (CL_BLK_SZ + sizeof(long)));;
  199.     robo_txrx_info.m_cl_blks.memArea = 
  200.             (char *)memalign (sizeof (long), robo_txrx_info.m_cl_blks.memSize);
  201.     if (robo_txrx_info.m_cl_blks.memArea == NULL) {
  202.         free(robo_txrx_info.roboNetPoolID);
  203.         robo_txrx_info.roboNetPoolID = NULL;
  204.         return(0);
  205.     }
  207.     robo_txrx_info.cluster.clNum = ROBO_TXRX_CLBUFS;
  208.     robo_txrx_info.cluster.clSize = ROBO_TX_RX_PK_SZ;
  209.     robo_txrx_info.cluster.memSize = robo_txrx_info.cluster.clNum *
  210.             (robo_txrx_info.cluster.clSize + sizeof(long)) + sizeof(long);
  211.     robo_txrx_info.cluster.memArea = cacheDmaMalloc(
  212.                                     robo_txrx_info.cluster.memSize);
  213.     if (robo_txrx_info.cluster.memArea == NULL) {
  214.         free(robo_txrx_info.roboNetPoolID);
  215.         robo_txrx_info.roboNetPoolID = NULL;
  216.         free(robo_txrx_info.m_cl_blks.memArea);
  217.         robo_txrx_info.m_cl_blks.memArea = NULL;
  218.         return(0);
  219.     }
  221.     if (netPoolInit(robo_txrx_info.roboNetPoolID,
  222.                 &robo_txrx_info.m_cl_blks,
  223.                 &robo_txrx_info.cluster, 1, NULL) != OK) {
  225.         free(robo_txrx_info.roboNetPoolID);
  226.         robo_txrx_info.roboNetPoolID = NULL;
  227.         free(robo_txrx_info.m_cl_blks.memArea);
  228.         robo_txrx_info.m_cl_blks.memArea = NULL;
  229.         free(robo_txrx_info.cluster.memArea);
  230.         robo_txrx_info.cluster.memArea = NULL;
  231.         return(0);
  232.     }
  233.     robo_txrx_info.clpool_id = netClPoolIdGet(robo_txrx_info.roboNetPoolID,
  234.                                 robo_txrx_info.cluster.clSize, FALSE);
  235.     return(1);
  236. }
  238. LOCAL int
  239. _roboTx(M_BLK_ID pMblk)
  240. {
  241.     char zd[] = {0,0,0,0,0,0};
  242. #ifdef ROBO_TXRX_DEBUG
  243.     if (robo_txrx_debug & ROBO_TXRX_DEBUG_F) {
  244.         logMsg("Sending a packet %08xn", (int)pMblk, 2, 3, 4, 5, 6);
  245.         robo_txrx_print_packet(pMblk);
  246.     }
  247. #endif
  249.     if (muxTkSend( robo_txrx_info.roboMuxBindID, pMblk, zd, 0x0806, 0) == ERROR)
  250.     {
  251.         logMsg("muxTkSend failed n", 1, 2, 3, 4, 5, 6);
  252.         netMblkClChainFree(pMblk);
  253.         robo_txrx_info.tx_fail++;
  254.         return(0);
  255.     }
  256.     robo_txrx_info.tx_cnt++;
  257.     return(1);
  258. }
  260. LOCAL BOOL
  261. roboRecv(void *netCallbackId, long type, M_BLK_ID pMblk, void *pSpareData)
  262. {
  263.     UINT8 *buf;
  264.     robo_txrx_info.rx_cnt++;
  266. #if 0
  267.     /* Adjust the data ptr and len to get back the ETH header */
  268.     pMblk->mBlkHdr.mData        -= LINK_HDR_LEN;
  269.     pMblk->mBlkHdr.mLen         += LINK_HDR_LEN;
  270.     pMblk->mBlkPktHdr.len       += LINK_HDR_LEN;
  271. #endif
  273. #ifdef ROBO_TXRX_DEBUG
  274.     if (robo_txrx_debug & ROBO_TXRX_DEBUG_F) {
  275.         robo_txrx_print_packet(pMblk);
  276.     }
  277. #endif
  278.     if (robo_txrx_info.queue_rx_pkts) {
  279.         if (robo_txrx_info.rx_cb != NULL) {
  280.             ROBO_TXRX_PRINT("Received a packet %08xn", (int)pMblk, 2, 3, 4, 5, 6);
  281.             robo_txrx_info.rx_cb(pMblk, pMblk->mBlkPktHdr.len);
  282.         } else {
  283.             netMblkClChainFree(pMblk);
  284.         }
  285.     } else {
  286.         /* copy the packet and pass it to the  application (TCL) */
  287.         /*                                                       */
  288.         if (robo_txrx_info.rx_cb != NULL) {
  289.             buf = robo_txrx_info.rx_alloc(pMblk->mBlkPktHdr.len);
  290.             if (buf != NULL) { 
  291.                 netMblkToBufCopy(pMblk, buf, NULL);
  292.                 robo_txrx_info.rx_cb(buf, pMblk->mBlkPktHdr.len);
  293.             } else {
  294.                 robo_txrx_info.rx_out_of_mem++;
  295.             }
  296.         }
  297.         /*                                                       */
  298.         /* copy the packet and pass it to the  application (TCL) */
  300.         netMblkClChainFree(pMblk);
  301.     }
  303.     return (1);
  304. }
  306. LOCAL BOOL
  307. roboTxShutdownRtn(void *netCallbackId)
  308. {
  309.     return (1);
  310. }
  312. LOCAL BOOL
  313. roboTxRestartRtn(void *netCallbackId)
  314. {
  315.     return (1);
  316. }
  318. LOCAL void
  319. roboErrorRtn(void *netCallbackId, END_ERR * pError)
  320. {
  321.     return;
  322. }
  324. /* Publicly exported functions */
  326. void roboTxRxInit()
  327. {
  328.     END_OBJ *pEndObj = NULL;
  330.     if (robo_txrx_info.roboMuxBindID != NULL) {
  331.         return;
  332.     }
  334.     roboTxRxNetpoolCreate();
  336.     /* Bind roboTxRx Network service to the END driver. */
  337.     robo_txrx_info.roboMuxBindID = (void *) muxTkBind(
  338.                         ROBO_MII_DEVICE_NAME, ROBO_MII_DEV_UNIT,
  339.                         roboRecv, roboTxShutdownRtn,
  340.                         roboTxRestartRtn, roboErrorRtn,
  341.                         MUX_PROTO_SNARF, "ROBO TX/RX",
  342.                         pEndObj,(void *) 0, (void *) 0);
  343.     if (!robo_txrx_info.roboMuxBindID)
  344.     {
  345.         logMsg("muxTkBind Failed (%08x).n", errnoGet(), 2, 3, 4, 5, 6);
  346.         return;
  347.     }
  349.     /* Promiscuous mode */
  350.     muxIoctl( robo_txrx_info.roboMuxBindID, EIOCSFLAGS, (void *)IFF_PROMISC);
  351. }
  353. int
  354. bcmRoboTx(UINT8 *b, int l)
  355. {
  356.     M_BLK_ID pMblk;
  358.     pMblk = netTupleGet(robo_txrx_info.roboNetPoolID, l,
  359.                         M_DONTWAIT, MT_DATA,FALSE);
  360.     if (pMblk == NULL) {
  361.         robo_txrx_info.tx_fail++;
  362.         return(0);
  363.     }
  364.     /* cache invalidate */
  365.     /* CACHE_INVALIDATE(pMblk->m_data, l); */
  366.     pMblk->mBlkHdr.mFlags  |= M_PKTHDR;
  367.     pMblk->mBlkHdr.mLen     = l;
  368.     pMblk->mBlkPktHdr.len   = l;
  370.     memcpy(pMblk->m_data, b, l);
  371.     return (_roboTx(pMblk));
  372. }
  374. int
  375. roboMIIRxHandlerRegister(cb_f cf, alloc_f af, free_f ff)
  376. {
  377.     if (robo_txrx_info.rx_cb == NULL) {
  378.         robo_txrx_info.rx_alloc = af;
  379.         robo_txrx_info.rx_free = ff;
  380.         robo_txrx_info.rx_cb = cf;
  381.         return(1);
  382.     } else {
  383.         return(0);
  384.     }
  385. }
  386. int
  387. roboMIIRxHandlerUnRegister(cb_f f)
  388. {
  389.     if (robo_txrx_info.rx_cb == f) {
  390.         robo_txrx_info.rx_cb = NULL;
  391.         return(1);
  392.     } else {
  393.         return(0);
  394.     }
  395. }
  397. void robo_rx_drain_pkts()
  398. {
  399.     M_BLK_ID pMblk, cMblk;
  400.     int s;
  402.     s = intLock();
  403.     pMblk = robo_txrx_info.rx_head;
  404.     robo_txrx_info.rx_tail = robo_txrx_info.rx_head = NULL;
  405.     while(pMblk) {
  406.         cMblk = pMblk;
  407.         netMblkClChainFree(cMblk);
  408.         pMblk = pMblk->mBlkHdr.mNextPkt;
  409.     }
  410. }
  412. void robo_rx_q_pkts(M_BLK_ID pMblk, int dummy)
  413. {
  414.     M_BLK_ID qMblk;
  415.     int s;
  417.     s = intLock();
  418.     if (robo_txrx_info.rx_tail == NULL ) {
  419.         robo_txrx_info.rx_tail = pMblk;
  420.         robo_txrx_info.rx_head = pMblk;
  421.     } else {
  422.         qMblk = robo_txrx_info.rx_tail;
  423.         qMblk->mBlkHdr.mNextPkt = pMblk;
  424.         robo_txrx_info.rx_tail = pMblk;
  425.         pMblk->mBlkHdr.mNextPkt = NULL;
  426.     }
  427.     intUnlock(s);
  429.     ROBO_TXRX_PRINT("Queued a packet %08xn", (int)pMblk, 2, 3, 4, 5, 6);
  431.     /* Indicate that a packet is available */
  432.     /* semTake(robo_txrx_info.rx_sem, WAIT_FOREVER); */
  433. }
  435. void bcm_robo_mii_rx(UINT8 *b, int *l)
  436. {
  437.     M_BLK_ID pMblk;
  438.     int s;
  439.     int n = 10;
  441.     *l = 0;
  443.     while(*l == 0) {
  444.         pMblk = robo_txrx_info.rx_head;
  445.         if (pMblk != NULL) {
  446.             s = intLock();
  447.             robo_txrx_info.rx_head = pMblk->mBlkHdr.mNextPkt;
  448.             if (robo_txrx_info.rx_head == NULL) {
  449.                 robo_txrx_info.rx_tail = NULL;
  450.             }
  451.             intUnlock(s);
  454.             *l = pMblk->mBlkPktHdr.len;
  455.             netMblkToBufCopy(pMblk, b, NULL);
  456.             netMblkClChainFree(pMblk);
  457.             ROBO_TXRX_PRINT("DeQueued a packet %08x len = %dn",
  458.                             (int)pMblk, *l, 3, 4, 5, 6);
  459.         } else {
  460.             /* Wait for a packet */
  461.             /* semTake(robo_txrx_info.rx_sem); */
  462.             taskDelay(1);
  463.             if (!(n--)) break;
  464.         }
  465.     }
  466. }
  469. void bcm_robo_mii_rx_start()
  470. {
  471.     ROBO_TXRX_PRINT("bcm_robo_mii_rx_startn", 1, 2, 3, 4, 5, 6);
  472.     robo_txrx_info.queue_rx_pkts = 1;
  473.     roboMIIRxHandlerRegister(robo_rx_q_pkts, NULL, NULL);
  474. }
  476. void bcm_robo_mii_rx_stop()
  477. {
  478.     ROBO_TXRX_PRINT("bcm_robo_mii_rx_stopn", 1, 2, 3, 4, 5, 6);
  479.     if (roboMIIRxHandlerUnRegister(robo_rx_q_pkts)) {
  480.         robo_txrx_info.queue_rx_pkts = 0;
  481.         robo_rx_drain_pkts();
  482.     }
  483. }
  486. #ifdef ROBO_TXRX_DEBUG
  487. /* debug */
  489. LOCAL void
  490. robo_rx_test_cb(char *buf, int len)
  491. {
  492.     logMsg("robo_rx_test_cb:",1,2,3,4,5,6);
  493.     robo_txrx_pp(buf, len);
  494.     free(buf);
  495. }
  497. void
  498. robo_tx_netpool_show()
  499. {
  500.     netPoolShow(robo_txrx_info.roboNetPoolID);
  501. }
  503. void
  504. robo_rx_test()
  505. {
  506.     roboMIIRxHandlerRegister(robo_rx_test_cb, malloc, free);
  507. }
  510. void
  511. robo_tx_test(int l)
  512. {
  513.     if (l > 512) {
  514.         l = 64;
  515.     }
  516.     if (!bcmRoboTx(robo_tx_test_pkbuf, l)) {
  517.         logMsg("Robo TX failed",1,2,3,4,5,6);
  518.     }
  519. }
  520. #endif