knet.c (17615B)
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 * File: knet.c 8 * Purpose: Kernel network control 9 */ 10 11 #include <shared/bsl.h> 12 13 #include <soc/drv.h> 14 #include <soc/dma.h> 15 #ifdef BCM_CMICX_SUPPORT 16 #include <soc/cmicx.h> 17 #endif 18 #include <soc/knet.h> 19 #ifdef BCM_PETRA_SUPPORT 20 #include <soc/dpp/drv.h> 21 #include <soc/dpp/ARAD/arad_api_mgmt.h> 22 #endif 23 24 #ifdef INCLUDE_KNET 25 26 static soc_knet_vectors_t kvect; 27 28 #define KNET_OPEN kvect.kcom.open 29 #define KNET_CLOSE kvect.kcom.close 30 #define KNET_SEND kvect.kcom.send 31 #define KNET_RECV kvect.kcom.recv 32 33 static void *knet_chan; 34 35 typedef struct knet_cmd_ctrl_s { 36 sal_mutex_t cmd_lock; 37 sal_mutex_t msg_lock; 38 sal_sem_t cmd_done; 39 int opcode; 40 int seqno; 41 int resp_len; 42 kcom_msg_t resp_msg; 43 } knet_cmd_ctrl_t; 44 45 static knet_cmd_ctrl_t knet_cmd_ctrl; 46 47 /* 48 * Simple handler registration (emphasis on simple). 49 */ 50 #define MAX_CALLBACKS 5 51 52 static struct callback_ctrl_s { 53 soc_knet_rx_cb_t cb; 54 void* cookie; 55 } _callback_ctrl[MAX_CALLBACKS]; 56 57 #define KNET_RX_THREAD_STOPPED 0 58 #define KNET_RX_THREAD_RUNNING 1 59 #define KNET_RX_THREAD_STOPPING 2 60 61 static int knet_rx_thread_run = 0; 62 63 int 64 soc_knet_rx_register(soc_knet_rx_cb_t callback, void *cookie, uint32 flags) 65 { 66 int idx; 67 68 for (idx = 0; idx < MAX_CALLBACKS; idx++) { 69 if (_callback_ctrl[idx].cb == NULL) { 70 _callback_ctrl[idx].cb = callback; 71 _callback_ctrl[idx].cookie = cookie; 72 return SOC_E_NONE; 73 } 74 } 75 return SOC_E_RESOURCE; 76 } 77 78 int 79 soc_knet_rx_unregister(soc_knet_rx_cb_t callback) 80 { 81 int idx; 82 83 for (idx = 0; idx < MAX_CALLBACKS; idx++) { 84 if (_callback_ctrl[idx].cb == callback) { 85 _callback_ctrl[idx].cb = NULL; 86 _callback_ctrl[idx].cookie = NULL; 87 } 88 } 89 return SOC_E_NONE; 90 } 91 92 int 93 soc_knet_handle_cmd_resp(kcom_msg_t *kmsg, unsigned int len, void *cookie) 94 { 95 knet_cmd_ctrl_t *ctrl = (knet_cmd_ctrl_t *)cookie; 96 97 if (kmsg->hdr.type != KCOM_MSG_TYPE_RSP) { 98 /* Not handled */ 99 return 0; 100 } 101 if (kmsg->hdr.opcode != ctrl->opcode) { 102 LOG_CLI((BSL_META("soc_knet_handle_cmd_resp: wrong opcode %d (expected %d)\n"), 103 kmsg->hdr.opcode, ctrl->opcode)); 104 } else if (kmsg->hdr.seqno != ctrl->seqno) { 105 LOG_CLI((BSL_META("soc_knet_handle_cmd_resp: wrong seq no %d (expected %d)\n"), 106 kmsg->hdr.seqno, ctrl->seqno)); 107 } else { 108 if (len > sizeof(ctrl->resp_msg)) { 109 LOG_CLI((BSL_META("soc_knet_handle_cmd_resp: resp too long (%d bytes)\n"), 110 len)); 111 } else { 112 LOG_VERBOSE(BSL_LS_SOC_COMMON, 113 (BSL_META("soc_knet_handle_cmd_resp: got %d bytes\n"), len)); 114 if (kmsg->hdr.status != 0) { 115 LOG_VERBOSE(BSL_LS_SOC_COMMON, 116 (BSL_META("soc_knet_handle_cmd_resp: status %d\n"), 117 kmsg->hdr.status)); 118 } 119 sal_mutex_take(ctrl->msg_lock, sal_mutex_FOREVER); 120 sal_memcpy(&ctrl->resp_msg, kmsg, len); 121 ctrl->resp_len = len; 122 sal_mutex_give(ctrl->msg_lock); 123 } 124 sal_sem_give(ctrl->cmd_done); 125 } 126 /* Handled */ 127 return 1; 128 } 129 130 int 131 soc_knet_cmd_req(kcom_msg_t *kmsg, unsigned int len, unsigned int buf_size) 132 { 133 int rv; 134 knet_cmd_ctrl_t *ctrl = &knet_cmd_ctrl; 135 136 if (knet_rx_thread_run == KNET_RX_THREAD_STOPPED) { 137 return SOC_E_UNAVAIL; 138 } 139 140 sal_mutex_take(ctrl->cmd_lock, sal_mutex_FOREVER); 141 142 if (kvect.hw_unit_get) { 143 /* convert the user unit to hw unit */ 144 kmsg->hdr.unit = kvect.hw_unit_get(kmsg->hdr.unit, 0); 145 } 146 kmsg->hdr.type = KCOM_MSG_TYPE_CMD; 147 kmsg->hdr.seqno = 0; 148 149 ctrl->opcode = kmsg->hdr.opcode; 150 151 rv = KNET_SEND(KCOM_CHAN_KNET, kmsg, len, buf_size); 152 if (rv < 0) { 153 LOG_CLI((BSL_META("soc_knet_cmd_req: command failed\n"))); 154 } else if (rv > 0) { 155 /* Synchronous response - no need to wait */ 156 } else if (sal_sem_take(ctrl->cmd_done, 2000000)) { 157 LOG_CLI((BSL_META("soc_knet_cmd_req: command timeout\n"))); 158 rv = SOC_E_TIMEOUT; 159 } else { 160 LOG_VERBOSE(BSL_LS_SOC_COMMON, 161 (BSL_META("soc_knet_cmd_req: command OK\n"))); 162 len = ctrl->resp_len; 163 if (len > buf_size) { 164 LOG_VERBOSE(BSL_LS_SOC_COMMON, 165 (BSL_META("soc_knet_cmd_req: oversized response " 166 "(%d bytes, max %d)\n"), 167 len, buf_size)); 168 len = buf_size; 169 } 170 sal_mutex_take(ctrl->msg_lock, sal_mutex_FOREVER); 171 sal_memcpy(kmsg, &ctrl->resp_msg, len); 172 sal_mutex_give(ctrl->msg_lock); 173 } 174 175 /* translate the return value for all the valid command response */ 176 if (rv >= 0) { 177 switch (kmsg->hdr.status) { 178 case KCOM_E_NONE: 179 rv = SOC_E_NONE; 180 break; 181 case KCOM_E_PARAM: 182 rv = SOC_E_PARAM; 183 break; 184 case KCOM_E_RESOURCE: 185 rv = SOC_E_RESOURCE; 186 break; 187 case KCOM_E_NOT_FOUND: 188 rv = SOC_E_NOT_FOUND; 189 break; 190 default: 191 rv = SOC_E_FAIL; 192 break; 193 } 194 } 195 196 sal_mutex_give(ctrl->cmd_lock); 197 198 return rv; 199 } 200 201 int 202 soc_knet_handle_rx(kcom_msg_t *kmsg, unsigned int len) 203 { 204 int unit; 205 int idx; 206 int rv = 0; 207 208 /* Check for valid header */ 209 if (len < sizeof(kcom_msg_hdr_t)) { 210 return SOC_E_INTERNAL; 211 } 212 213 /* Check for valid unit */ 214 unit = kmsg->hdr.unit; 215 if (!SOC_UNIT_VALID(unit)) { 216 return SOC_E_UNIT; 217 } 218 219 for (idx = 0; idx < MAX_CALLBACKS; idx++) { 220 if (_callback_ctrl[idx].cb != NULL) { 221 rv = _callback_ctrl[idx].cb(kmsg, len, _callback_ctrl[idx].cookie); 222 if (rv > 0) { 223 /* Message handled */ 224 return SOC_E_NONE; 225 } 226 } 227 } 228 if (rv == 0) { 229 LOG_CLI((BSL_META_U(unit, 230 "soc_knet_handle_rx: unhandled (type=%d, opcode=%d)\n"), 231 kmsg->hdr.type, kmsg->hdr.opcode)); 232 } 233 return SOC_E_NOT_FOUND; 234 } 235 236 void 237 soc_knet_rx_thread(void *context) 238 { 239 kcom_msg_t kmsg; 240 int len; 241 char thread_name[SAL_THREAD_NAME_MAX_LEN]; 242 sal_thread_t thread; 243 244 thread = sal_thread_self(); 245 thread_name[0] = 0; 246 sal_thread_name(thread, thread_name, sizeof (thread_name)); 247 while (knet_rx_thread_run == KNET_RX_THREAD_RUNNING) { 248 if (kvect.hw_unit_get) { 249 /* Pass the hw unit to KNET module to support multiple instance. */ 250 kmsg.hdr.unit = kvect.hw_unit_get(PTR_TO_INT(context), 0); 251 } 252 if ((len = KNET_RECV(KCOM_CHAN_KNET, &kmsg, sizeof(kmsg))) < 0) { 253 LOG_CLI((BSL_META("knet rx error - thread aborting\n"))); 254 LOG_ERROR(BSL_LS_SOC_COMMON, 255 (BSL_META("AbnormalThreadExit:%s\n"), thread_name)); 256 break; 257 } 258 259 if (kvect.hw_unit_get) { 260 /* convert the hw unit to user unit */ 261 kmsg.hdr.unit = kvect.hw_unit_get(kmsg.hdr.unit, 1); 262 } 263 soc_knet_handle_rx(&kmsg, len); 264 } 265 knet_rx_thread_run = KNET_RX_THREAD_STOPPED; 266 } 267 268 int 269 soc_knet_config(soc_knet_vectors_t *vect) 270 { 271 if (vect == NULL) { 272 return SOC_E_PARAM; 273 } 274 275 kvect = *vect; 276 277 return SOC_E_NONE; 278 } 279 280 int 281 soc_eth_knet_hw_config(int unit, int type, int chan, uint32 flags, uint32 value) 282 { 283 unsigned int len; 284 kcom_msg_eth_hw_config_t kmsg; 285 286 sal_memset(&kmsg, 0, sizeof(kmsg)); 287 kmsg.hdr.opcode = KCOM_M_ETH_HW_CONFIG; 288 kmsg.hdr.unit = unit; 289 kmsg.config.type = type; 290 kmsg.config.chan = chan; 291 kmsg.config.flags = flags; 292 kmsg.config.value = value; 293 294 len = sizeof(kmsg); 295 296 return soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 297 } 298 299 int 300 soc_knet_hw_reset(int unit, int channel) 301 { 302 unsigned int len; 303 kcom_msg_hw_reset_t kmsg; 304 305 sal_memset(&kmsg, 0, sizeof(kmsg)); 306 kmsg.hdr.opcode = KCOM_M_HW_RESET; 307 kmsg.hdr.unit = unit; 308 if (channel >= 0) { 309 kmsg.channels = (1 << channel); 310 } 311 len = sizeof(kmsg); 312 313 return soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 314 } 315 316 int 317 soc_knet_hw_init(int unit) 318 { 319 unsigned int len; 320 kcom_msg_hw_init_t kmsg; 321 #ifdef BCM_PETRA_SUPPORT 322 soc_dpp_config_t *dpp = NULL; 323 #endif 324 325 sal_memset(&kmsg, 0, sizeof(kmsg)); 326 kmsg.hdr.opcode = KCOM_M_HW_INIT; 327 kmsg.hdr.unit = unit; 328 329 #ifdef BCM_CMICX_SUPPORT 330 if (soc_feature(unit, soc_feature_cmicx)) { 331 kmsg.cmic_type = 'x'; 332 kmsg.pkt_hdr_size = soc_cmicx_pktdma_header_size_get(unit); 333 if (soc_cm_get_bus_type(unit) & SOC_PCI_DEV_TYPE) { 334 kmsg.dma_hi = CMIC_PCIE_SO_OFFSET; 335 } else { 336 kmsg.dma_hi = 0; 337 } 338 } else 339 #endif 340 if (soc_feature(unit, soc_feature_cmicm)) { 341 kmsg.cmic_type = 'm'; 342 kmsg.pkt_hdr_size = 0; 343 } else { 344 kmsg.cmic_type = 'e'; 345 kmsg.pkt_hdr_size = 0; 346 } 347 #ifdef BCM_PETRA_SUPPORT 348 /* make use of pkt_hdr_size to indicate possible Dune headers */ 349 /* 0x0 - none */ 350 /* 0x1 - FTMH LB-Key Extension */ 351 /* 0x2 - FTMH Stacking Extension */ 352 kmsg.pkt_hdr_size = 0; 353 354 dpp = SOC_DPP_CONFIG(unit); 355 if (dpp && (dpp->arad)) { 356 if (dpp->arad->init.fabric.ftmh_lb_ext_mode != ARAD_MGMT_FTMH_LB_EXT_MODE_DISABLED) { 357 kmsg.pkt_hdr_size |= 0x1; 358 } 359 if (dpp->arad->init.fabric.ftmh_stacking_ext_mode == 0x1) { 360 kmsg.pkt_hdr_size |= 0x2; 361 } 362 } 363 #endif 364 #ifdef BCM_DNX_SUPPORT 365 if (SOC_IS_DNX(unit)) 366 { 367 /** Update to 0 since there is no ep_to_cpu header */ 368 kmsg.pkt_hdr_size = 0; 369 } 370 #endif 371 372 kmsg.dcb_type = SOC_DCB_TYPE(unit); 373 kmsg.dcb_size = SOC_DCB_SIZE(unit); 374 375 if (SOC_DMA_MODE(unit) == SOC_DMA_MODE_CONTINUOUS) { 376 /* For now enable Continuous mode for all the channels */ 377 kmsg.cdma_channels = ~0; 378 } 379 len = sizeof(kmsg); 380 381 return soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 382 } 383 384 int 385 soc_knet_reprobe(int unit) 386 { 387 int rv; 388 unsigned int len; 389 kcom_msg_reprobe_t kmsg; 390 391 sal_memset(&kmsg, 0, sizeof(kmsg)); 392 kmsg.hdr.opcode = KCOM_M_REPROBE; 393 kmsg.hdr.unit = unit; 394 len = sizeof(kmsg); 395 396 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 397 398 return rv; 399 } 400 401 int 402 soc_knet_check_version(int unit) 403 { 404 int rv; 405 unsigned int len; 406 kcom_msg_version_t kmsg; 407 408 sal_memset(&kmsg, 0, sizeof(kmsg)); 409 kmsg.hdr.opcode = KCOM_M_VERSION; 410 kmsg.hdr.unit = unit; 411 kmsg.version = KCOM_VERSION; 412 len = sizeof(kmsg); 413 414 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 415 416 if (SOC_SUCCESS(rv)) { 417 if (kmsg.version != KCOM_VERSION) { 418 rv = SOC_E_INTERNAL; 419 } 420 if (kmsg.netif_max != KCOM_NETIF_MAX) { 421 rv = SOC_E_INTERNAL; 422 } 423 if (kmsg.filter_max != KCOM_FILTER_MAX) { 424 rv = SOC_E_INTERNAL; 425 } 426 } 427 428 return rv; 429 } 430 431 int 432 soc_knet_detach(void) 433 { 434 int rv; 435 unsigned int len; 436 kcom_msg_detach_t kmsg; 437 438 sal_memset(&kmsg, 0, sizeof(kmsg)); 439 kmsg.hdr.opcode = KCOM_M_DETACH; 440 kmsg.hdr.unit = -1; 441 len = sizeof(kmsg); 442 443 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 444 445 return rv; 446 } 447 448 int 449 soc_knet_debug_pkt_set(int unit, int enable) 450 { 451 int rv; 452 unsigned int len; 453 kcom_msg_dbg_pkt_set_t kmsg; 454 455 sal_memset(&kmsg, 0, sizeof(kmsg)); 456 kmsg.hdr.opcode = KCOM_M_DBGPKT_SET; 457 kmsg.hdr.unit = unit; 458 kmsg.enable = enable; 459 len = sizeof(kmsg); 460 461 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 462 463 return rv; 464 } 465 466 int 467 soc_knet_debug_pkt_get(int unit, int *value) 468 { 469 int rv; 470 unsigned int len; 471 kcom_msg_dbg_pkt_get_t kmsg; 472 473 sal_memset(&kmsg, 0, sizeof(kmsg)); 474 kmsg.hdr.opcode = KCOM_M_DBGPKT_GET; 475 kmsg.hdr.unit = unit; 476 len = sizeof(kmsg); 477 478 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 479 if (SOC_SUCCESS(rv)) { 480 *value = kmsg.value; 481 } 482 483 return rv; 484 } 485 486 int 487 soc_knet_wb_cleanup(int unit) 488 { 489 int rv; 490 unsigned int len; 491 kcom_msg_wb_cleanup_t kmsg; 492 493 sal_memset(&kmsg, 0, sizeof(kmsg)); 494 kmsg.hdr.opcode = KCOM_M_WB_CLEANUP; 495 kmsg.hdr.unit = unit; 496 len = sizeof(kmsg); 497 498 rv = soc_knet_cmd_req((kcom_msg_t *)&kmsg, len, sizeof(kmsg)); 499 500 return rv; 501 } 502 503 int 504 soc_knet_irq_mask_set(int unit, uint32 addr, uint32 mask) 505 { 506 if (kvect.irq_mask_set) { 507 return kvect.irq_mask_set(unit, addr, mask); 508 } 509 soc_pci_write(unit, addr, mask); 510 return SOC_E_NONE; 511 } 512 513 int 514 soc_knet_cleanup(void) 515 { 516 /* Do clean-up only one device left */ 517 if (soc_ndev > 1) { 518 return SOC_E_NONE; 519 } 520 521 if (knet_chan != NULL) { 522 if (knet_rx_thread_run == KNET_RX_THREAD_RUNNING) { 523 int retry = 5000; 524 knet_rx_thread_run = KNET_RX_THREAD_STOPPING; 525 (void)soc_knet_detach(); 526 while (knet_rx_thread_run != KNET_RX_THREAD_STOPPED && retry-- > 0) { 527 sal_usleep(1000); 528 } 529 if (retry <= 0) { 530 LOG_ERROR(BSL_LS_SOC_COMMON, 531 (BSL_META("KNET Rx thread will not exit.\n"))); 532 } 533 } 534 KNET_CLOSE(KCOM_CHAN_KNET); 535 } 536 soc_knet_rx_unregister(soc_knet_handle_cmd_resp); 537 if (knet_cmd_ctrl.cmd_lock != NULL) { 538 sal_mutex_destroy(knet_cmd_ctrl.cmd_lock); 539 knet_cmd_ctrl.cmd_lock = NULL; 540 } 541 if (knet_cmd_ctrl.msg_lock != NULL) { 542 sal_mutex_destroy(knet_cmd_ctrl.msg_lock); 543 knet_cmd_ctrl.msg_lock = NULL; 544 } 545 if (knet_cmd_ctrl.cmd_done != NULL) { 546 sal_sem_destroy(knet_cmd_ctrl.cmd_done); 547 knet_cmd_ctrl.cmd_done = NULL; 548 } 549 return SOC_E_NONE; 550 } 551 552 int 553 soc_knet_init(int unit) 554 { 555 int rv; 556 sal_thread_t rxthr; 557 knet_cmd_ctrl_t *ctrl = &knet_cmd_ctrl; 558 kcom_msg_string_t kmsg; 559 560 if (KNET_OPEN == NULL) { 561 /* KCOM vectors not assigned */ 562 LOG_VERBOSE(BSL_LS_SOC_COMMON, 563 (BSL_META_U(unit, 564 "soc_knet_init: No KCOM vectors\n"))); 565 return SOC_E_CONFIG; 566 } 567 568 /* Check support for KNET feature */ 569 rv = SOC_E_UNAVAIL; 570 if (SOC_IS_XGS3_SWITCH(unit)) { 571 /* XGS3-style DCBs are supported */ 572 rv = SOC_E_NONE; 573 } 574 #ifdef BCM_PETRA_SUPPORT 575 if (SOC_IS_ARAD(unit)) { 576 /* DNX devices are supported */ 577 rv = SOC_E_NONE; 578 } 579 #endif 580 #ifdef BCM_DNX_SUPPORT 581 if (SOC_IS_DNX(unit)) { 582 /* DNX devices are supported */ 583 rv = SOC_E_NONE; 584 } 585 #endif 586 if (rv != SOC_E_NONE) { 587 return rv; 588 } 589 590 if (knet_rx_thread_run != KNET_RX_THREAD_STOPPED) { 591 /* Already initialized, only need to reprobe the device */ 592 rv = soc_knet_reprobe(unit); 593 if (SOC_FAILURE(rv)) { 594 LOG_CLI((BSL_META_U(unit, 595 "knet reprobe failed\n"))); 596 return SOC_E_FAIL; 597 } 598 return SOC_E_NONE; 599 } 600 601 ctrl->cmd_lock = sal_mutex_create("KNET CMD"); 602 if (ctrl->cmd_lock == NULL) { 603 soc_knet_cleanup(); 604 return SOC_E_RESOURCE; 605 } 606 ctrl->msg_lock = sal_mutex_create("KNET MSG"); 607 if (ctrl->msg_lock == NULL) { 608 soc_knet_cleanup(); 609 return SOC_E_RESOURCE; 610 } 611 ctrl->cmd_done = sal_sem_create("KNET CMD", 1, 0); 612 if (ctrl->cmd_done == NULL) { 613 soc_knet_cleanup(); 614 return SOC_E_RESOURCE; 615 } 616 617 /* Check if kernel messaging is initialized */ 618 knet_chan = KNET_OPEN(KCOM_CHAN_KNET); 619 if (knet_chan == NULL) { 620 LOG_VERBOSE(BSL_LS_SOC_COMMON, 621 (BSL_META_U(unit, 622 "knet open failed\n"))); 623 soc_knet_cleanup(); 624 return SOC_E_FAIL; 625 } 626 627 /* Try sending string event to see if kernel module is present */ 628 sal_memset(&kmsg, 0, sizeof(kmsg)); 629 kmsg.hdr.opcode = KCOM_M_STRING; 630 kmsg.hdr.type = KCOM_MSG_TYPE_EVT; 631 sal_strcpy(kmsg.val, "soc_knet_init"); 632 rv = KNET_SEND(KCOM_CHAN_KNET, &kmsg, sizeof(kmsg), sizeof(kmsg)); 633 if (rv < 0) { 634 LOG_VERBOSE(BSL_LS_SOC_COMMON, 635 (BSL_META_U(unit, 636 "knet init failed\n"))); 637 soc_knet_cleanup(); 638 return SOC_E_FAIL; 639 } 640 641 /* Register command response handler */ 642 soc_knet_rx_register(soc_knet_handle_cmd_resp, ctrl, 0); 643 644 /* Start message handler */ 645 knet_rx_thread_run = KNET_RX_THREAD_RUNNING; 646 rxthr = sal_thread_create("SOC KNET RX", 0, 647 soc_property_get(unit, spn_SOC_KNET_RX_THREAD_PRI, 0), 648 soc_knet_rx_thread, INT_TO_PTR(unit)); 649 if (rxthr == NULL) { 650 LOG_CLI((BSL_META_U(unit, 651 "knet rx thread create failed\n"))); 652 soc_knet_cleanup(); 653 return SOC_E_FAIL; 654 } 655 656 rv = soc_knet_check_version(unit); 657 if (SOC_FAILURE(rv)) { 658 LOG_CLI((BSL_META_U(unit, 659 "knet version check failed\n"))); 660 soc_knet_cleanup(); 661 return SOC_E_FAIL; 662 } 663 664 rv = soc_knet_reprobe(unit); 665 if (SOC_FAILURE(rv)) { 666 LOG_CLI((BSL_META_U(unit, 667 "knet reprobe failed\n"))); 668 soc_knet_cleanup(); 669 return SOC_E_FAIL; 670 } 671 672 return SOC_E_NONE; 673 } 674 675 #endif /* INCLUDE_KNET */ 676 677 int _soc_knet_not_empty;