mux_drv.c (16003B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 */ 7 #if defined(VXWORKS) && (VX_VERSION > 54) 8 9 #include <stdlib.h> 10 #include <end.h> 11 #include <taskLib.h> 12 #include <muxLib.h> 13 #include <muxTkLib.h> 14 #include <netBufLib.h> 15 #include <errnoLib.h> 16 #include <time.h> 17 #include <cacheLib.h> 18 #include <logLib.h> 19 #include <intLib.h> 20 21 #ifdef VXWORKS_NETWORK_STACK_6_5 22 #include <if.h> 23 #include <string.h> 24 #endif /* VXWORKS_NETWORK_STACK_6_5 */ 25 26 #include "mux_drv.h" 27 28 #define ET_DRV_TXRX_DEBUG 29 #define ET_DRV_TX_TEST_XXXX 30 31 #define ET_DRV_TX_RX_PK_SZ 2048 32 #define ET_DRV_TXRX_CLBLKS 256 33 #define ET_DRV_TXRX_MBLKS 256 34 #define ET_DRV_TXRX_CLBUFS 256 35 36 typedef struct et_drv_txrx_info_s { 37 void * et_drvMuxBindID; 38 void * et_drvNetPoolID; 39 M_CL_CONFIG m_cl_blks; 40 CL_DESC cluster; 41 CL_POOL_ID clpool_id; 42 cb_f rx_cb; 43 void * cookie; 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 } et_drv_txrx_info_t; 54 55 LOCAL et_drv_txrx_info_t et_drv_txrx_info[ETH_MAX_UNITS]; 56 #ifdef ET_DRV_TXRX_DEBUG 57 int et_drv_txrx_debug = 0; 58 #endif 59 60 #define ET_DRV_TXRX_DEBUG_F 0x00000001 61 #define ET_DRV_TXRX_DEBUG_P 0x00000002 62 #define ET_DRV_TXRX_PRINT if (et_drv_txrx_debug & ET_DRV_TXRX_DEBUG_P) logMsg 63 64 65 #ifdef ET_DRV_TXRX_DEBUG 66 /* debug test functions */ 67 void et_drv_tx_test(int unit, int l); 68 void et_drv_rx_test(int unit); 69 void et_drv_tx_netpool_show(int unit); 70 71 #include <stdio.h> 72 73 /* Debug */ 74 LOCAL void 75 et_drv_txrx_pp(UINT8 *p, int l) 76 { 77 int i; 78 79 for(i=0; i < l; i++) { 80 if ((i % 16) == 0) { 81 printf("\n%02x :", i); 82 } 83 printf("%02x ", *p++); 84 } 85 printf("\n"); 86 } 87 88 /* Debug */ 89 LOCAL void 90 et_drv_txrx_print_packet(M_BLK_ID pMblk) 91 { 92 unsigned char *p; 93 94 pMblk->mBlkHdr.mFlags &=(~(M_BCAST | M_MCAST)); 95 96 printf("pklen=%d mLen=%d mType=%d mNext=%08x mData=%08x\n", 97 pMblk->mBlkPktHdr.len, 98 pMblk->mBlkHdr.mLen, 99 pMblk->mBlkHdr.mType, 100 (int)pMblk->mBlkHdr.mNext, 101 (int)pMblk->mBlkHdr.mData); 102 103 p = (unsigned char *)pMblk->mBlkHdr.mData; 104 et_drv_txrx_pp(p, pMblk->mBlkPktHdr.len); 105 } 106 107 UINT8 et_drv_tx_test_pkbuf[512] = { 108 0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 109 ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f 110 ,0x10 ,0x11 ,0x12 ,0x13 ,0x14 ,0x15 ,0x16 ,0x17 111 ,0x18 ,0x19 ,0x1a ,0x1b ,0x1c ,0x1d ,0x1e ,0x1f 112 ,0x20 ,0x21 ,0x22 ,0x23 ,0x24 ,0x25 ,0x26 ,0x27 113 ,0x28 ,0x29 ,0x2a ,0x2b ,0x2c ,0x2d ,0x2e ,0x2f 114 ,0x30 ,0x31 ,0x32 ,0x33 ,0x34 ,0x35 ,0x36 ,0x37 115 ,0x38 ,0x39 ,0x3a ,0x3b ,0x3c ,0x3d ,0x3e ,0x3f 116 ,0x40 ,0x41 ,0x42 ,0x43 ,0x44 ,0x45 ,0x46 ,0x47 117 ,0x48 ,0x49 ,0x4a ,0x4b ,0x4c ,0x4d ,0x4e ,0x4f 118 ,0x50 ,0x51 ,0x52 ,0x53 ,0x54 ,0x55 ,0x56 ,0x57 119 ,0x58 ,0x59 ,0x5a ,0x5b ,0x5c ,0x5d ,0x5e ,0x5f 120 ,0x60 ,0x61 ,0x62 ,0x63 ,0x64 ,0x65 ,0x66 ,0x67 121 ,0x68 ,0x69 ,0x6a ,0x6b ,0x6c ,0x6d ,0x6e ,0x6f 122 ,0x70 ,0x71 ,0x72 ,0x73 ,0x74 ,0x75 ,0x76 ,0x77 123 ,0x78 ,0x79 ,0x7a ,0x7b ,0x7c ,0x7d ,0x7e ,0x7f 124 ,0x80 ,0x81 ,0x82 ,0x83 ,0x84 ,0x85 ,0x86 ,0x87 125 ,0x88 ,0x89 ,0x8a ,0x8b ,0x8c ,0x8d ,0x8e ,0x8f 126 ,0x90 ,0x91 ,0x92 ,0x93 ,0x94 ,0x95 ,0x96 ,0x97 127 ,0x98 ,0x99 ,0x9a ,0x9b ,0x9c ,0x9d ,0x9e ,0x9f 128 ,0xa0 ,0xa1 ,0xa2 ,0xa3 ,0xa4 ,0xa5 ,0xa6 ,0xa7 129 ,0xa8 ,0xa9 ,0xaa ,0xab ,0xac ,0xad ,0xae ,0xaf 130 ,0xb0 ,0xb1 ,0xb2 ,0xb3 ,0xb4 ,0xb5 ,0xb6 ,0xb7 131 ,0xb8 ,0xb9 ,0xba ,0xbb ,0xbc ,0xbd ,0xbe ,0xbf 132 ,0xc0 ,0xc1 ,0xc2 ,0xc3 ,0xc4 ,0xc5 ,0xc6 ,0xc7 133 ,0xc8 ,0xc9 ,0xca ,0xcb ,0xcc ,0xcd ,0xce ,0xcf 134 ,0xd0 ,0xd1 ,0xd2 ,0xd3 ,0xd4 ,0xd5 ,0xd6 ,0xd7 135 ,0xd8 ,0xd9 ,0xda ,0xdb ,0xdc ,0xdd ,0xde ,0xdf 136 ,0xe0 ,0xe1 ,0xe2 ,0xe3 ,0xe4 ,0xe5 ,0xe6 ,0xe7 137 ,0xe8 ,0xe9 ,0xea ,0xeb ,0xec ,0xed ,0xee ,0xef 138 ,0xf0 ,0xf1 ,0xf2 ,0xf3 ,0xf4 ,0xf5 ,0xf6 ,0xf7 139 ,0xf8 ,0xf9 ,0xfa ,0xfb ,0xfc ,0xfd ,0xfe ,0xff 140 ,0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 141 ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f 142 ,0x10 ,0x11 ,0x12 ,0x13 ,0x14 ,0x15 ,0x16 ,0x17 143 ,0x18 ,0x19 ,0x1a ,0x1b ,0x1c ,0x1d ,0x1e ,0x1f 144 ,0x20 ,0x21 ,0x22 ,0x23 ,0x24 ,0x25 ,0x26 ,0x27 145 ,0x28 ,0x29 ,0x2a ,0x2b ,0x2c ,0x2d ,0x2e ,0x2f 146 ,0x30 ,0x31 ,0x32 ,0x33 ,0x34 ,0x35 ,0x36 ,0x37 147 ,0x38 ,0x39 ,0x3a ,0x3b ,0x3c ,0x3d ,0x3e ,0x3f 148 ,0x40 ,0x41 ,0x42 ,0x43 ,0x44 ,0x45 ,0x46 ,0x47 149 ,0x48 ,0x49 ,0x4a ,0x4b ,0x4c ,0x4d ,0x4e ,0x4f 150 ,0x50 ,0x51 ,0x52 ,0x53 ,0x54 ,0x55 ,0x56 ,0x57 151 ,0x58 ,0x59 ,0x5a ,0x5b ,0x5c ,0x5d ,0x5e ,0x5f 152 ,0x60 ,0x61 ,0x62 ,0x63 ,0x64 ,0x65 ,0x66 ,0x67 153 ,0x68 ,0x69 ,0x6a ,0x6b ,0x6c ,0x6d ,0x6e ,0x6f 154 ,0x70 ,0x71 ,0x72 ,0x73 ,0x74 ,0x75 ,0x76 ,0x77 155 ,0x78 ,0x79 ,0x7a ,0x7b ,0x7c ,0x7d ,0x7e ,0x7f 156 ,0x80 ,0x81 ,0x82 ,0x83 ,0x84 ,0x85 ,0x86 ,0x87 157 ,0x88 ,0x89 ,0x8a ,0x8b ,0x8c ,0x8d ,0x8e ,0x8f 158 ,0x90 ,0x91 ,0x92 ,0x93 ,0x94 ,0x95 ,0x96 ,0x97 159 ,0x98 ,0x99 ,0x9a ,0x9b ,0x9c ,0x9d ,0x9e ,0x9f 160 ,0xa0 ,0xa1 ,0xa2 ,0xa3 ,0xa4 ,0xa5 ,0xa6 ,0xa7 161 ,0xa8 ,0xa9 ,0xaa ,0xab ,0xac ,0xad ,0xae ,0xaf 162 ,0xb0 ,0xb1 ,0xb2 ,0xb3 ,0xb4 ,0xb5 ,0xb6 ,0xb7 163 ,0xb8 ,0xb9 ,0xba ,0xbb ,0xbc ,0xbd ,0xbe ,0xbf 164 ,0xc0 ,0xc1 ,0xc2 ,0xc3 ,0xc4 ,0xc5 ,0xc6 ,0xc7 165 ,0xc8 ,0xc9 ,0xca ,0xcb ,0xcc ,0xcd ,0xce ,0xcf 166 ,0xd0 ,0xd1 ,0xd2 ,0xd3 ,0xd4 ,0xd5 ,0xd6 ,0xd7 167 ,0xd8 ,0xd9 ,0xda ,0xdb ,0xdc ,0xdd ,0xde ,0xdf 168 ,0xe0 ,0xe1 ,0xe2 ,0xe3 ,0xe4 ,0xe5 ,0xe6 ,0xe7 169 ,0xe8 ,0xe9 ,0xea ,0xeb ,0xec ,0xed ,0xee ,0xef 170 ,0xf0 ,0xf1 ,0xf2 ,0xf3 ,0xf4 ,0xf5 ,0xf6 ,0xf7 171 ,0xf8 ,0xf9 ,0xfa ,0xfb ,0xfc ,0xfd ,0xfe ,0xff 172 }; 173 #endif 174 175 /* Netpool create */ 176 LOCAL int 177 et_drvTxRxNetpoolCreate(int unit) 178 { 179 et_drv_txrx_info[unit].et_drvNetPoolID = (NET_POOL_ID)calloc(1, sizeof(NET_POOL)); 180 181 if (et_drv_txrx_info[unit].et_drvNetPoolID == NULL) { 182 return(0); 183 } 184 185 et_drv_txrx_info[unit].m_cl_blks.mBlkNum = ET_DRV_TXRX_MBLKS; 186 et_drv_txrx_info[unit].m_cl_blks.clBlkNum = ET_DRV_TXRX_CLBLKS; 187 et_drv_txrx_info[unit].m_cl_blks.memSize = 188 (et_drv_txrx_info[unit].m_cl_blks.mBlkNum * (M_BLK_SZ + sizeof(long))) + 189 (et_drv_txrx_info[unit].m_cl_blks.clBlkNum * (CL_BLK_SZ + sizeof(long))); 190 et_drv_txrx_info[unit].m_cl_blks.memArea = 191 (char *)memalign (sizeof (long), et_drv_txrx_info[unit].m_cl_blks.memSize); 192 if (et_drv_txrx_info[unit].m_cl_blks.memArea == NULL) { 193 free(et_drv_txrx_info[unit].et_drvNetPoolID); 194 et_drv_txrx_info[unit].et_drvNetPoolID = NULL; 195 return(0); 196 } 197 198 et_drv_txrx_info[unit].cluster.clNum = ET_DRV_TXRX_CLBUFS; 199 et_drv_txrx_info[unit].cluster.clSize = ET_DRV_TX_RX_PK_SZ; 200 et_drv_txrx_info[unit].cluster.memSize = et_drv_txrx_info[unit].cluster.clNum * 201 (et_drv_txrx_info[unit].cluster.clSize + sizeof(long)) + sizeof(long); 202 et_drv_txrx_info[unit].cluster.memArea = cacheDmaMalloc( 203 et_drv_txrx_info[unit].cluster.memSize); 204 if (et_drv_txrx_info[unit].cluster.memArea == NULL) { 205 free(et_drv_txrx_info[unit].et_drvNetPoolID); 206 et_drv_txrx_info[unit].et_drvNetPoolID = NULL; 207 free(et_drv_txrx_info[unit].m_cl_blks.memArea); 208 et_drv_txrx_info[unit].m_cl_blks.memArea = NULL; 209 return(0); 210 } 211 212 if (netPoolInit(et_drv_txrx_info[unit].et_drvNetPoolID, 213 &et_drv_txrx_info[unit].m_cl_blks, 214 &et_drv_txrx_info[unit].cluster, 1, NULL) != OK) { 215 216 free(et_drv_txrx_info[unit].et_drvNetPoolID); 217 et_drv_txrx_info[unit].et_drvNetPoolID = NULL; 218 free(et_drv_txrx_info[unit].m_cl_blks.memArea); 219 et_drv_txrx_info[unit].m_cl_blks.memArea = NULL; 220 free(et_drv_txrx_info[unit].cluster.memArea); 221 et_drv_txrx_info[unit].cluster.memArea = NULL; 222 return(0); 223 } 224 et_drv_txrx_info[unit].clpool_id = netClPoolIdGet(et_drv_txrx_info[unit].et_drvNetPoolID, 225 et_drv_txrx_info[unit].cluster.clSize, FALSE); 226 return(1); 227 } 228 229 LOCAL int 230 _et_drvTx(int unit, M_BLK_ID pMblk) 231 { 232 #ifdef ET_DRV_TXRX_DEBUG 233 if (et_drv_txrx_debug & ET_DRV_TXRX_DEBUG_F) { 234 logMsg("Sending a packet %08x\n", (int)pMblk, 2, 3, 4, 5, 6); 235 et_drv_txrx_print_packet(pMblk); 236 } 237 #endif 238 239 if (muxSend( et_drv_txrx_info[unit].et_drvMuxBindID, pMblk) == ERROR) 240 { 241 logMsg("muxTkSend failed \n", 1, 2, 3, 4, 5, 6); 242 netMblkClChainFree(pMblk); 243 et_drv_txrx_info[unit].tx_fail++; 244 return(-1); 245 } 246 et_drv_txrx_info[unit].tx_cnt++; 247 return(0); 248 } 249 250 LOCAL BOOL 251 et_drvRecv(void *pCookie, long type, M_BLK_ID pMblk, 252 LL_HDR_INFO * pLinkHdrInfo, void *pSpareData) 253 { 254 int rv = -1, unit; 255 UINT8 *buf; 256 257 for (unit = 0 ; unit < ETH_MAX_UNITS; unit++) { 258 if ((void *)et_drv_txrx_info[unit].et_drvMuxBindID == pCookie) { 259 break; 260 } 261 } 262 263 if (unit == ETH_MAX_UNITS) { 264 return FALSE; 265 } 266 267 et_drv_txrx_info[unit].rx_cnt++; 268 269 #ifdef ET_DRV_TXRX_DEBUG 270 if (et_drv_txrx_debug & ET_DRV_TXRX_DEBUG_F) { 271 et_drv_txrx_print_packet(pMblk); 272 } 273 #endif 274 if (et_drv_txrx_info[unit].rx_cb != NULL) { 275 if (et_drv_txrx_info[unit].rx_alloc != NULL) { 276 buf = et_drv_txrx_info[unit].rx_alloc(pMblk->mBlkPktHdr.len); 277 if (buf != NULL) { 278 netMblkToBufCopy(pMblk,(char *)buf, NULL); 279 rv = et_drv_txrx_info[unit].rx_cb(unit, buf, 280 pMblk->mBlkPktHdr.len, 281 et_drv_txrx_info[unit].cookie); 282 } else { 283 et_drv_txrx_info[unit].rx_out_of_mem++; 284 } 285 } else { 286 rv = et_drv_txrx_info[unit].rx_cb(unit, 287 pMblk->mBlkHdr.mData, 288 pMblk->mBlkPktHdr.len, 289 et_drv_txrx_info[unit].cookie); 290 } 291 } 292 netMblkClChainFree(pMblk); 293 294 return (rv == 0)? TRUE : FALSE; 295 } 296 297 #if 0 298 LOCAL BOOL 299 et_drvTxShutdownRtn(void *netCallbackId) 300 { 301 return (1); 302 } 303 304 LOCAL BOOL 305 et_drvTxRestartRtn(void *netCallbackId) 306 { 307 return (1); 308 } 309 310 LOCAL void 311 et_drvErrorRtn(void *netCallbackId, END_ERR * pError) 312 { 313 return; 314 } 315 #endif 316 317 /* Publicly exported functions */ 318 319 int et_drvTxRxInit(char * dev, int unit) 320 { 321 if (et_drv_txrx_info[unit].et_drvMuxBindID != NULL) { 322 return -1; 323 } 324 325 et_drv_txrx_info[unit].queue_rx_pkts = 0; 326 327 et_drvTxRxNetpoolCreate(unit); 328 329 /* Bind et_drvTxRx Network service to the END driver. */ 330 et_drv_txrx_info[unit].et_drvMuxBindID = (void *) muxBind( 331 dev, unit, 332 et_drvRecv, NULL, 333 NULL, NULL, 334 MUX_PROTO_SNARF, "ET_DRV TX/RX", NULL); 335 336 if (!et_drv_txrx_info[unit].et_drvMuxBindID) 337 { 338 logMsg("muxTkBind Failed (%08x).\n", errnoGet(), 2, 3, 4, 5, 6); 339 return -1; 340 } 341 342 /* Promiscuous mode */ 343 muxIoctl( et_drv_txrx_info[unit].et_drvMuxBindID, EIOCSFLAGS, (void *)IFF_PROMISC); 344 345 return 0; 346 } 347 348 int 349 et_drv_mac_addr_get(int unit, unsigned char *mac) 350 { 351 return muxIoctl( et_drv_txrx_info[unit].et_drvMuxBindID, EIOCGADDR, (void *)mac); 352 } 353 354 int 355 et_drvTx(int unit, UINT8 *b, int l, void *cookie) 356 { 357 M_BLK_ID pMblk; 358 359 pMblk = netTupleGet(et_drv_txrx_info[unit].et_drvNetPoolID, l, 360 M_DONTWAIT, MT_DATA,FALSE); 361 if (pMblk == NULL) { 362 et_drv_txrx_info[unit].tx_fail++; 363 return(0); 364 } 365 /* cache invalidate */ 366 /* CACHE_INVALIDATE(pMblk->m_data, l); */ 367 pMblk->mBlkHdr.mFlags |= M_PKTHDR; 368 pMblk->mBlkHdr.mLen = l; 369 pMblk->mBlkPktHdr.len = l; 370 371 memcpy(pMblk->m_data, b, l); 372 return (_et_drvTx(unit, pMblk)); 373 } 374 375 int 376 et_drvMIIRxHandlerRegister(int unit, cb_f cf, alloc_f af, free_f ff, void *cookie) 377 { 378 if (et_drv_txrx_info[unit].rx_cb == NULL) { 379 et_drv_txrx_info[unit].rx_alloc = af; 380 et_drv_txrx_info[unit].rx_free = ff; 381 et_drv_txrx_info[unit].rx_cb = cf; 382 et_drv_txrx_info[unit].cookie = cookie; 383 return(0); 384 } else { 385 return(1); 386 } 387 } 388 int 389 et_drvMIIRxHandlerUnRegister(int unit, cb_f f) 390 { 391 if (et_drv_txrx_info[unit].rx_cb == f) { 392 et_drv_txrx_info[unit].rx_cb = NULL; 393 return(0); 394 } else { 395 return(1); 396 } 397 } 398 399 void et_drv_rx_drain_pkts(int unit) 400 { 401 M_BLK_ID pMblk, cMblk; 402 int s; 403 404 s = intLock(); 405 pMblk = et_drv_txrx_info[unit].rx_head; 406 et_drv_txrx_info[unit].rx_tail = et_drv_txrx_info[unit].rx_head = NULL; 407 while(pMblk) { 408 cMblk = pMblk; 409 netMblkClChainFree(cMblk); 410 pMblk = pMblk->mBlkHdr.mNextPkt; 411 } 412 intUnlock(s); 413 } 414 415 void et_drv_rx_q_pkts(int unit, M_BLK_ID pMblk, int dummy) 416 { 417 M_BLK_ID qMblk; 418 M_BLK_ID newMblk, newId; 419 int s; 420 421 newMblk = netMblkGet(et_drv_txrx_info[unit].et_drvNetPoolID, 422 M_DONTWAIT, MT_DATA); 423 if (newMblk == NULL) { 424 printf("et_drv_rx_q_pkts : Failed to allocate mbuf\n"); 425 et_drv_txrx_info[unit].tx_fail++; 426 return; 427 } 428 newId = netMblkDup(pMblk, newMblk); 429 if (newId == NULL) { 430 printf("dup failed \n"); 431 return; 432 } 433 434 s = intLock(); 435 if (et_drv_txrx_info[unit].rx_tail == NULL ) { 436 et_drv_txrx_info[unit].rx_tail = newId; 437 et_drv_txrx_info[unit].rx_head = newId; 438 } else { 439 qMblk = et_drv_txrx_info[unit].rx_tail; 440 qMblk->mBlkHdr.mNextPkt = newId; 441 et_drv_txrx_info[unit].rx_tail = newId; 442 newId->mBlkHdr.mNextPkt = NULL; 443 } 444 intUnlock(s); 445 446 ET_DRV_TXRX_PRINT("Queued a packet %08x\n", (int)pMblk, 2, 3, 4, 5, 6); 447 448 /* Indicate that a packet is available */ 449 /* semTake(et_drv_txrx_info.rx_sem, WAIT_FOREVER); */ 450 } 451 452 void et_drv_mii_rx(int unit, UINT8 *b, int *l) 453 { 454 M_BLK_ID pMblk; 455 int s; 456 int n = 10; 457 458 *l = 0; 459 460 while(*l == 0) { 461 pMblk = et_drv_txrx_info[unit].rx_head; 462 if (pMblk != NULL) { 463 s = intLock(); 464 et_drv_txrx_info[unit].rx_head = pMblk->mBlkHdr.mNextPkt; 465 if (et_drv_txrx_info[unit].rx_head == NULL) { 466 et_drv_txrx_info[unit].rx_tail = NULL; 467 } 468 intUnlock(s); 469 470 *l = pMblk->mBlkPktHdr.len; 471 netMblkToBufCopy(pMblk, (char *)b, NULL); 472 netMblkClChainFree(pMblk); 473 ET_DRV_TXRX_PRINT("DeQueued a packet %08x len = %d\n", 474 (int)pMblk, *l, 3, 4, 5, 6); 475 } else { 476 /* Wait for a packet */ 477 /* semTake(et_drv_txrx_info.rx_sem); */ 478 taskDelay(1); 479 if (!(n--)) break; 480 } 481 } 482 } 483 484 485 void et_drv_start(int unit) 486 { 487 ET_DRV_TXRX_PRINT("et_drv_start\n", 1, 2, 3, 4, 5, 6); 488 et_drv_txrx_info[unit].queue_rx_pkts = 1; 489 et_drvMIIRxHandlerRegister(unit, (cb_f) et_drv_rx_q_pkts, NULL, NULL, NULL); 490 } 491 492 void et_drv_stop(int unit) 493 { 494 ET_DRV_TXRX_PRINT("et_drv_stop\n", 1, 2, 3, 4, 5, 6); 495 if (et_drvMIIRxHandlerUnRegister(unit, (cb_f) et_drv_rx_q_pkts)) { 496 et_drv_txrx_info[unit].queue_rx_pkts = 0; 497 et_drv_rx_drain_pkts(unit); 498 } 499 } 500 501 502 #ifdef ET_DRV_TXRX_DEBUG 503 /* debug */ 504 505 LOCAL void 506 et_drv_rx_test_cb(char *buf, int len) 507 { 508 logMsg("et_drv_rx_test_cb:",1,2,3,4,5,6); 509 et_drv_txrx_pp((UINT8 *)buf, len); 510 free(buf); 511 } 512 513 extern void netPoolShow(NET_POOL_ID); 514 void 515 et_drv_tx_netpool_show(int unit) 516 { 517 netPoolShow(et_drv_txrx_info[unit].et_drvNetPoolID); 518 } 519 520 void 521 et_drv_rx_test(int unit) 522 { 523 et_drvMIIRxHandlerRegister(unit, (cb_f) et_drv_rx_test_cb, (alloc_f)malloc, free, NULL); 524 } 525 526 void 527 et_drv_tx_test(int unit, int l) 528 { 529 if (l > 512) { 530 l = 64; 531 } 532 if (!et_drvTx(unit, et_drv_tx_test_pkbuf, l, NULL)) { 533 logMsg("et_drv TX failed",1,2,3,4,5,6); 534 } 535 } 536 #endif 537 538 #endif /* VXWORKS && VX_VERSION > 54 */ 539 540 int mux_drv_not_empty; 541