1/* 2 * Copyright (C) 2013 Realtek Semiconductor Corp. 3 * All Rights Reserved. 4 * 5 * This program is the proprietary software of Realtek Semiconductor 6 * Corporation and/or its licensors, and only be used, duplicated, 7 * modified or distributed under the authorized license from Realtek. 8 * 9 * ANY USE OF THE SOFTWARE OTHER THAN AS AUTHORIZED UNDER 10 * THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED. 11 * 12 * $Revision: 51993 $ 13 * $Date: 2014-10-08 19:44:38 +0800 (������, 08 ������ 2014) $ 14 * 15 * Purpose : RTL8367C switch high-level API for RTL8367C 16 * Feature : Port security related functions 17 * 18 */ 19 20#include <rtl8367c_asicdrv_port.h> 21 22#ifndef __KERNEL__ 23#include <string.h> 24#else 25#include <linux/string.h> 26#endif 27 28/* Function Name: 29 * rtl8367c_setAsicPortUnknownDaBehavior 30 * Description: 31 * Set UNDA behavior 32 * Input: 33 * port - port ID 34 * behavior - 0: flooding to unknwon DA portmask; 1: drop; 2:trap; 3: flooding 35 * Output: 36 * None 37 * Return: 38 * RT_ERR_OK - Success 39 * RT_ERR_SMI - SMI access error 40 * RT_ERR_NOT_ALLOWED - Invalid behavior 41 * Note: 42 * None 43 */ 44ret_t rtl8367c_setAsicPortUnknownDaBehavior(rtk_uint32 port, rtk_uint32 behavior) 45{ 46 if(port >= RTL8367C_PORTNO) 47 return RT_ERR_PORT_ID; 48 49 if(behavior >= L2_UNDA_BEHAVE_END) 50 return RT_ERR_NOT_ALLOWED; 51 52 if(port < 8) 53 return rtl8367c_setAsicRegBits(RTL8367C_REG_UNKNOWN_UNICAST_DA_PORT_BEHAVE, RTL8367C_Port0_ACTION_MASK << (port * 2), behavior); 54 else 55 return rtl8367c_setAsicRegBits(RTL8367C_REG_UNKNOWN_UNICAST_DA_PORT_BEHAVE_EXT, RTL8367C_PORT8_ACTION_MASK << ((port-8) * 2), behavior); 56} 57/* Function Name: 58 * rtl8367c_getAsicPortUnknownDaBehavior 59 * Description: 60 * Get UNDA behavior 61 * Input: 62 * port - port ID 63 * Output: 64 * pBehavior - 0: flooding to unknwon DA portmask; 1: drop; 2:trap; 3: flooding 65 * Return: 66 * RT_ERR_OK - Success 67 * RT_ERR_SMI - SMI access error 68 * Note: 69 * None 70 */ 71ret_t rtl8367c_getAsicPortUnknownDaBehavior(rtk_uint32 port, rtk_uint32 *pBehavior) 72{ 73 if(port >= RTL8367C_PORTNO) 74 return RT_ERR_PORT_ID; 75 76 if(port < 8) 77 return rtl8367c_getAsicRegBits(RTL8367C_REG_UNKNOWN_UNICAST_DA_PORT_BEHAVE, RTL8367C_Port0_ACTION_MASK << (port * 2), pBehavior); 78 else 79 return rtl8367c_getAsicRegBits(RTL8367C_REG_UNKNOWN_UNICAST_DA_PORT_BEHAVE_EXT, RTL8367C_PORT8_ACTION_MASK << ((port-8) * 2), pBehavior); 80} 81/* Function Name: 82 * rtl8367c_setAsicPortUnknownSaBehavior 83 * Description: 84 * Set UNSA behavior 85 * Input: 86 * behavior - 0: flooding; 1: drop; 2:trap 87 * Output: 88 * None 89 * Return: 90 * RT_ERR_OK - Success 91 * RT_ERR_SMI - SMI access error 92 * RT_ERR_NOT_ALLOWED - Invalid behavior 93 * Note: 94 * None 95 */ 96ret_t rtl8367c_setAsicPortUnknownSaBehavior(rtk_uint32 behavior) 97{ 98 if(behavior >= L2_BEHAVE_SA_END) 99 return RT_ERR_NOT_ALLOWED; 100 101 return rtl8367c_setAsicRegBits(RTL8367C_PORT_SECURIT_CTRL_REG, RTL8367C_UNKNOWN_SA_BEHAVE_MASK, behavior); 102} 103/* Function Name: 104 * rtl8367c_getAsicPortUnknownSaBehavior 105 * Description: 106 * Get UNSA behavior 107 * Input: 108 * pBehavior - 0: flooding; 1: drop; 2:trap 109 * Output: 110 * None 111 * Return: 112 * RT_ERR_OK - Success 113 * RT_ERR_SMI - SMI access error 114 * Note: 115 * None 116 */ 117ret_t rtl8367c_getAsicPortUnknownSaBehavior(rtk_uint32 *pBehavior) 118{ 119 return rtl8367c_getAsicRegBits(RTL8367C_PORT_SECURIT_CTRL_REG, RTL8367C_UNKNOWN_SA_BEHAVE_MASK, pBehavior); 120} 121/* Function Name: 122 * rtl8367c_setAsicPortUnmatchedSaBehavior 123 * Description: 124 * Set Unmatched SA behavior 125 * Input: 126 * behavior - 0: flooding; 1: drop; 2:trap 127 * Output: 128 * None 129 * Return: 130 * RT_ERR_OK - Success 131 * RT_ERR_SMI - SMI access error 132 * RT_ERR_NOT_ALLOWED - Invalid behavior 133 * Note: 134 * None 135 */ 136ret_t rtl8367c_setAsicPortUnmatchedSaBehavior(rtk_uint32 behavior) 137{ 138 if(behavior >= L2_BEHAVE_SA_END) 139 return RT_ERR_NOT_ALLOWED; 140 141 return rtl8367c_setAsicRegBits(RTL8367C_PORT_SECURIT_CTRL_REG, RTL8367C_UNMATCHED_SA_BEHAVE_MASK, behavior); 142} 143/* Function Name: 144 * rtl8367c_getAsicPortUnmatchedSaBehavior 145 * Description: 146 * Get Unmatched SA behavior 147 * Input: 148 * pBehavior - 0: flooding; 1: drop; 2:trap 149 * Output: 150 * None 151 * Return: 152 * RT_ERR_OK - Success 153 * RT_ERR_SMI - SMI access error 154 * Note: 155 * None 156 */ 157ret_t rtl8367c_getAsicPortUnmatchedSaBehavior(rtk_uint32 *pBehavior) 158{ 159 return rtl8367c_getAsicRegBits(RTL8367C_PORT_SECURIT_CTRL_REG, RTL8367C_UNMATCHED_SA_BEHAVE_MASK, pBehavior); 160} 161 162/* Function Name: 163 * rtl8367c_setAsicPortUnmatchedSaMoving 164 * Description: 165 * Set Unmatched SA moving state 166 * Input: 167 * port - Port ID 168 * enabled - 0: can't move to new port; 1: can move to new port 169 * Output: 170 * None 171 * Return: 172 * RT_ERR_OK - Success 173 * RT_ERR_SMI - SMI access error 174 * RT_ERR_PORT_ID - Error Port ID 175 * Note: 176 * None 177 */ 178ret_t rtl8367c_setAsicPortUnmatchedSaMoving(rtk_uint32 port, rtk_uint32 enabled) 179{ 180 if(port >= RTL8367C_PORTNO) 181 return RT_ERR_PORT_ID; 182 183 return rtl8367c_setAsicRegBit(RTL8367C_REG_L2_SA_MOVING_FORBID, port, (enabled == 1) ? 0 : 1); 184} 185 186/* Function Name: 187 * rtl8367c_getAsicPortUnmatchedSaMoving 188 * Description: 189 * Get Unmatched SA moving state 190 * Input: 191 * port - Port ID 192 * Output: 193 * pEnabled - 0: can't move to new port; 1: can move to new port 194 * Return: 195 * RT_ERR_OK - Success 196 * RT_ERR_SMI - SMI access error 197 * RT_ERR_PORT_ID - Error Port ID 198 * Note: 199 * None 200 */ 201ret_t rtl8367c_getAsicPortUnmatchedSaMoving(rtk_uint32 port, rtk_uint32 *pEnabled) 202{ 203 rtk_uint32 data; 204 ret_t retVal; 205 206 if(port >= RTL8367C_PORTNO) 207 return RT_ERR_PORT_ID; 208 209 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_L2_SA_MOVING_FORBID, port, &data)) != RT_ERR_OK) 210 return retVal; 211 212 *pEnabled = (data == 1) ? 0 : 1; 213 return RT_ERR_OK; 214} 215 216/* Function Name: 217 * rtl8367c_setAsicPortUnknownDaFloodingPortmask 218 * Description: 219 * Set UNDA flooding portmask 220 * Input: 221 * portmask - portmask(0~0xFF) 222 * Output: 223 * None 224 * Return: 225 * RT_ERR_OK - Success 226 * RT_ERR_SMI - SMI access error 227 * RT_ERR_PORT_MASK - Invalid portmask 228 * Note: 229 * None 230 */ 231ret_t rtl8367c_setAsicPortUnknownDaFloodingPortmask(rtk_uint32 portmask) 232{ 233 if(portmask > RTL8367C_PORTMASK) 234 return RT_ERR_PORT_MASK; 235 236 return rtl8367c_setAsicReg(RTL8367C_UNUCAST_FLOADING_PMSK_REG, portmask); 237} 238/* Function Name: 239 * rtl8367c_getAsicPortUnknownDaFloodingPortmask 240 * Description: 241 * Get UNDA flooding portmask 242 * Input: 243 * pPortmask - portmask(0~0xFF) 244 * Output: 245 * None 246 * Return: 247 * RT_ERR_OK - Success 248 * RT_ERR_SMI - SMI access error 249 * Note: 250 * None 251 */ 252ret_t rtl8367c_getAsicPortUnknownDaFloodingPortmask(rtk_uint32 *pPortmask) 253{ 254 return rtl8367c_getAsicReg(RTL8367C_UNUCAST_FLOADING_PMSK_REG, pPortmask); 255} 256/* Function Name: 257 * rtl8367c_setAsicPortUnknownMulticastFloodingPortmask 258 * Description: 259 * Set UNMC flooding portmask 260 * Input: 261 * portmask - portmask(0~0xFF) 262 * Output: 263 * None 264 * Return: 265 * RT_ERR_OK - Success 266 * RT_ERR_SMI - SMI access error 267 * RT_ERR_PORT_MASK - Invalid portmask 268 * Note: 269 * None 270 */ 271ret_t rtl8367c_setAsicPortUnknownMulticastFloodingPortmask(rtk_uint32 portmask) 272{ 273 if(portmask > RTL8367C_PORTMASK) 274 return RT_ERR_PORT_MASK; 275 276 return rtl8367c_setAsicReg(RTL8367C_UNMCAST_FLOADING_PMSK_REG, portmask); 277} 278/* Function Name: 279 * rtl8367c_getAsicPortUnknownMulticastFloodingPortmask 280 * Description: 281 * Get UNMC flooding portmask 282 * Input: 283 * pPortmask - portmask(0~0xFF) 284 * Output: 285 * None 286 * Return: 287 * RT_ERR_OK - Success 288 * RT_ERR_SMI - SMI access error 289 * Note: 290 * None 291 */ 292ret_t rtl8367c_getAsicPortUnknownMulticastFloodingPortmask(rtk_uint32 *pPortmask) 293{ 294 return rtl8367c_getAsicReg(RTL8367C_UNMCAST_FLOADING_PMSK_REG, pPortmask); 295} 296/* Function Name: 297 * rtl8367c_setAsicPortBcastFloodingPortmask 298 * Description: 299 * Set Bcast flooding portmask 300 * Input: 301 * portmask - portmask(0~0xFF) 302 * Output: 303 * None 304 * Return: 305 * RT_ERR_OK - Success 306 * RT_ERR_SMI - SMI access error 307 * RT_ERR_PORT_MASK - Invalid portmask 308 * Note: 309 * None 310 */ 311ret_t rtl8367c_setAsicPortBcastFloodingPortmask(rtk_uint32 portmask) 312{ 313 if(portmask > RTL8367C_PORTMASK) 314 return RT_ERR_PORT_MASK; 315 316 return rtl8367c_setAsicReg(RTL8367C_BCAST_FLOADING_PMSK_REG, portmask); 317} 318/* Function Name: 319 * rtl8367c_getAsicPortBcastFloodingPortmask 320 * Description: 321 * Get Bcast flooding portmask 322 * Input: 323 * pPortmask - portmask(0~0xFF) 324 * Output: 325 * None 326 * Return: 327 * RT_ERR_OK - Success 328 * RT_ERR_SMI - SMI access error 329 * Note: 330 * None 331 */ 332ret_t rtl8367c_getAsicPortBcastFloodingPortmask(rtk_uint32 *pPortmask) 333{ 334 return rtl8367c_getAsicReg(RTL8367C_BCAST_FLOADING_PMSK_REG, pPortmask); 335} 336/* Function Name: 337 * rtl8367c_setAsicPortBlockSpa 338 * Description: 339 * Set disabling blocking frame if source port and destination port are the same 340 * Input: 341 * port - Physical port number (0~7) 342 * permit - 0: block; 1: permit 343 * Output: 344 * None 345 * Return: 346 * RT_ERR_OK - Success 347 * RT_ERR_SMI - SMI access error 348 * RT_ERR_PORT_ID - Invalid port number 349 * Note: 350 * None 351 */ 352ret_t rtl8367c_setAsicPortBlockSpa(rtk_uint32 port, rtk_uint32 permit) 353{ 354 if(port >= RTL8367C_PORTNO) 355 return RT_ERR_PORT_ID; 356 357 return rtl8367c_setAsicRegBit(RTL8367C_SOURCE_PORT_BLOCK_REG, port, permit); 358} 359/* Function Name: 360 * rtl8367c_getAsicPortBlockSpa 361 * Description: 362 * Get disabling blocking frame if source port and destination port are the same 363 * Input: 364 * port - Physical port number (0~7) 365 * pPermit - 0: block; 1: permit 366 * Output: 367 * None 368 * Return: 369 * RT_ERR_OK - Success 370 * RT_ERR_SMI - SMI access error 371 * RT_ERR_PORT_ID - Invalid port number 372 * Note: 373 * None 374 */ 375ret_t rtl8367c_getAsicPortBlockSpa(rtk_uint32 port, rtk_uint32* pPermit) 376{ 377 if(port >= RTL8367C_PORTNO) 378 return RT_ERR_PORT_ID; 379 380 return rtl8367c_getAsicRegBit(RTL8367C_SOURCE_PORT_BLOCK_REG, port, pPermit); 381} 382/* Function Name: 383 * rtl8367c_setAsicPortDos 384 * Description: 385 * Set DOS function 386 * Input: 387 * type - DOS type 388 * drop - 0: permit; 1: drop 389 * Output: 390 * None 391 * Return: 392 * RT_ERR_OK - Success 393 * RT_ERR_SMI - SMI access error 394 * RT_ERR_OUT_OF_RANGE - Invalid payload index 395 * Note: 396 * None 397 */ 398ret_t rtl8367c_setAsicPortDos(rtk_uint32 type, rtk_uint32 drop) 399{ 400 if(type >= DOS_END) 401 return RT_ERR_OUT_OF_RANGE; 402 403 return rtl8367c_setAsicRegBit(RTL8367C_REG_DOS_CFG, RTL8367C_DROP_DAEQSA_OFFSET + type, drop); 404} 405/* Function Name: 406 * rtl8367c_getAsicPortDos 407 * Description: 408 * Get DOS function 409 * Input: 410 * type - DOS type 411 * pDrop - 0: permit; 1: drop 412 * Output: 413 * None 414 * Return: 415 * RT_ERR_OK - Success 416 * RT_ERR_SMI - SMI access error 417 * RT_ERR_OUT_OF_RANGE - Invalid payload index 418 * Note: 419 * None 420 */ 421ret_t rtl8367c_getAsicPortDos(rtk_uint32 type, rtk_uint32* pDrop) 422{ 423 if(type >= DOS_END) 424 return RT_ERR_OUT_OF_RANGE; 425 426 return rtl8367c_getAsicRegBit(RTL8367C_REG_DOS_CFG, RTL8367C_DROP_DAEQSA_OFFSET + type,pDrop); 427} 428/* Function Name: 429 * rtl8367c_setAsicPortForceLink 430 * Description: 431 * Set port force linking configuration 432 * Input: 433 * port - Physical port number (0~7) 434 * pPortAbility - port ability configuration 435 * Output: 436 * None 437 * Return: 438 * RT_ERR_OK - Success 439 * RT_ERR_SMI - SMI access error 440 * RT_ERR_PORT_ID - Invalid port number 441 * Note: 442 * None 443 */ 444ret_t rtl8367c_setAsicPortForceLink(rtk_uint32 port, rtl8367c_port_ability_t *pPortAbility) 445{ 446 rtk_uint32 regData; 447 rtk_uint16 *accessPtr; 448 rtl8367c_port_ability_t ability; 449 450 /* Invalid input parameter */ 451 if(port >= RTL8367C_PORTNO) 452 return RT_ERR_PORT_ID; 453 454 memset(&ability, 0x00, sizeof(rtl8367c_port_ability_t)); 455 memcpy(&ability, pPortAbility, sizeof(rtl8367c_port_ability_t)); 456 457 accessPtr = (rtk_uint16*)&ability; 458 459 regData = *accessPtr; 460 return rtl8367c_setAsicReg(RTL8367C_REG_MAC0_FORCE_SELECT+port, regData); 461} 462/* Function Name: 463 * rtl8367c_getAsicPortForceLink 464 * Description: 465 * Get port force linking configuration 466 * Input: 467 * port - Physical port number (0~7) 468 * pPortAbility - port ability configuration 469 * Output: 470 * None 471 * Return: 472 * RT_ERR_OK - Success 473 * RT_ERR_SMI - SMI access error 474 * RT_ERR_PORT_ID - Invalid port number 475 * Note: 476 * None 477 */ 478ret_t rtl8367c_getAsicPortForceLink(rtk_uint32 port, rtl8367c_port_ability_t *pPortAbility) 479{ 480 ret_t retVal; 481 rtk_uint32 regData; 482 rtk_uint16 *accessPtr; 483 rtl8367c_port_ability_t ability; 484 485 /* Invalid input parameter */ 486 if(port >= RTL8367C_PORTNO) 487 return RT_ERR_PORT_ID; 488 489 memset(&ability, 0x00, sizeof(rtl8367c_port_ability_t)); 490 491 492 accessPtr = (rtk_uint16*)&ability; 493 494 retVal = rtl8367c_getAsicReg(RTL8367C_REG_MAC0_FORCE_SELECT + port, ®Data); 495 if(retVal != RT_ERR_OK) 496 return retVal; 497 498 *accessPtr = regData; 499 500 memcpy(pPortAbility, &ability, sizeof(rtl8367c_port_ability_t)); 501 502 return RT_ERR_OK; 503} 504/* Function Name: 505 * rtl8367c_getAsicPortStatus 506 * Description: 507 * Get port link status 508 * Input: 509 * port - Physical port number (0~7) 510 * pPortAbility - port ability configuration 511 * Output: 512 * None 513 * Return: 514 * RT_ERR_OK - Success 515 * RT_ERR_SMI - SMI access error 516 * RT_ERR_PORT_ID - Invalid port number 517 * Note: 518 * None 519 */ 520ret_t rtl8367c_getAsicPortStatus(rtk_uint32 port, rtl8367c_port_status_t *pPortStatus) 521{ 522 ret_t retVal; 523 rtk_uint32 regData; 524 rtk_uint16 *accessPtr; 525 rtl8367c_port_status_t status; 526 527 /* Invalid input parameter */ 528 if(port >= RTL8367C_PORTNO) 529 return RT_ERR_PORT_ID; 530 531 memset(&status, 0x00, sizeof(rtl8367c_port_status_t)); 532 533 534 accessPtr = (rtk_uint16*)&status; 535 536 retVal = rtl8367c_getAsicReg(RTL8367C_REG_PORT0_STATUS+port,®Data); 537 if(retVal != RT_ERR_OK) 538 return retVal; 539 540 *accessPtr = regData; 541 542 memcpy(pPortStatus, &status, sizeof(rtl8367c_port_status_t)); 543 544 return RT_ERR_OK; 545} 546/* Function Name: 547 * rtl8367c_setAsicPortForceLinkExt 548 * Description: 549 * Set external interface force linking configuration 550 * Input: 551 * id - external interface id (0~2) 552 * portAbility - port ability configuration 553 * Output: 554 * None 555 * Return: 556 * RT_ERR_OK - Success 557 * RT_ERR_SMI - SMI access error 558 * RT_ERR_OUT_OF_RANGE - input parameter out of range 559 * Note: 560 * None 561 */ 562ret_t rtl8367c_setAsicPortForceLinkExt(rtk_uint32 id, rtl8367c_port_ability_t *pPortAbility) 563{ 564 rtk_uint32 retVal; 565 rtk_uint32 reg_data; 566 567 /* Invalid input parameter */ 568 if(id >= RTL8367C_EXTNO) 569 return RT_ERR_OUT_OF_RANGE; 570 571 reg_data = (rtk_uint32)(*(rtk_uint16 *)pPortAbility); 572 573 if(1 == id) 574 { 575 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_FDUP_OFFSET, pPortAbility->duplex)) != RT_ERR_OK) 576 return retVal; 577 578 if((retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_SPD_MASK, pPortAbility->speed)) != RT_ERR_OK) 579 return retVal; 580 581 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_LINK_OFFSET, pPortAbility->link)) != RT_ERR_OK) 582 return retVal; 583 584 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_TXFC_OFFSET, pPortAbility->txpause)) != RT_ERR_OK) 585 return retVal; 586 587 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_RXFC_OFFSET, pPortAbility->rxpause)) != RT_ERR_OK) 588 return retVal; 589 } 590 591 if(0 == id || 1 == id) 592 return rtl8367c_setAsicReg(RTL8367C_REG_DIGITAL_INTERFACE0_FORCE + id, reg_data); 593 else 594 return rtl8367c_setAsicReg(RTL8367C_REG_DIGITAL_INTERFACE2_FORCE, reg_data); 595} 596/* Function Name: 597 * rtl8367c_getAsicPortForceLinkExt 598 * Description: 599 * Get external interface force linking configuration 600 * Input: 601 * id - external interface id (0~1) 602 * pPortAbility - port ability configuration 603 * Output: 604 * None 605 * Return: 606 * RT_ERR_OK - Success 607 * RT_ERR_SMI - SMI access error 608 * RT_ERR_OUT_OF_RANGE - input parameter out of range 609 * Note: 610 * None 611 */ 612ret_t rtl8367c_getAsicPortForceLinkExt(rtk_uint32 id, rtl8367c_port_ability_t *pPortAbility) 613{ 614 rtk_uint32 reg_data; 615 rtk_uint32 sgmiiSel; 616 rtk_uint32 hsgmiiSel; 617 rtk_uint16 ability_data; 618 ret_t retVal; 619 620 /* Invalid input parameter */ 621 if(id >= RTL8367C_EXTNO) 622 return RT_ERR_OUT_OF_RANGE; 623 624 if(1 == id) 625 { 626 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_SGMII_OFFSET, &sgmiiSel)) != RT_ERR_OK) 627 return retVal; 628 629 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_HSGMII_OFFSET, &hsgmiiSel)) != RT_ERR_OK) 630 return retVal; 631 632 if( (sgmiiSel == 1) || (hsgmiiSel == 1) ) 633 { 634 memset(pPortAbility, 0x00, sizeof(rtl8367c_port_ability_t)); 635 pPortAbility->forcemode = 1; 636 637 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_FDUP_OFFSET, ®_data)) != RT_ERR_OK) 638 return retVal; 639 640 pPortAbility->duplex = reg_data; 641 642 if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_SPD_MASK, ®_data)) != RT_ERR_OK) 643 return retVal; 644 645 pPortAbility->speed = reg_data; 646 647 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_LINK_OFFSET, ®_data)) != RT_ERR_OK) 648 return retVal; 649 650 pPortAbility->link = reg_data; 651 652 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_TXFC_OFFSET, ®_data)) != RT_ERR_OK) 653 return retVal; 654 655 pPortAbility->txpause = reg_data; 656 657 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_SGMII_RXFC_OFFSET, ®_data)) != RT_ERR_OK) 658 return retVal; 659 660 pPortAbility->rxpause = reg_data; 661 662 return RT_ERR_OK; 663 } 664 } 665 666 if(0 == id || 1 == id) 667 retVal = rtl8367c_getAsicReg(RTL8367C_REG_DIGITAL_INTERFACE0_FORCE+id, ®_data); 668 else 669 retVal = rtl8367c_getAsicReg(RTL8367C_REG_DIGITAL_INTERFACE2_FORCE, ®_data); 670 671 if(retVal != RT_ERR_OK) 672 return retVal; 673 674 ability_data = (rtk_uint16)reg_data; 675 memcpy(pPortAbility, &ability_data, sizeof(rtl8367c_port_ability_t)); 676 677 return RT_ERR_OK; 678} 679/* Function Name: 680 * rtl8367c_setAsicPortExtMode 681 * Description: 682 * Set external interface mode configuration 683 * Input: 684 * id - external interface id (0~2) 685 * mode - external interface mode 686 * Output: 687 * None 688 * Return: 689 * RT_ERR_OK - Success 690 * RT_ERR_SMI - SMI access error 691 * RT_ERR_OUT_OF_RANGE - input parameter out of range 692 * Note: 693 * None 694 */ 695ret_t rtl8367c_setAsicPortExtMode(rtk_uint32 id, rtk_uint32 mode) 696{ 697 ret_t retVal; 698 699 if(id >= RTL8367C_EXTNO) 700 return RT_ERR_OUT_OF_RANGE; 701 702 if(mode >= EXT_END) 703 return RT_ERR_OUT_OF_RANGE; 704 705 if( (mode == EXT_SGMII) || (mode == EXT_HSGMII) ) 706 { 707 if(id != 1) 708 return RT_ERR_PORT_ID; 709 } 710 711 if(mode == EXT_GMII) 712 { 713 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_EXT0_RGMXF, RTL8367C_EXT0_RGTX_INV_OFFSET, 1)) != RT_ERR_OK) 714 return retVal; 715 716 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_EXT1_RGMXF, RTL8367C_EXT1_RGTX_INV_OFFSET, 1)) != RT_ERR_OK) 717 return retVal; 718 719 if( (retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_EXT_TXC_DLY, RTL8367C_EXT1_GMII_TX_DELAY_MASK, 5)) != RT_ERR_OK) 720 return retVal; 721 722 if( (retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_EXT_TXC_DLY, RTL8367C_EXT0_GMII_TX_DELAY_MASK, 6)) != RT_ERR_OK) 723 return retVal; 724 } 725 726 /* Serdes reset */ 727 if( (mode == EXT_TMII_MAC) || (mode == EXT_TMII_PHY) ) 728 { 729 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_BYPASS_LINE_RATE, id, 1)) != RT_ERR_OK) 730 return retVal; 731 } 732 else 733 { 734 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_BYPASS_LINE_RATE, id, 0)) != RT_ERR_OK) 735 return retVal; 736 } 737 738 if( (mode == EXT_SGMII) || (mode == EXT_HSGMII) ) 739 { 740 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_DATA, 0x0F80)) != RT_ERR_OK) 741 return retVal; 742 743 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_ADR, 0x0001)) != RT_ERR_OK) 744 return retVal; 745 746 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_CMD, 0x00C0)) != RT_ERR_OK) 747 return retVal; 748 } 749 750 if(mode == EXT_SGMII) 751 { 752 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_SGMII_OFFSET, 1)) != RT_ERR_OK) 753 return retVal; 754 755 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_HSGMII_OFFSET, 0)) != RT_ERR_OK) 756 return retVal; 757 } 758 else if(mode == EXT_HSGMII) 759 { 760 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_SGMII_OFFSET, 0)) != RT_ERR_OK) 761 return retVal; 762 763 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_HSGMII_OFFSET, 1)) != RT_ERR_OK) 764 return retVal; 765 } 766 else 767 { 768 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_SGMII_OFFSET, 0)) != RT_ERR_OK) 769 return retVal; 770 771 if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_HSGMII_OFFSET, 0)) != RT_ERR_OK) 772 return retVal; 773 774 if(0 == id || 1 == id) 775 { 776 if((retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_DIGITAL_INTERFACE_SELECT, RTL8367C_SELECT_GMII_0_MASK << (id * RTL8367C_SELECT_GMII_1_OFFSET), mode)) != RT_ERR_OK) 777 return retVal; 778 } 779 else 780 { 781 if((retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_DIGITAL_INTERFACE_SELECT_1, RTL8367C_SELECT_GMII_2_MASK, mode)) != RT_ERR_OK) 782 return retVal; 783 } 784 } 785 786 /* Serdes not reset */ 787 if( (mode == EXT_SGMII) || (mode == EXT_HSGMII) ) 788 { 789 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_DATA, 0x7106)) != RT_ERR_OK) 790 return retVal; 791 792 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_ADR, 0x0003)) != RT_ERR_OK) 793 return retVal; 794 795 if( (retVal = rtl8367c_setAsicReg(RTL8367C_REG_SDS_INDACS_CMD, 0x00C0)) != RT_ERR_OK) 796 return retVal; 797 } 798 799 return RT_ERR_OK; 800} 801/* Function Name: 802 * rtl8367c_getAsicPortExtMode 803 * Description: 804 * Get external interface mode configuration 805 * Input: 806 * id - external interface id (0~1) 807 * pMode - external interface mode 808 * Output: 809 * None 810 * Return: 811 * RT_ERR_OK - Success 812 * RT_ERR_SMI - SMI access error 813 * RT_ERR_OUT_OF_RANGE - input parameter out of range 814 * Note: 815 * None 816 */ 817ret_t rtl8367c_getAsicPortExtMode(rtk_uint32 id, rtk_uint32 *pMode) 818{ 819 ret_t retVal; 820 rtk_uint32 regData; 821 822 if(id >= RTL8367C_EXTNO) 823 return RT_ERR_OUT_OF_RANGE; 824 825 if (1 == id) 826 { 827 if( (retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_SGMII_OFFSET, ®Data)) != RT_ERR_OK) 828 return retVal; 829 830 if(1 == regData) 831 { 832 *pMode = EXT_SGMII; 833 return RT_ERR_OK; 834 } 835 836 if( (retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SDS_MISC, RTL8367C_CFG_MAC8_SEL_HSGMII_OFFSET, ®Data)) != RT_ERR_OK) 837 return retVal; 838 839 if(1 == regData) 840 { 841 *pMode = EXT_HSGMII; 842 return RT_ERR_OK; 843 } 844 } 845 846 if(0 == id || 1 == id) 847 return rtl8367c_getAsicRegBits(RTL8367C_REG_DIGITAL_INTERFACE_SELECT, RTL8367C_SELECT_GMII_0_MASK << (id * RTL8367C_SELECT_GMII_1_OFFSET), pMode); 848 else 849 return rtl8367c_getAsicRegBits(RTL8367C_REG_DIGITAL_INTERFACE_SELECT_1, RTL8367C_SELECT_GMII_2_MASK, pMode); 850} 851 852/* Function Name: 853 * rtl8370_setAsicPortEnableAll 854 * Description: 855 * Set ALL ports enable. 856 * Input: 857 * enable - enable all ports. 858 * Output: 859 * None 860 * Return: 861 * RT_ERR_OK - Success 862 * RT_ERR_SMI - SMI access error 863 * Note: 864 * None 865 */ 866ret_t rtl8367c_setAsicPortEnableAll(rtk_uint32 enable) 867{ 868 if(enable >= 2) 869 return RT_ERR_INPUT; 870 871 return rtl8367c_setAsicRegBit(RTL8367C_REG_PHY_AD, RTL8367C_PDNPHY_OFFSET, !enable); 872} 873 874/* Function Name: 875 * rtl8367c_getAsicPortEnableAll 876 * Description: 877 * Set ALL ports enable. 878 * Input: 879 * enable - enable all ports. 880 * Output: 881 * None 882 * Return: 883 * RT_ERR_OK - Success 884 * RT_ERR_SMI - SMI access error 885 * Note: 886 * None 887 */ 888ret_t rtl8367c_getAsicPortEnableAll(rtk_uint32 *pEnable) 889{ 890 ret_t retVal; 891 rtk_uint32 regData; 892 893 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_PHY_AD, RTL8367C_PDNPHY_OFFSET, ®Data); 894 if(retVal != RT_ERR_OK) 895 return retVal; 896 897 if (regData==0) 898 *pEnable = 1; 899 else 900 *pEnable = 0; 901 902 return RT_ERR_OK; 903} 904/* Function Name: 905 * rtl8367c_setAsicPortSmallIpg 906 * Description: 907 * Set small ipg egress mode 908 * Input: 909 * port - Physical port number (0~7) 910 * enable - 0: normal, 1: small 911 * Output: 912 * None 913 * Return: 914 * RT_ERR_OK - Success 915 * RT_ERR_SMI - SMI access error 916 * RT_ERR_PORT_ID - Invalid port number 917 * Note: 918 * None 919 */ 920ret_t rtl8367c_setAsicPortSmallIpg(rtk_uint32 port, rtk_uint32 enable) 921{ 922 if(port >= RTL8367C_PORTNO) 923 return RT_ERR_PORT_ID; 924 925 return rtl8367c_setAsicRegBit(RTL8367C_PORT_SMALL_IPG_REG(port), RTL8367C_PORT0_MISC_CFG_SMALL_TAG_IPG_OFFSET, enable); 926} 927 928/* Function Name: 929 * rtl8367c_getAsicPortSmallIpg 930 * Description: 931 * Get small ipg egress mode 932 * Input: 933 * port - Physical port number (0~7) 934 * pEnable - 0: normal, 1: small 935 * Output: 936 * None 937 * Return: 938 * RT_ERR_OK - Success 939 * RT_ERR_SMI - SMI access error 940 * RT_ERR_PORT_ID - Invalid port number 941 * Note: 942 * None 943 */ 944ret_t rtl8367c_getAsicPortSmallIpg(rtk_uint32 port, rtk_uint32* pEnable) 945{ 946 if(port >= RTL8367C_PORTNO) 947 return RT_ERR_PORT_ID; 948 949 return rtl8367c_getAsicRegBit(RTL8367C_PORT_SMALL_IPG_REG(port), RTL8367C_PORT0_MISC_CFG_SMALL_TAG_IPG_OFFSET, pEnable); 950} 951 952/* Function Name: 953 * rtl8367c_setAsicPortLoopback 954 * Description: 955 * Set MAC loopback 956 * Input: 957 * port - Physical port number (0~7) 958 * enable - 0: Disable, 1: enable 959 * Output: 960 * None 961 * Return: 962 * RT_ERR_OK - Success 963 * RT_ERR_SMI - SMI access error 964 * RT_ERR_PORT_ID - Invalid port number 965 * Note: 966 * None 967 */ 968ret_t rtl8367c_setAsicPortLoopback(rtk_uint32 port, rtk_uint32 enable) 969{ 970 if(port >= RTL8367C_PORTNO) 971 return RT_ERR_PORT_ID; 972 973 return rtl8367c_setAsicRegBit(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_PORT0_MISC_CFG_MAC_LOOPBACK_OFFSET, enable); 974} 975 976/* Function Name: 977 * rtl8367c_getAsicPortLoopback 978 * Description: 979 * Set MAC loopback 980 * Input: 981 * port - Physical port number (0~7) 982 * Output: 983 * pEnable - 0: Disable, 1: enable 984 * Return: 985 * RT_ERR_OK - Success 986 * RT_ERR_SMI - SMI access error 987 * RT_ERR_PORT_ID - Invalid port number 988 * Note: 989 * None 990 */ 991ret_t rtl8367c_getAsicPortLoopback(rtk_uint32 port, rtk_uint32 *pEnable) 992{ 993 if(port >= RTL8367C_PORTNO) 994 return RT_ERR_PORT_ID; 995 996 return rtl8367c_getAsicRegBit(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_PORT0_MISC_CFG_MAC_LOOPBACK_OFFSET, pEnable); 997} 998 999/* Function Name: 1000 * rtl8367c_setAsicPortRTCT 1001 * Description: 1002 * Set RTCT 1003 * Input: 1004 * portmask - Port mask of RTCT enabled (0-4) 1005 * Output: 1006 * None. 1007 * Return: 1008 * RT_ERR_OK - Success 1009 * RT_ERR_SMI - SMI access error 1010 * RT_ERR_PORT_MASK - Invalid port mask 1011 * Note: 1012 * RTCT test takes 4.8 seconds at most. 1013 */ 1014ret_t rtl8367c_setAsicPortRTCT(rtk_uint32 portmask) 1015{ 1016 ret_t retVal; 1017 rtk_uint32 regData; 1018 rtk_uint32 port; 1019 1020 if((retVal = rtl8367c_setAsicReg(0x13C2, 0x0249)) != RT_ERR_OK) 1021 return retVal; 1022 1023 if((retVal = rtl8367c_getAsicReg(0x1300, ®Data)) != RT_ERR_OK) 1024 return retVal; 1025 1026 if( (regData == 0x0276) || (regData == 0x0597) ) 1027 return RT_ERR_CHIP_NOT_SUPPORTED; 1028 1029 for(port = 0; port <= 10 ; port++) 1030 { 1031 if(portmask & (0x0001 << port)) 1032 { 1033 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa422, ®Data)) != RT_ERR_OK) 1034 return retVal; 1035 1036 regData &= 0x7FFF; 1037 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa422, regData)) != RT_ERR_OK) 1038 return retVal; 1039 1040 regData |= 0x00F0; 1041 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa422, regData)) != RT_ERR_OK) 1042 return retVal; 1043 1044 regData |= 0x0001; 1045 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa422, regData)) != RT_ERR_OK) 1046 return retVal; 1047 } 1048 } 1049 1050 return RT_ERR_OK; 1051} 1052 1053/* Function Name: 1054 * rtl8367c_getAsicPortRTCTResult 1055 * Description: 1056 * Get RTCT result 1057 * Input: 1058 * port - Port ID of RTCT result 1059 * Output: 1060 * pResult - The result of port ID 1061 * Return: 1062 * RT_ERR_OK - Success 1063 * RT_ERR_SMI - SMI access error 1064 * RT_ERR_PORT_MASK - Invalid port mask 1065 * RT_ERR_PHY_RTCT_NOT_FINISH - RTCT test doesn't finish. 1066 * Note: 1067 * RTCT test takes 4.8 seconds at most. 1068 * If this API returns RT_ERR_PHY_RTCT_NOT_FINISH, 1069 * users should wait a whole then read it again. 1070 */ 1071ret_t rtl8367c_getAsicPortRTCTResult(rtk_uint32 port, rtl8367c_port_rtct_result_t *pResult) 1072{ 1073 ret_t retVal; 1074 rtk_uint32 regData, finish = 1; 1075 1076 if((retVal = rtl8367c_setAsicReg(0x13C2, 0x0249)) != RT_ERR_OK) 1077 return retVal; 1078 1079 if((retVal = rtl8367c_getAsicReg(0x1300, ®Data)) != RT_ERR_OK) 1080 return retVal; 1081 1082 if( (regData == 0x6367) ) 1083 { 1084 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa422, ®Data)) != RT_ERR_OK) 1085 return retVal; 1086 1087 if((regData & 0x8000) == 0x8000) 1088 { 1089 /* Channel A */ 1090 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x802a)) != RT_ERR_OK) 1091 return retVal; 1092 1093 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1094 return retVal; 1095 1096 pResult->channelAOpen = (regData == 0x0048) ? 1 : 0; 1097 pResult->channelAShort = (regData == 0x0050) ? 1 : 0; 1098 pResult->channelAMismatch = ((regData == 0x0042) || (regData == 0x0044)) ? 1 : 0; 1099 pResult->channelALinedriver = (regData == 0x0041) ? 1 : 0; 1100 1101 /* Channel B */ 1102 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x802e)) != RT_ERR_OK) 1103 return retVal; 1104 1105 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1106 return retVal; 1107 1108 pResult->channelBOpen = (regData == 0x0048) ? 1 : 0; 1109 pResult->channelBShort = (regData == 0x0050) ? 1 : 0; 1110 pResult->channelBMismatch = ((regData == 0x0042) || (regData == 0x0044)) ? 1 : 0; 1111 pResult->channelBLinedriver = (regData == 0x0041) ? 1 : 0; 1112 1113 /* Channel C */ 1114 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x8032)) != RT_ERR_OK) 1115 return retVal; 1116 1117 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1118 return retVal; 1119 1120 pResult->channelCOpen = (regData == 0x0048) ? 1 : 0; 1121 pResult->channelCShort = (regData == 0x0050) ? 1 : 0; 1122 pResult->channelCMismatch = ((regData == 0x0042) || (regData == 0x0044)) ? 1 : 0; 1123 pResult->channelCLinedriver = (regData == 0x0041) ? 1 : 0; 1124 1125 /* Channel D */ 1126 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x8036)) != RT_ERR_OK) 1127 return retVal; 1128 1129 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1130 return retVal; 1131 1132 pResult->channelDOpen = (regData == 0x0048) ? 1 : 0; 1133 pResult->channelDShort = (regData == 0x0050) ? 1 : 0; 1134 pResult->channelDMismatch = ((regData == 0x0042) || (regData == 0x0044)) ? 1 : 0; 1135 pResult->channelDLinedriver = (regData == 0x0041) ? 1 : 0; 1136 1137 /* Channel A Length */ 1138 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x802c)) != RT_ERR_OK) 1139 return retVal; 1140 1141 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1142 return retVal; 1143 1144 pResult->channelALen = (regData / 2); 1145 1146 /* Channel B Length */ 1147 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x8030)) != RT_ERR_OK) 1148 return retVal; 1149 1150 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1151 return retVal; 1152 1153 pResult->channelBLen = (regData / 2); 1154 1155 /* Channel C Length */ 1156 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x8034)) != RT_ERR_OK) 1157 return retVal; 1158 1159 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1160 return retVal; 1161 1162 pResult->channelCLen = (regData / 2); 1163 1164 /* Channel D Length */ 1165 if((retVal = rtl8367c_setAsicPHYOCPReg(port, 0xa436, 0x8038)) != RT_ERR_OK) 1166 return retVal; 1167 1168 if((retVal = rtl8367c_getAsicPHYOCPReg(port, 0xa438, ®Data)) != RT_ERR_OK) 1169 return retVal; 1170 1171 pResult->channelDLen = (regData / 2); 1172 } 1173 else 1174 finish = 0; 1175 } 1176 else 1177 return RT_ERR_CHIP_NOT_SUPPORTED; 1178 1179 if(finish == 0) 1180 return RT_ERR_PHY_RTCT_NOT_FINISH; 1181 else 1182 return RT_ERR_OK; 1183} 1184