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: 42321 $ 13 * $Date: 2013-08-26 13:51:29 +0800 (������, 26 ������ 2013) $ 14 * 15 * Purpose : RTL8367C switch high-level API for RTL8367C 16 * Feature : IGMP related functions 17 * 18 */ 19#include <rtl8367c_asicdrv_igmp.h> 20/* Function Name: 21 * rtl8367c_setAsicIgmp 22 * Description: 23 * Set IGMP/MLD state 24 * Input: 25 * enabled - 1: enabled, 0: disabled 26 * Output: 27 * None 28 * Return: 29 * RT_ERR_OK - Success 30 * RT_ERR_SMI - SMI access error 31 * Note: 32 * None 33 */ 34ret_t rtl8367c_setAsicIgmp(rtk_uint32 enabled) 35{ 36 ret_t retVal; 37 38 /* Enable/Disable H/W IGMP/MLD */ 39 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_EN_OFFSET, enabled); 40 41 return retVal; 42} 43/* Function Name: 44 * rtl8367c_getAsicIgmp 45 * Description: 46 * Get IGMP/MLD state 47 * Input: 48 * enabled - 1: enabled, 0: disabled 49 * Output: 50 * None 51 * Return: 52 * RT_ERR_OK - Success 53 * RT_ERR_SMI - SMI access error 54 * Note: 55 * None 56 */ 57ret_t rtl8367c_getAsicIgmp(rtk_uint32 *ptr_enabled) 58{ 59 ret_t retVal; 60 61 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_EN_OFFSET, ptr_enabled); 62 return retVal; 63} 64/* Function Name: 65 * rtl8367c_setAsicIpMulticastVlanLeaky 66 * Description: 67 * Set IP multicast VLAN Leaky function 68 * Input: 69 * port - Physical port number (0~7) 70 * enabled - 1: enabled, 0: disabled 71 * Output: 72 * None 73 * Return: 74 * RT_ERR_OK - Success 75 * RT_ERR_SMI - SMI access error 76 * RT_ERR_PORT_ID - Invalid port number 77 * Note: 78 * When enabling this function, 79 * if the lookup result(forwarding portmap) of IP Multicast packet is over VLAN boundary, 80 * the packet can be forwarded across VLAN 81 */ 82ret_t rtl8367c_setAsicIpMulticastVlanLeaky(rtk_uint32 port, rtk_uint32 enabled) 83{ 84 ret_t retVal; 85 86 if(port > RTL8367C_PORTIDMAX) 87 return RT_ERR_PORT_ID; 88 89 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IPMCAST_VLAN_LEAKY, port, enabled); 90 91 return retVal; 92} 93/* Function Name: 94 * rtl8367c_getAsicIpMulticastVlanLeaky 95 * Description: 96 * Get IP multicast VLAN Leaky function 97 * Input: 98 * port - Physical port number (0~7) 99 * enabled - 1: enabled, 0: disabled 100 * Output: 101 * None 102 * Return: 103 * RT_ERR_OK - Success 104 * RT_ERR_SMI - SMI access error 105 * RT_ERR_PORT_ID - Invalid port number 106 * Note: 107 * None 108 */ 109ret_t rtl8367c_getAsicIpMulticastVlanLeaky(rtk_uint32 port, rtk_uint32 *ptr_enabled) 110{ 111 ret_t retVal; 112 113 if(port > RTL8367C_PORTIDMAX) 114 return RT_ERR_PORT_ID; 115 116 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IPMCAST_VLAN_LEAKY, port, ptr_enabled); 117 118 return retVal; 119} 120 121/* Function Name: 122 * rtl8367c_setAsicIGMPTableFullOP 123 * Description: 124 * Set Table Full operation 125 * Input: 126 * operation - The operation should be taken when the IGMP table is full. 127 * Output: 128 * None 129 * Return: 130 * RT_ERR_OK - Success 131 * RT_ERR_SMI - SMI access error 132 * RT_ERR_OUT_OF_RANGE - input parameter is out of range 133 * Note: 134 * None 135 */ 136ret_t rtl8367c_setAsicIGMPTableFullOP(rtk_uint32 operation) 137{ 138 ret_t retVal; 139 140 if(operation >= TABLE_FULL_OP_END) 141 return RT_ERR_OUT_OF_RANGE; 142 143 /* Table full Operation */ 144 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_TABLE_FULL_OP_MASK, operation); 145 if(retVal != RT_ERR_OK) 146 return retVal; 147 148 return RT_ERR_OK; 149} 150 151/* Function Name: 152 * rtl8367c_getAsicIGMPTableFullOP 153 * Description: 154 * Get Table Full operation 155 * Input: 156 * None 157 * Output: 158 * poperation - The operation should be taken when the IGMP table is full. 159 * Return: 160 * RT_ERR_OK - Success 161 * RT_ERR_SMI - SMI access error 162 * Note: 163 * None 164 */ 165ret_t rtl8367c_getAsicIGMPTableFullOP(rtk_uint32 *poperation) 166{ 167 ret_t retVal; 168 rtk_uint32 value; 169 170 /* Table full Operation */ 171 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_TABLE_FULL_OP_MASK, &value); 172 if(retVal != RT_ERR_OK) 173 return retVal; 174 175 *poperation = value; 176 177 return RT_ERR_OK; 178} 179 180/* Function Name: 181 * rtl8367c_setAsicIGMPCRCErrOP 182 * Description: 183 * Set the operation when ASIC receive a Checksum error packet 184 * Input: 185 * operation -The operation when ASIC receive a Checksum error packet 186 * Output: 187 * None 188 * Return: 189 * RT_ERR_OK - Success 190 * RT_ERR_SMI - SMI access error 191 * RT_ERR_OUT_OF_RANGE - input parameter is out of range 192 * Note: 193 * None 194 */ 195ret_t rtl8367c_setAsicIGMPCRCErrOP(rtk_uint32 operation) 196{ 197 ret_t retVal; 198 199 if(operation >= CRC_ERR_OP_END) 200 return RT_ERR_OUT_OF_RANGE; 201 202 /* CRC Error Operation */ 203 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_CKS_ERR_OP_MASK, operation); 204 if(retVal != RT_ERR_OK) 205 return retVal; 206 207 return RT_ERR_OK; 208} 209 210/* Function Name: 211 * rtl8367c_getAsicIGMPCRCErrOP 212 * Description: 213 * Get the operation when ASIC receive a Checksum error packet 214 * Input: 215 * None 216 * Output: 217 * poperation - The operation of Checksum error packet 218 * Return: 219 * RT_ERR_OK - Success 220 * RT_ERR_SMI - SMI access error 221 * Note: 222 * None 223 */ 224ret_t rtl8367c_getAsicIGMPCRCErrOP(rtk_uint32 *poperation) 225{ 226 ret_t retVal; 227 rtk_uint32 value; 228 229 /* CRC Error Operation */ 230 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_CKS_ERR_OP_MASK, &value); 231 if(retVal != RT_ERR_OK) 232 return retVal; 233 234 *poperation = value; 235 236 return RT_ERR_OK; 237} 238 239/* Function Name: 240 * rtl8367c_setAsicIGMPFastLeaveEn 241 * Description: 242 * Enable/Disable Fast Leave 243 * Input: 244 * enabled - 1:enable Fast Leave; 0:disable Fast Leave 245 * Output: 246 * None 247 * Return: 248 * RT_ERR_OK - Success 249 * RT_ERR_SMI - SMI access error 250 * Note: 251 * None 252 */ 253ret_t rtl8367c_setAsicIGMPFastLeaveEn(rtk_uint32 enabled) 254{ 255 ret_t retVal; 256 257 /* Fast Leave */ 258 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_FAST_LEAVE_EN_MASK, (enabled >= 1) ? 1 : 0); 259 if(retVal != RT_ERR_OK) 260 return retVal; 261 262 return RT_ERR_OK; 263} 264 265/* Function Name: 266 * rtl8367c_getAsicIGMPFastLeaveEn 267 * Description: 268 * Get Fast Leave state 269 * Input: 270 * None 271 * Output: 272 * penabled - 1:enable Fast Leave; 0:disable Fast Leave 273 * Return: 274 * RT_ERR_OK - Success 275 * RT_ERR_SMI - SMI access error 276 * Note: 277 * None 278 */ 279ret_t rtl8367c_getAsicIGMPFastLeaveEn(rtk_uint32 *penabled) 280{ 281 ret_t retVal; 282 rtk_uint32 value; 283 284 /* Fast Leave */ 285 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_FAST_LEAVE_EN_MASK, &value); 286 if(retVal != RT_ERR_OK) 287 return retVal; 288 289 *penabled = value; 290 291 return RT_ERR_OK; 292} 293 294/* Function Name: 295 * rtl8367c_setAsicIGMPLeaveTimer 296 * Description: 297 * Set the Leave timer of IGMP/MLD 298 * Input: 299 * leave_timer - Leave timer 300 * Output: 301 * None 302 * Return: 303 * RT_ERR_OK - Success 304 * RT_ERR_SMI - SMI access error 305 * RT_ERR_OUT_OF_RANGE - input parameter is out of range 306 * Note: 307 * None 308 */ 309ret_t rtl8367c_setAsicIGMPLeaveTimer(rtk_uint32 leave_timer) 310{ 311 ret_t retVal; 312 313 if(leave_timer > RTL8367C_MAX_LEAVE_TIMER) 314 return RT_ERR_OUT_OF_RANGE; 315 316 /* Leave timer */ 317 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_TIMER_MASK, leave_timer); 318 if(retVal != RT_ERR_OK) 319 return retVal; 320 321 return RT_ERR_OK; 322} 323 324/* Function Name: 325 * rtl8367c_getAsicIGMPLeaveTimer 326 * Description: 327 * Get the Leave timer of IGMP/MLD 328 * Input: 329 * None 330 * Output: 331 * pleave_timer - Leave timer 332 * Return: 333 * RT_ERR_OK - Success 334 * RT_ERR_SMI - SMI access error 335 * Note: 336 * None 337 */ 338ret_t rtl8367c_getAsicIGMPLeaveTimer(rtk_uint32 *pleave_timer) 339{ 340 ret_t retVal; 341 rtk_uint32 value; 342 343 /* Leave timer */ 344 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_TIMER_MASK, &value); 345 if(retVal != RT_ERR_OK) 346 return retVal; 347 348 *pleave_timer = value; 349 350 return RT_ERR_OK; 351} 352 353/* Function Name: 354 * rtl8367c_setAsicIGMPQueryInterval 355 * Description: 356 * Set Query Interval of IGMP/MLD 357 * Input: 358 * interval - Query Interval 359 * Output: 360 * None 361 * Return: 362 * RT_ERR_OK - Success 363 * RT_ERR_SMI - SMI access error 364 * RT_ERR_OUT_OF_RANGE - input parameter is out of range 365 * Note: 366 * None 367 */ 368ret_t rtl8367c_setAsicIGMPQueryInterval(rtk_uint32 interval) 369{ 370 ret_t retVal; 371 372 if(interval > RTL8367C_MAX_QUERY_INT) 373 return RT_ERR_OUT_OF_RANGE; 374 375 /* Query Interval */ 376 retVal = rtl8367c_setAsicReg(RTL8367C_REG_IGMP_MLD_CFG2, interval); 377 if(retVal != RT_ERR_OK) 378 return retVal; 379 380 return RT_ERR_OK; 381} 382 383/* Function Name: 384 * rtl8367c_getAsicIGMPQueryInterval 385 * Description: 386 * Get Query Interval of IGMP/MLD 387 * Input: 388 * None 389 * Output: 390 * pinterval - Query Interval 391 * Return: 392 * RT_ERR_OK - Success 393 * RT_ERR_SMI - SMI access error 394 * Note: 395 * None 396 */ 397ret_t rtl8367c_getAsicIGMPQueryInterval(rtk_uint32 *pinterval) 398{ 399 ret_t retVal; 400 rtk_uint32 value; 401 402 /* Query Interval */ 403 retVal = rtl8367c_getAsicReg(RTL8367C_REG_IGMP_MLD_CFG2, &value); 404 if(retVal != RT_ERR_OK) 405 return retVal; 406 407 *pinterval = value; 408 409 return RT_ERR_OK; 410} 411 412/* Function Name: 413 * rtl8367c_setAsicIGMPRobVar 414 * Description: 415 * Set Robustness Variable of IGMP/MLD 416 * Input: 417 * rob_var - Robustness Variable 418 * Output: 419 * None 420 * Return: 421 * RT_ERR_OK - Success 422 * RT_ERR_SMI - SMI access error 423 * RT_ERR_OUT_OF_RANGE - input parameter is out of range 424 * Note: 425 * None 426 */ 427ret_t rtl8367c_setAsicIGMPRobVar(rtk_uint32 rob_var) 428{ 429 ret_t retVal; 430 431 if(rob_var > RTL8367C_MAX_ROB_VAR) 432 return RT_ERR_OUT_OF_RANGE; 433 434 /* Bourstness variable */ 435 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_ROBURSTNESS_VAR_MASK, rob_var); 436 if(retVal != RT_ERR_OK) 437 return retVal; 438 439 return RT_ERR_OK; 440} 441 442/* Function Name: 443 * rtl8367c_getAsicIGMPRobVar 444 * Description: 445 * Get Robustness Variable of IGMP/MLD 446 * Input: 447 * none 448 * Output: 449 * prob_var - Robustness Variable 450 * Return: 451 * RT_ERR_OK - Success 452 * RT_ERR_SMI - SMI access error 453 * Note: 454 * None 455 */ 456ret_t rtl8367c_getAsicIGMPRobVar(rtk_uint32 *prob_var) 457{ 458 ret_t retVal; 459 rtk_uint32 value; 460 461 /* Bourstness variable */ 462 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_ROBURSTNESS_VAR_MASK, &value); 463 if(retVal != RT_ERR_OK) 464 return retVal; 465 466 *prob_var = value; 467 468 return RT_ERR_OK; 469} 470 471/* Function Name: 472 * rtl8367c_setAsicIGMPStaticRouterPort 473 * Description: 474 * Set IGMP static router port mask 475 * Input: 476 * pmsk - Static portmask 477 * Output: 478 * None 479 * Return: 480 * RT_ERR_OK - Success 481 * RT_ERR_SMI - SMI access error 482 * RT_ERR_PORT_MASK - Invalid port mask 483 * Note: 484 * None 485 */ 486ret_t rtl8367c_setAsicIGMPStaticRouterPort(rtk_uint32 pmsk) 487{ 488 if(pmsk > RTL8367C_PORTMASK) 489 return RT_ERR_PORT_MASK; 490 491 return rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_STATIC_ROUTER_PORT, RTL8367C_IGMP_STATIC_ROUTER_PORT_MASK, pmsk); 492} 493 494/* Function Name: 495 * rtl8367c_getAsicIGMPStaticRouterPort 496 * Description: 497 * Get IGMP static router port mask 498 * Input: 499 * pmsk - Static portmask 500 * Output: 501 * None 502 * Return: 503 * RT_ERR_OK - Success 504 * RT_ERR_SMI - SMI access error 505 * Note: 506 * None 507 */ 508ret_t rtl8367c_getAsicIGMPStaticRouterPort(rtk_uint32 *pmsk) 509{ 510 return rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_STATIC_ROUTER_PORT, RTL8367C_IGMP_STATIC_ROUTER_PORT_MASK, pmsk); 511} 512 513/* Function Name: 514 * rtl8367c_setAsicIGMPAllowDynamicRouterPort 515 * Description: 516 * Set IGMP dynamic router port allow mask 517 * Input: 518 * pmsk - Allow dynamic router port mask 519 * Output: 520 * None 521 * Return: 522 * RT_ERR_OK - Success 523 * RT_ERR_SMI - SMI access error 524 * RT_ERR_PORT_MASK - Invalid port mask 525 * Note: 526 * None 527 */ 528ret_t rtl8367c_setAsicIGMPAllowDynamicRouterPort(rtk_uint32 pmsk) 529{ 530 return rtl8367c_setAsicReg(RTL8367C_REG_IGMP_MLD_CFG4, pmsk); 531} 532 533/* Function Name: 534 * rtl8367c_getAsicIGMPAllowDynamicRouterPort 535 * Description: 536 * Get IGMP dynamic router port allow mask 537 * Input: 538 * None. 539 * Output: 540 * pPmsk - Allow dynamic router port mask 541 * Return: 542 * RT_ERR_OK - Success 543 * RT_ERR_SMI - SMI access error 544 * RT_ERR_PORT_MASK - Invalid port mask 545 * Note: 546 * None 547 */ 548ret_t rtl8367c_getAsicIGMPAllowDynamicRouterPort(rtk_uint32 *pPmsk) 549{ 550 return rtl8367c_getAsicReg(RTL8367C_REG_IGMP_MLD_CFG4, pPmsk); 551} 552 553/* Function Name: 554 * rtl8367c_getAsicIGMPdynamicRouterPort1 555 * Description: 556 * Get 1st dynamic router port and timer 557 * Input: 558 * port - Physical port number (0~7) 559 * timer - router port timer 560 * Output: 561 * None 562 * Return: 563 * RT_ERR_OK - Success 564 * RT_ERR_SMI - SMI access error 565 * Note: 566 * None 567 */ 568ret_t rtl8367c_getAsicIGMPdynamicRouterPort1(rtk_uint32 *port, rtk_uint32 *timer) 569{ 570 ret_t retVal; 571 572 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_1_MASK, port); 573 if(retVal != RT_ERR_OK) 574 return retVal; 575 576 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_TMR_1_MASK, timer); 577 if(retVal != RT_ERR_OK) 578 return retVal; 579 580 return RT_ERR_OK; 581} 582 583/* Function Name: 584 * rtl8367c_getAsicIGMPdynamicRouterPort2 585 * Description: 586 * Get 2nd dynamic router port and timer 587 * Input: 588 * port - Physical port number (0~7) 589 * timer - router port timer 590 * Output: 591 * None 592 * Return: 593 * RT_ERR_OK - Success 594 * RT_ERR_SMI - SMI access error 595 * Note: 596 * None 597 */ 598ret_t rtl8367c_getAsicIGMPdynamicRouterPort2(rtk_uint32 *port, rtk_uint32 *timer) 599{ 600 ret_t retVal; 601 602 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_2_MASK, port); 603 if(retVal != RT_ERR_OK) 604 return retVal; 605 606 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_TMR_2_MASK, timer); 607 if(retVal != RT_ERR_OK) 608 return retVal; 609 610 return RT_ERR_OK; 611} 612 613/* Function Name: 614 * rtl8367c_setAsicIGMPSuppression 615 * Description: 616 * Set the suppression function 617 * Input: 618 * report_supp_enabled - Report suppression, 1:Enable, 0:disable 619 * leave_supp_enabled - Leave suppression, 1:Enable, 0:disable 620 * Output: 621 * None 622 * Return: 623 * RT_ERR_OK - Success 624 * RT_ERR_SMI - SMI access error 625 * Note: 626 * None 627 */ 628ret_t rtl8367c_setAsicIGMPSuppression(rtk_uint32 report_supp_enabled, rtk_uint32 leave_supp_enabled) 629{ 630 ret_t retVal; 631 632 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_REPORT_SUPPRESSION_MASK, report_supp_enabled); 633 if(retVal != RT_ERR_OK) 634 return retVal; 635 636 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_SUPPRESSION_MASK, leave_supp_enabled); 637 if(retVal != RT_ERR_OK) 638 return retVal; 639 640 return RT_ERR_OK; 641} 642 643/* Function Name: 644 * rtl8367c_getAsicIGMPSuppression 645 * Description: 646 * Get the suppression function 647 * Input: 648 * report_supp_enabled - Report suppression, 1:Enable, 0:disable 649 * leave_supp_enabled - Leave suppression, 1:Enable, 0:disable 650 * Output: 651 * None 652 * Return: 653 * RT_ERR_OK - Success 654 * RT_ERR_SMI - SMI access error 655 * Note: 656 * None 657 */ 658ret_t rtl8367c_getAsicIGMPSuppression(rtk_uint32 *report_supp_enabled, rtk_uint32 *leave_supp_enabled) 659{ 660 ret_t retVal; 661 662 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_REPORT_SUPPRESSION_MASK, report_supp_enabled); 663 if(retVal != RT_ERR_OK) 664 return retVal; 665 666 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_SUPPRESSION_MASK, leave_supp_enabled); 667 if(retVal != RT_ERR_OK) 668 return retVal; 669 670 return RT_ERR_OK; 671} 672 673/* Function Name: 674 * rtl8367c_setAsicIGMPQueryRX 675 * Description: 676 * Set port-based Query packet RX allowance 677 * Input: 678 * port - port number 679 * allow_query - allowance of Query packet RX, 1:Allow, 0:Drop 680 * Output: 681 * None 682 * Return: 683 * RT_ERR_OK - Success 684 * RT_ERR_PORT_ID - Error PORT ID 685 * RT_ERR_SMI - SMI access error 686 * Note: 687 * None 688 */ 689ret_t rtl8367c_setAsicIGMPQueryRX(rtk_uint32 port, rtk_uint32 allow_query) 690{ 691 ret_t retVal; 692 693 if(port > RTL8367C_PORTIDMAX) 694 return RT_ERR_PORT_ID; 695 696 /* Allow Query */ 697 if (port < 8) 698 { 699 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, allow_query); 700 if(retVal != RT_ERR_OK) 701 return retVal; 702 } 703 else 704 { 705 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, allow_query); 706 if(retVal != RT_ERR_OK) 707 return retVal; 708 } 709 710 return RT_ERR_OK; 711} 712 713/* Function Name: 714 * rtl8367c_getAsicIGMPQueryRX 715 * Description: 716 * Get port-based Query packet RX allowance 717 * Input: 718 * port - port number 719 * Output: 720 * allow_query - allowance of Query packet RX, 1:Allow, 0:Drop 721 * Return: 722 * RT_ERR_OK - Success 723 * RT_ERR_PORT_ID - Error PORT ID 724 * RT_ERR_SMI - SMI access error 725 * Note: 726 * None 727 */ 728ret_t rtl8367c_getAsicIGMPQueryRX(rtk_uint32 port, rtk_uint32 *allow_query) 729{ 730 ret_t retVal; 731 rtk_uint32 value; 732 733 if(port > RTL8367C_PORTIDMAX) 734 return RT_ERR_PORT_ID; 735 736 /* Allow Query */ 737 if (port < 8) 738 { 739 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, &value); 740 if(retVal != RT_ERR_OK) 741 return retVal; 742 } 743 else 744 { 745 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, &value); 746 if(retVal != RT_ERR_OK) 747 return retVal; 748 } 749 *allow_query = value; 750 751 return RT_ERR_OK; 752} 753 754/* Function Name: 755 * rtl8367c_setAsicIGMPReportRX 756 * Description: 757 * Set port-based Report packet RX allowance 758 * Input: 759 * port - port number 760 * allow_report - allowance of Report packet RX, 1:Allow, 0:Drop 761 * Output: 762 * None 763 * Return: 764 * RT_ERR_OK - Success 765 * RT_ERR_PORT_ID - Error PORT ID 766 * RT_ERR_SMI - SMI access error 767 * Note: 768 * None 769 */ 770ret_t rtl8367c_setAsicIGMPReportRX(rtk_uint32 port, rtk_uint32 allow_report) 771{ 772 ret_t retVal; 773 774 if(port > RTL8367C_PORTIDMAX) 775 return RT_ERR_PORT_ID; 776 777 if(port < 8) 778 { 779 /* Allow Report */ 780 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, allow_report); 781 if(retVal != RT_ERR_OK) 782 return retVal; 783 } 784 else 785 { 786 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, allow_report); 787 if(retVal != RT_ERR_OK) 788 return retVal; 789 } 790 return RT_ERR_OK; 791} 792 793/* Function Name: 794 * rtl8367c_getAsicIGMPReportRX 795 * Description: 796 * Get port-based Report packet RX allowance 797 * Input: 798 * port - port number 799 * Output: 800 * allow_report - allowance of Report packet RX, 1:Allow, 0:Drop 801 * Return: 802 * RT_ERR_OK - Success 803 * RT_ERR_PORT_ID - Error PORT ID 804 * RT_ERR_SMI - SMI access error 805 * Note: 806 * None 807 */ 808ret_t rtl8367c_getAsicIGMPReportRX(rtk_uint32 port, rtk_uint32 *allow_report) 809{ 810 ret_t retVal; 811 rtk_uint32 value; 812 813 if(port > RTL8367C_PORTIDMAX) 814 return RT_ERR_PORT_ID; 815 816 if(port < 8) 817 { 818 /* Allow Report */ 819 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, &value); 820 if(retVal != RT_ERR_OK) 821 return retVal; 822 } 823 else 824 { 825 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, &value); 826 if(retVal != RT_ERR_OK) 827 return retVal; 828 } 829 *allow_report = value; 830 831 return RT_ERR_OK; 832} 833 834/* Function Name: 835 * rtl8367c_setAsicIGMPLeaveRX 836 * Description: 837 * Set port-based Leave packet RX allowance 838 * Input: 839 * port - port number 840 * allow_leave - allowance of Leave packet RX, 1:Allow, 0:Drop 841 * Output: 842 * None 843 * Return: 844 * RT_ERR_OK - Success 845 * RT_ERR_PORT_ID - Error PORT ID 846 * RT_ERR_SMI - SMI access error 847 * Note: 848 * None 849 */ 850ret_t rtl8367c_setAsicIGMPLeaveRX(rtk_uint32 port, rtk_uint32 allow_leave) 851{ 852 ret_t retVal; 853 854 if(port > RTL8367C_PORTIDMAX) 855 return RT_ERR_PORT_ID; 856 857 if(port < 8) 858 { 859 /* Allow Leave */ 860 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, allow_leave); 861 if(retVal != RT_ERR_OK) 862 return retVal; 863 } 864 else 865 { 866 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, allow_leave); 867 if(retVal != RT_ERR_OK) 868 return retVal; 869 } 870 return RT_ERR_OK; 871} 872 873/* Function Name: 874 * rtl8367c_getAsicIGMPLeaveRX 875 * Description: 876 * Get port-based Leave packet RX allowance 877 * Input: 878 * port - port number 879 * Output: 880 * allow_leave - allowance of Leave packet RX, 1:Allow, 0:Drop 881 * Return: 882 * RT_ERR_OK - Success 883 * RT_ERR_PORT_ID - Error PORT ID 884 * RT_ERR_SMI - SMI access error 885 * Note: 886 * None 887 */ 888ret_t rtl8367c_getAsicIGMPLeaveRX(rtk_uint32 port, rtk_uint32 *allow_leave) 889{ 890 ret_t retVal; 891 rtk_uint32 value; 892 893 if(port > RTL8367C_PORTIDMAX) 894 return RT_ERR_PORT_ID; 895 896 if(port < 8) 897 { 898 /* Allow Leave */ 899 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, &value); 900 if(retVal != RT_ERR_OK) 901 return retVal; 902 } 903 else 904 { 905 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, &value); 906 if(retVal != RT_ERR_OK) 907 return retVal; 908 } 909 910 *allow_leave = value; 911 912 return RT_ERR_OK; 913} 914 915/* Function Name: 916 * rtl8367c_setAsicIGMPMRPRX 917 * Description: 918 * Set port-based Multicast Routing Protocol packet RX allowance 919 * Input: 920 * port - port number 921 * allow_mrp - allowance of Multicast Routing Protocol packet RX, 1:Allow, 0:Drop 922 * Output: 923 * None 924 * Return: 925 * RT_ERR_OK - Success 926 * RT_ERR_PORT_ID - Error PORT ID 927 * RT_ERR_SMI - SMI access error 928 * Note: 929 * None 930 */ 931ret_t rtl8367c_setAsicIGMPMRPRX(rtk_uint32 port, rtk_uint32 allow_mrp) 932{ 933 ret_t retVal; 934 935 if(port > RTL8367C_PORTIDMAX) 936 return RT_ERR_PORT_ID; 937 938 if(port < 8) 939 { 940 /* Allow Multicast Routing Protocol */ 941 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, allow_mrp); 942 if(retVal != RT_ERR_OK) 943 return retVal; 944 } 945 else 946 { 947 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, allow_mrp); 948 if(retVal != RT_ERR_OK) 949 return retVal; 950 } 951 return RT_ERR_OK; 952} 953 954/* Function Name: 955 * rtl8367c_getAsicIGMPMRPRX 956 * Description: 957 * Get port-based Multicast Routing Protocol packet RX allowance 958 * Input: 959 * port - port number 960 * Output: 961 * allow_mrp - allowance of Multicast Routing Protocol packet RX, 1:Allow, 0:Drop 962 * Return: 963 * RT_ERR_OK - Success 964 * RT_ERR_PORT_ID - Error PORT ID 965 * RT_ERR_SMI - SMI access error 966 * Note: 967 * None 968 */ 969ret_t rtl8367c_getAsicIGMPMRPRX(rtk_uint32 port, rtk_uint32 *allow_mrp) 970{ 971 ret_t retVal; 972 rtk_uint32 value; 973 974 if(port > RTL8367C_PORTIDMAX) 975 return RT_ERR_PORT_ID; 976 977 /* Allow Multicast Routing Protocol */ 978 if(port < 8) 979 { 980 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, &value); 981 if(retVal != RT_ERR_OK) 982 return retVal; 983 } 984 else 985 { 986 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, &value); 987 if(retVal != RT_ERR_OK) 988 return retVal; 989 } 990 *allow_mrp = value; 991 992 return RT_ERR_OK; 993} 994 995/* Function Name: 996 * rtl8367c_setAsicIGMPMcDataRX 997 * Description: 998 * Set port-based Multicast data packet RX allowance 999 * Input: 1000 * port - port number 1001 * allow_mcdata - allowance of Multicast data packet RX, 1:Allow, 0:Drop 1002 * Output: 1003 * none 1004 * Return: 1005 * RT_ERR_OK - Success 1006 * RT_ERR_PORT_ID - Error PORT ID 1007 * RT_ERR_SMI - SMI access error 1008 * Note: 1009 * None 1010 */ 1011ret_t rtl8367c_setAsicIGMPMcDataRX(rtk_uint32 port, rtk_uint32 allow_mcdata) 1012{ 1013 ret_t retVal; 1014 1015 if(port > RTL8367C_PORTIDMAX) 1016 return RT_ERR_PORT_ID; 1017 1018 /* Allow Multicast Data */ 1019 if(port < 8) 1020 { 1021 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, allow_mcdata); 1022 if(retVal != RT_ERR_OK) 1023 return retVal; 1024 } 1025 else 1026 { 1027 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, allow_mcdata); 1028 if(retVal != RT_ERR_OK) 1029 return retVal; 1030 } 1031 return RT_ERR_OK; 1032} 1033 1034/* Function Name: 1035 * rtl8367c_getAsicIGMPMcDataRX 1036 * Description: 1037 * Get port-based Multicast data packet RX allowance 1038 * Input: 1039 * port - port number 1040 * Output: 1041 * allow_mcdata - allowance of Multicast data packet RX, 1:Allow, 0:Drop 1042 * Return: 1043 * RT_ERR_OK - Success 1044 * RT_ERR_PORT_ID - Error PORT ID 1045 * RT_ERR_SMI - SMI access error 1046 * Note: 1047 * None 1048 */ 1049ret_t rtl8367c_getAsicIGMPMcDataRX(rtk_uint32 port, rtk_uint32 *allow_mcdata) 1050{ 1051 ret_t retVal; 1052 rtk_uint32 value; 1053 1054 if(port > RTL8367C_PORTIDMAX) 1055 return RT_ERR_PORT_ID; 1056 1057 /* Allow Multicast data */ 1058 if(port < 8) 1059 { 1060 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, &value); 1061 if(retVal != RT_ERR_OK) 1062 return retVal; 1063 } 1064 else 1065 { 1066 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, &value); 1067 if(retVal != RT_ERR_OK) 1068 return retVal; 1069 } 1070 1071 *allow_mcdata = value; 1072 1073 return RT_ERR_OK; 1074} 1075 1076/* Function Name: 1077 * rtl8367c_setAsicIGMPv1Opeartion 1078 * Description: 1079 * Set port-based IGMPv1 Control packet action 1080 * Input: 1081 * port - port number 1082 * igmpv1_op - IGMPv1 control packet action 1083 * Output: 1084 * None 1085 * Return: 1086 * RT_ERR_OK - Success 1087 * RT_ERR_PORT_ID - Error PORT ID 1088 * RT_ERR_SMI - SMI access error 1089 * Note: 1090 * None 1091 */ 1092ret_t rtl8367c_setAsicIGMPv1Opeartion(rtk_uint32 port, rtk_uint32 igmpv1_op) 1093{ 1094 ret_t retVal; 1095 1096 if(port > RTL8367C_PORTIDMAX) 1097 return RT_ERR_PORT_ID; 1098 1099 /* IGMPv1 operation */ 1100 if(port < 8) 1101 { 1102 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, igmpv1_op); 1103 if(retVal != RT_ERR_OK) 1104 return retVal; 1105 } 1106 else 1107 { 1108 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, igmpv1_op); 1109 if(retVal != RT_ERR_OK) 1110 return retVal; 1111 } 1112 1113 return RT_ERR_OK; 1114} 1115 1116/* Function Name: 1117 * rtl8367c_getAsicIGMPv1Opeartion 1118 * Description: 1119 * Get port-based IGMPv1 Control packet action 1120 * Input: 1121 * port - port number 1122 * Output: 1123 * igmpv1_op - IGMPv1 control packet action 1124 * Return: 1125 * RT_ERR_OK - Success 1126 * RT_ERR_PORT_ID - Error PORT ID 1127 * RT_ERR_SMI - SMI access error 1128 * Note: 1129 * None 1130 */ 1131ret_t rtl8367c_getAsicIGMPv1Opeartion(rtk_uint32 port, rtk_uint32 *igmpv1_op) 1132{ 1133 ret_t retVal; 1134 rtk_uint32 value; 1135 1136 if(port > RTL8367C_PORTIDMAX) 1137 return RT_ERR_PORT_ID; 1138 1139 /* IGMPv1 operation */ 1140 if(port < 8) 1141 { 1142 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, &value); 1143 if(retVal != RT_ERR_OK) 1144 return retVal; 1145 } 1146 else 1147 { 1148 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, &value); 1149 if(retVal != RT_ERR_OK) 1150 return retVal; 1151 } 1152 1153 *igmpv1_op = value; 1154 1155 return RT_ERR_OK; 1156} 1157 1158/* Function Name: 1159 * rtl8367c_setAsicIGMPv2Opeartion 1160 * Description: 1161 * Set port-based IGMPv2 Control packet action 1162 * Input: 1163 * port - port number 1164 * igmpv2_op - IGMPv2 control packet action 1165 * Output: 1166 * None 1167 * Return: 1168 * RT_ERR_OK - Success 1169 * RT_ERR_PORT_ID - Error PORT ID 1170 * RT_ERR_SMI - SMI access error 1171 * Note: 1172 * None 1173 */ 1174ret_t rtl8367c_setAsicIGMPv2Opeartion(rtk_uint32 port, rtk_uint32 igmpv2_op) 1175{ 1176 ret_t retVal; 1177 1178 if(port > RTL8367C_PORTIDMAX) 1179 return RT_ERR_PORT_ID; 1180 1181 /* IGMPv2 operation */ 1182 if(port < 8) 1183 { 1184 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, igmpv2_op); 1185 if(retVal != RT_ERR_OK) 1186 return retVal; 1187 } 1188 else 1189 { 1190 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, igmpv2_op); 1191 if(retVal != RT_ERR_OK) 1192 return retVal; 1193 } 1194 1195 return RT_ERR_OK; 1196} 1197 1198/* Function Name: 1199 * rtl8367c_getAsicIGMPv2Opeartion 1200 * Description: 1201 * Get port-based IGMPv2 Control packet action 1202 * Input: 1203 * port - port number 1204 * Output: 1205 * igmpv2_op - IGMPv2 control packet action 1206 * Return: 1207 * RT_ERR_OK - Success 1208 * RT_ERR_PORT_ID - Error PORT ID 1209 * RT_ERR_SMI - SMI access error 1210 * Note: 1211 * None 1212 */ 1213ret_t rtl8367c_getAsicIGMPv2Opeartion(rtk_uint32 port, rtk_uint32 *igmpv2_op) 1214{ 1215 ret_t retVal; 1216 rtk_uint32 value; 1217 1218 if(port > RTL8367C_PORTIDMAX) 1219 return RT_ERR_PORT_ID; 1220 1221 /* IGMPv2 operation */ 1222 if(port < 8) 1223 { 1224 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, &value); 1225 if(retVal != RT_ERR_OK) 1226 return retVal; 1227 } 1228 else 1229 { 1230 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, &value); 1231 if(retVal != RT_ERR_OK) 1232 return retVal; 1233 } 1234 1235 *igmpv2_op = value; 1236 1237 return RT_ERR_OK; 1238} 1239 1240/* Function Name: 1241 * rtl8367c_setAsicIGMPv3Opeartion 1242 * Description: 1243 * Set port-based IGMPv3 Control packet action 1244 * Input: 1245 * port - port number 1246 * igmpv3_op - IGMPv3 control packet action 1247 * Output: 1248 * None 1249 * Return: 1250 * RT_ERR_OK - Success 1251 * RT_ERR_PORT_ID - Error PORT ID 1252 * RT_ERR_SMI - SMI access error 1253 * Note: 1254 * None 1255 */ 1256ret_t rtl8367c_setAsicIGMPv3Opeartion(rtk_uint32 port, rtk_uint32 igmpv3_op) 1257{ 1258 ret_t retVal; 1259 1260 if(port > RTL8367C_PORTIDMAX) 1261 return RT_ERR_PORT_ID; 1262 1263 if(port > RTL8367C_PORTIDMAX) 1264 return RT_ERR_PORT_ID; 1265 1266 /* IGMPv3 operation */ 1267 if(port < 8) 1268 { 1269 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, igmpv3_op); 1270 if(retVal != RT_ERR_OK) 1271 return retVal; 1272 } 1273 else 1274 { 1275 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, igmpv3_op); 1276 if(retVal != RT_ERR_OK) 1277 return retVal; 1278 } 1279 1280 return RT_ERR_OK; 1281} 1282 1283/* Function Name: 1284 * rtl8367c_getAsicIGMPv3Opeartion 1285 * Description: 1286 * Get port-based IGMPv3 Control packet action 1287 * Input: 1288 * port - port number 1289 * Output: 1290 * igmpv3_op - IGMPv3 control packet action 1291 * Return: 1292 * RT_ERR_OK - Success 1293 * RT_ERR_PORT_ID - Error PORT ID 1294 * RT_ERR_SMI - SMI access error 1295 * Note: 1296 * None 1297 */ 1298ret_t rtl8367c_getAsicIGMPv3Opeartion(rtk_uint32 port, rtk_uint32 *igmpv3_op) 1299{ 1300 ret_t retVal; 1301 rtk_uint32 value; 1302 1303 if(port > RTL8367C_PORTIDMAX) 1304 return RT_ERR_PORT_ID; 1305 1306 /* IGMPv3 operation */ 1307 if(port < 8) 1308 { 1309 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, &value); 1310 if(retVal != RT_ERR_OK) 1311 return retVal; 1312 } 1313 else 1314 { 1315 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, &value); 1316 if(retVal != RT_ERR_OK) 1317 return retVal; 1318 } 1319 1320 *igmpv3_op = value; 1321 1322 return RT_ERR_OK; 1323} 1324 1325/* Function Name: 1326 * rtl8367c_setAsicMLDv1Opeartion 1327 * Description: 1328 * Set port-based MLDv1 Control packet action 1329 * Input: 1330 * port - port number 1331 * mldv1_op - MLDv1 control packet action 1332 * Output: 1333 * None 1334 * Return: 1335 * RT_ERR_OK - Success 1336 * RT_ERR_PORT_ID - Error PORT ID 1337 * RT_ERR_SMI - SMI access error 1338 * Note: 1339 * None 1340 */ 1341ret_t rtl8367c_setAsicMLDv1Opeartion(rtk_uint32 port, rtk_uint32 mldv1_op) 1342{ 1343 ret_t retVal; 1344 1345 if(port > RTL8367C_PORTIDMAX) 1346 return RT_ERR_PORT_ID; 1347 1348 /* MLDv1 operation */ 1349 if(port < 8) 1350 { 1351 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, mldv1_op); 1352 if(retVal != RT_ERR_OK) 1353 return retVal; 1354 } 1355 else 1356 { 1357 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, mldv1_op); 1358 if(retVal != RT_ERR_OK) 1359 return retVal; 1360 } 1361 1362 return RT_ERR_OK; 1363} 1364 1365/* Function Name: 1366 * rtl8367c_getAsicMLDv1Opeartion 1367 * Description: 1368 * Get port-based MLDv1 Control packet action 1369 * Input: 1370 * port - port number 1371 * Output: 1372 * mldv1_op - MLDv1 control packet action 1373 * Return: 1374 * RT_ERR_OK - Success 1375 * RT_ERR_PORT_ID - Error PORT ID 1376 * RT_ERR_SMI - SMI access error 1377 * Note: 1378 * None 1379 */ 1380ret_t rtl8367c_getAsicMLDv1Opeartion(rtk_uint32 port, rtk_uint32 *mldv1_op) 1381{ 1382 ret_t retVal; 1383 rtk_uint32 value; 1384 1385 if(port > RTL8367C_PORTIDMAX) 1386 return RT_ERR_PORT_ID; 1387 1388 /* MLDv1 operation */ 1389 if(port < 8) 1390 { 1391 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, &value); 1392 if(retVal != RT_ERR_OK) 1393 return retVal; 1394 } 1395 else 1396 { 1397 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, &value); 1398 if(retVal != RT_ERR_OK) 1399 return retVal; 1400 } 1401 1402 *mldv1_op = value; 1403 1404 return RT_ERR_OK; 1405} 1406 1407/* Function Name: 1408 * rtl8367c_setAsicMLDv2Opeartion 1409 * Description: 1410 * Set port-based MLDv2 Control packet action 1411 * Input: 1412 * port - port number 1413 * mldv2_op - MLDv2 control packet action 1414 * Output: 1415 * none 1416 * Return: 1417 * RT_ERR_OK - Success 1418 * RT_ERR_PORT_ID - Error PORT ID 1419 * RT_ERR_SMI - SMI access error 1420 * Note: 1421 * None 1422 */ 1423ret_t rtl8367c_setAsicMLDv2Opeartion(rtk_uint32 port, rtk_uint32 mldv2_op) 1424{ 1425 ret_t retVal; 1426 1427 if(port > RTL8367C_PORTIDMAX) 1428 return RT_ERR_PORT_ID; 1429 1430 /* MLDv2 operation */ 1431 if(port < 8) 1432 { 1433 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, mldv2_op); 1434 if(retVal != RT_ERR_OK) 1435 return retVal; 1436 } 1437 else 1438 { 1439 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, mldv2_op); 1440 if(retVal != RT_ERR_OK) 1441 return retVal; 1442 } 1443 1444 return RT_ERR_OK; 1445} 1446 1447/* Function Name: 1448 * rtl8367c_getAsicMLDv2Opeartion 1449 * Description: 1450 * Get port-based MLDv2 Control packet action 1451 * Input: 1452 * port - port number 1453 * Output: 1454 * mldv2_op - MLDv2 control packet action 1455 * Return: 1456 * RT_ERR_OK - Success 1457 * RT_ERR_PORT_ID - Error PORT ID 1458 * RT_ERR_SMI - SMI access error 1459 * Note: 1460 * None 1461 */ 1462ret_t rtl8367c_getAsicMLDv2Opeartion(rtk_uint32 port, rtk_uint32 *mldv2_op) 1463{ 1464 ret_t retVal; 1465 rtk_uint32 value; 1466 1467 if(port > RTL8367C_PORTIDMAX) 1468 return RT_ERR_PORT_ID; 1469 1470 /* MLDv2 operation */ 1471 if(port < 8) 1472 { 1473 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, &value); 1474 if(retVal != RT_ERR_OK) 1475 return retVal; 1476 } 1477 else 1478 { 1479 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, &value); 1480 if(retVal != RT_ERR_OK) 1481 return retVal; 1482 } 1483 1484 *mldv2_op = value; 1485 1486 return RT_ERR_OK; 1487} 1488 1489/* Function Name: 1490 * rtl8367c_setAsicIGMPPortMAXGroup 1491 * Description: 1492 * Set per-port Max group number 1493 * Input: 1494 * port - Physical port number (0~7) 1495 * max_group - max IGMP group 1496 * Output: 1497 * None 1498 * Return: 1499 * RT_ERR_OK - Success 1500 * RT_ERR_SMI - SMI access error 1501 * RT_ERR_PORT_ID - Invalid port number 1502 * RT_ERR_OUT_OF_RANGE - input parameter out of range 1503 * Note: 1504 * None 1505 */ 1506ret_t rtl8367c_setAsicIGMPPortMAXGroup(rtk_uint32 port, rtk_uint32 max_group) 1507{ 1508 ret_t retVal; 1509 1510 if(port > RTL8367C_PORTIDMAX) 1511 return RT_ERR_PORT_ID; 1512 1513 if(max_group > RTL8367C_IGMP_MAX_GOUP) 1514 return RT_ERR_OUT_OF_RANGE; 1515 1516 if(port < 8) 1517 { 1518 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT01_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), max_group); 1519 if(retVal != RT_ERR_OK) 1520 return retVal; 1521 } 1522 else 1523 { 1524 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT89_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), max_group); 1525 if(retVal != RT_ERR_OK) 1526 return retVal; 1527 } 1528 1529 return RT_ERR_OK; 1530} 1531/* Function Name: 1532 * rtl8367c_getAsicIGMPPortMAXGroup 1533 * Description: 1534 * Get per-port Max group number 1535 * Input: 1536 * port - Physical port number (0~7) 1537 * max_group - max IGMP group 1538 * Output: 1539 * None 1540 * Return: 1541 * RT_ERR_OK - Success 1542 * RT_ERR_SMI - SMI access error 1543 * RT_ERR_PORT_ID - Invalid port number 1544 * Note: 1545 * None 1546 */ 1547ret_t rtl8367c_getAsicIGMPPortMAXGroup(rtk_uint32 port, rtk_uint32 *max_group) 1548{ 1549 ret_t retVal; 1550 rtk_uint32 value; 1551 1552 if(port > RTL8367C_PORTIDMAX) 1553 return RT_ERR_PORT_ID; 1554 1555 if(port < 8) 1556 { 1557 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT01_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), &value); 1558 if(retVal != RT_ERR_OK) 1559 return retVal; 1560 } 1561 else 1562 { 1563 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT89_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), &value); 1564 if(retVal != RT_ERR_OK) 1565 return retVal; 1566 } 1567 1568 *max_group = value; 1569 return RT_ERR_OK; 1570} 1571/* Function Name: 1572 * rtl8367c_getAsicIGMPPortCurrentGroup 1573 * Description: 1574 * Get per-port current group number 1575 * Input: 1576 * port - Physical port number (0~7) 1577 * current_group - current IGMP group 1578 * Output: 1579 * None 1580 * Return: 1581 * RT_ERR_OK - Success 1582 * RT_ERR_SMI - SMI access error 1583 * RT_ERR_PORT_ID - Invalid port number 1584 * Note: 1585 * None 1586 */ 1587ret_t rtl8367c_getAsicIGMPPortCurrentGroup(rtk_uint32 port, rtk_uint32 *current_group) 1588{ 1589 ret_t retVal; 1590 rtk_uint32 value; 1591 1592 if(port > RTL8367C_PORTIDMAX) 1593 return RT_ERR_PORT_ID; 1594 1595 if(port < 8) 1596 { 1597 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT01_CURRENT_GROUP + (port/2), RTL8367C_PORT0_CURRENT_GROUP_MASK << (RTL8367C_PORT1_CURRENT_GROUP_OFFSET * (port%2)), &value); 1598 if(retVal != RT_ERR_OK) 1599 return retVal; 1600 } 1601 else 1602 { 1603 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT89_CURRENT_GROUP + (port/2), RTL8367C_PORT0_CURRENT_GROUP_MASK << (RTL8367C_PORT1_CURRENT_GROUP_OFFSET * (port%2)), &value); 1604 if(retVal != RT_ERR_OK) 1605 return retVal; 1606 } 1607 1608 *current_group = value; 1609 return RT_ERR_OK; 1610} 1611/* Function Name: 1612 * rtl8367c_getAsicIGMPGroup 1613 * Description: 1614 * Get IGMP group 1615 * Input: 1616 * idx - Group index (0~255) 1617 * valid - valid bit 1618 * grp - IGMP group 1619 * Output: 1620 * None 1621 * Return: 1622 * RT_ERR_OK - Success 1623 * RT_ERR_SMI - SMI access error 1624 * RT_ERR_OUT_OF_RANGE - Group index is out of range 1625 * Note: 1626 * None 1627 */ 1628ret_t rtl8367c_getAsicIGMPGroup(rtk_uint32 idx, rtk_uint32 *valid, rtl8367c_igmpgroup *grp) 1629{ 1630 ret_t retVal; 1631 rtk_uint32 regAddr, regData; 1632 rtk_uint16* tableAddr; 1633 rtk_uint32 i; 1634 1635 if(idx > RTL8367C_IGMP_MAX_GOUP) 1636 return RT_ERR_OUT_OF_RANGE; 1637 1638 /* Write ACS_ADR register for data bits */ 1639 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG; 1640 regData = idx; 1641 retVal = rtl8367c_setAsicReg(regAddr, regData); 1642 if(retVal != RT_ERR_OK) 1643 return retVal; 1644 1645 /* Write ACS_CMD register */ 1646 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG; 1647 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ, TB_TARGET_IGMP_GROUP); 1648 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData); 1649 if(retVal != RT_ERR_OK) 1650 return retVal; 1651 1652 /* Read Data Bits */ 1653 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE; 1654 tableAddr = (rtk_uint16*)grp; 1655 for(i=0;i<RTL8367C_IGMP_GRP_BLEN;i++) 1656 { 1657 retVal = rtl8367c_getAsicReg(regAddr, ®Data); 1658 if(retVal != RT_ERR_OK) 1659 return retVal; 1660 1661 *tableAddr = regData; 1662 1663 regAddr ++; 1664 tableAddr ++; 1665 } 1666 1667 /* Valid bit */ 1668 retVal = rtl8367c_getAsicReg(RTL8367C_IGMP_GROUP_USAGE_REG(idx), ®Data); 1669 if(retVal != RT_ERR_OK) 1670 return retVal; 1671 1672 *valid = ((regData & (0x0001 << (idx %16))) != 0) ? 1 : 0; 1673 1674 return RT_ERR_OK; 1675} 1676/* Function Name: 1677 * rtl8367c_setAsicIpMulticastPortIsoLeaky 1678 * Description: 1679 * Set IP multicast Port Isolation leaky 1680 * Input: 1681 * port - Physical port number (0~7) 1682 * enabled - 1: enabled, 0: disabled 1683 * Output: 1684 * None 1685 * Return: 1686 * RT_ERR_OK - Success 1687 * RT_ERR_SMI - SMI access error 1688 * RT_ERR_PORT_ID - Invalid port number 1689 * Note: 1690 * None 1691 */ 1692ret_t rtl8367c_setAsicIpMulticastPortIsoLeaky(rtk_uint32 port, rtk_uint32 enabled) 1693{ 1694 ret_t retVal; 1695 1696 if(port > RTL8367C_PORTIDMAX) 1697 return RT_ERR_PORT_ID; 1698 1699 retVal = rtl8367c_setAsicRegBits(RTL8367C_IPMCAST_PORTISO_LEAKY_REG, (0x0001 << port), enabled); 1700 if(retVal != RT_ERR_OK) 1701 return retVal; 1702 1703 return RT_ERR_OK; 1704} 1705 1706/* Function Name: 1707 * rtl8367c_getAsicIpMulticastPortIsoLeaky 1708 * Description: 1709 * Get IP multicast Port Isolation leaky 1710 * Input: 1711 * port - Physical port number (0~7) 1712 * enabled - 1: enabled, 0: disabled 1713 * Output: 1714 * None 1715 * Return: 1716 * RT_ERR_OK - Success 1717 * RT_ERR_SMI - SMI access error 1718 * Note: 1719 * None 1720 */ 1721ret_t rtl8367c_getAsicIpMulticastPortIsoLeaky(rtk_uint32 port, rtk_uint32 *enabled) 1722{ 1723 ret_t retVal; 1724 rtk_uint32 regData; 1725 1726 retVal = rtl8367c_getAsicRegBits(RTL8367C_IPMCAST_PORTISO_LEAKY_REG, (0x0001 << port), ®Data); 1727 if(retVal != RT_ERR_OK) 1728 return retVal; 1729 1730 *enabled = regData; 1731 return RT_ERR_OK; 1732} 1733 1734/* Function Name: 1735 * rtl8367c_setAsicIGMPReportLeaveFlood 1736 * Description: 1737 * Set IGMP/MLD Report/Leave flood 1738 * Input: 1739 * flood - 0: Reserved, 1: flooding to router ports, 2: flooding to all ports, 3: flooding to router port or to all ports if there is no router port 1740 * Output: 1741 * None 1742 * Return: 1743 * RT_ERR_OK - Success 1744 * RT_ERR_SMI - SMI access error 1745 * Note: 1746 * None 1747 */ 1748ret_t rtl8367c_setAsicIGMPReportLeaveFlood(rtk_uint32 flood) 1749{ 1750 ret_t retVal; 1751 1752 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG3, RTL8367C_REPORT_LEAVE_FORWARD_MASK, flood); 1753 if(retVal != RT_ERR_OK) 1754 return retVal; 1755 1756 return RT_ERR_OK; 1757} 1758 1759/* Function Name: 1760 * rtl8367c_getAsicIGMPReportLeaveFlood 1761 * Description: 1762 * Get IGMP/MLD Report/Leave flood 1763 * Input: 1764 * None 1765 * Output: 1766 * pflood - 0: Reserved, 1: flooding to router ports, 2: flooding to all ports, 3: flooding to router port or to all ports if there is no router port 1767 * Return: 1768 * RT_ERR_OK - Success 1769 * RT_ERR_SMI - SMI access error 1770 * Note: 1771 * None 1772 */ 1773ret_t rtl8367c_getAsicIGMPReportLeaveFlood(rtk_uint32 *pFlood) 1774{ 1775 ret_t retVal; 1776 rtk_uint32 regData; 1777 1778 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG3, RTL8367C_REPORT_LEAVE_FORWARD_MASK, ®Data); 1779 if(retVal != RT_ERR_OK) 1780 return retVal; 1781 1782 *pFlood = regData; 1783 return RT_ERR_OK; 1784} 1785 1786/* Function Name: 1787 * rtl8367c_setAsicIGMPDropLeaveZero 1788 * Description: 1789 * Set the function of droppping Leave packet with group IP = 0.0.0.0 1790 * Input: 1791 * drop - 1: Drop, 0:Bypass 1792 * Output: 1793 * None 1794 * Return: 1795 * RT_ERR_OK - Success 1796 * RT_ERR_SMI - SMI access error 1797 * Note: 1798 * None 1799 */ 1800ret_t rtl8367c_setAsicIGMPDropLeaveZero(rtk_uint32 drop) 1801{ 1802 ret_t retVal; 1803 1804 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_DROP_LEAVE_ZERO_OFFSET, drop); 1805 if(retVal != RT_ERR_OK) 1806 return retVal; 1807 1808 return RT_ERR_OK; 1809} 1810 1811/* Function Name: 1812 * rtl8367c_getAsicIGMPDropLeaveZero 1813 * Description: 1814 * Get the function of droppping Leave packet with group IP = 0.0.0.0 1815 * Input: 1816 * None 1817 * Output: 1818 * pDrop - 1: Drop, 0:Bypass 1819 * Return: 1820 * RT_ERR_OK - Success 1821 * RT_ERR_SMI - SMI access error 1822 * Note: 1823 * None 1824 */ 1825ret_t rtl8367c_getAsicIGMPDropLeaveZero(rtk_uint32 *pDrop) 1826{ 1827 ret_t retVal; 1828 rtk_uint32 regData; 1829 1830 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_DROP_LEAVE_ZERO_OFFSET, ®Data); 1831 if(retVal != RT_ERR_OK) 1832 return retVal; 1833 1834 *pDrop = regData; 1835 return RT_ERR_OK; 1836} 1837 1838/* Function Name: 1839 * rtl8367c_setAsicIGMPBypassStormCTRL 1840 * Description: 1841 * Set the function of bypass strom control for IGMP/MLD packet 1842 * Input: 1843 * bypass - 1: Bypass, 0:not bypass 1844 * Output: 1845 * None 1846 * Return: 1847 * RT_ERR_OK - Success 1848 * RT_ERR_SMI - SMI access error 1849 * Note: 1850 * None 1851 */ 1852ret_t rtl8367c_setAsicIGMPBypassStormCTRL(rtk_uint32 bypass) 1853{ 1854 ret_t retVal; 1855 1856 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_DISCARD_STORM_FILTER_OFFSET, bypass); 1857 if(retVal != RT_ERR_OK) 1858 return retVal; 1859 1860 return RT_ERR_OK; 1861} 1862 1863/* Function Name: 1864 * rtl8367c_getAsicIGMPBypassStormCTRL 1865 * Description: 1866 * Set the function of bypass strom control for IGMP/MLD packet 1867 * Input: 1868 * None 1869 * Output: 1870 * pBypass - 1: Bypass, 0:not bypass 1871 * Return: 1872 * RT_ERR_OK - Success 1873 * RT_ERR_SMI - SMI access error 1874 * Note: 1875 * None 1876 */ 1877ret_t rtl8367c_getAsicIGMPBypassStormCTRL(rtk_uint32 *pBypass) 1878{ 1879 ret_t retVal; 1880 rtk_uint32 regData; 1881 1882 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_DISCARD_STORM_FILTER_OFFSET, ®Data); 1883 if(retVal != RT_ERR_OK) 1884 return retVal; 1885 1886 *pBypass = regData; 1887 return RT_ERR_OK; 1888} 1889 1890/* Function Name: 1891 * rtl8367c_setAsicIGMPIsoLeaky 1892 * Description: 1893 * Set Port Isolation leaky for IGMP/MLD packet 1894 * Input: 1895 * leaky - 1: Leaky, 0:not leaky 1896 * Output: 1897 * None 1898 * Return: 1899 * RT_ERR_OK - Success 1900 * RT_ERR_SMI - SMI access error 1901 * Note: 1902 * None 1903 */ 1904ret_t rtl8367c_setAsicIGMPIsoLeaky(rtk_uint32 leaky) 1905{ 1906 ret_t retVal; 1907 1908 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_PORTISO_LEAKY_OFFSET, leaky); 1909 if(retVal != RT_ERR_OK) 1910 return retVal; 1911 1912 return RT_ERR_OK; 1913} 1914 1915/* Function Name: 1916 * rtl8367c_getAsicIGMPIsoLeaky 1917 * Description: 1918 * Get Port Isolation leaky for IGMP/MLD packet 1919 * Input: 1920 * Noen 1921 * Output: 1922 * pLeaky - 1: Leaky, 0:not leaky 1923 * Return: 1924 * RT_ERR_OK - Success 1925 * RT_ERR_SMI - SMI access error 1926 * Note: 1927 * None 1928 */ 1929ret_t rtl8367c_getAsicIGMPIsoLeaky(rtk_uint32 *pLeaky) 1930{ 1931 ret_t retVal; 1932 rtk_uint32 regData; 1933 1934 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_PORTISO_LEAKY_OFFSET, ®Data); 1935 if(retVal != RT_ERR_OK) 1936 return retVal; 1937 1938 *pLeaky = regData; 1939 return RT_ERR_OK; 1940} 1941 1942/* Function Name: 1943 * rtl8367c_setAsicIGMPVLANLeaky 1944 * Description: 1945 * Set VLAN leaky for IGMP/MLD packet 1946 * Input: 1947 * leaky - 1: Leaky, 0:not leaky 1948 * Output: 1949 * None 1950 * Return: 1951 * RT_ERR_OK - Success 1952 * RT_ERR_SMI - SMI access error 1953 * Note: 1954 * None 1955 */ 1956ret_t rtl8367c_setAsicIGMPVLANLeaky(rtk_uint32 leaky) 1957{ 1958 ret_t retVal; 1959 1960 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_VLAN_LEAKY_OFFSET, leaky); 1961 if(retVal != RT_ERR_OK) 1962 return retVal; 1963 1964 return RT_ERR_OK; 1965} 1966 1967/* Function Name: 1968 * rtl8367c_getAsicIGMPVLANLeaky 1969 * Description: 1970 * Get VLAN leaky for IGMP/MLD packet 1971 * Input: 1972 * Noen 1973 * Output: 1974 * pLeaky - 1: Leaky, 0:not leaky 1975 * Return: 1976 * RT_ERR_OK - Success 1977 * RT_ERR_SMI - SMI access error 1978 * Note: 1979 * None 1980 */ 1981ret_t rtl8367c_getAsicIGMPVLANLeaky(rtk_uint32 *pLeaky) 1982{ 1983 ret_t retVal; 1984 rtk_uint32 regData; 1985 1986 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_VLAN_LEAKY_OFFSET, ®Data); 1987 if(retVal != RT_ERR_OK) 1988 return retVal; 1989 1990 *pLeaky = regData; 1991 return RT_ERR_OK; 1992} 1993 1994/* Function Name: 1995 * rtl8367c_setAsicIGMPBypassGroup 1996 * Description: 1997 * Set IGMP/MLD Bypass group 1998 * Input: 1999 * bypassType - Bypass type 2000 * enabled - enabled 2001 * Output: 2002 * None 2003 * Return: 2004 * RT_ERR_OK - Success 2005 * RT_ERR_SMI - SMI access error 2006 * Note: 2007 * None 2008 */ 2009ret_t rtl8367c_setAsicIGMPBypassGroup(rtk_uint32 bypassType, rtk_uint32 enabled) 2010{ 2011 ret_t retVal; 2012 rtk_uint32 offset; 2013 2014 switch(bypassType) 2015 { 2016 case BYPASS_224_0_0_X: 2017 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_0_OFFSET; 2018 break; 2019 case BYPASS_224_0_1_X: 2020 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_1_OFFSET; 2021 break; 2022 case BYPASS_239_255_255_X: 2023 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_239_255_255_OFFSET; 2024 break; 2025 case BYPASS_IPV6_00XX: 2026 offset = RTL8367C_IGMP_MLD_IP6_BYPASS_OFFSET; 2027 break; 2028 default: 2029 return RT_ERR_INPUT; 2030 } 2031 2032 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG3, offset, enabled); 2033 if(retVal != RT_ERR_OK) 2034 return retVal; 2035 2036 return RT_ERR_OK; 2037} 2038 2039/* Function Name: 2040 * rtl8367c_getAsicIGMPBypassGroup 2041 * Description: 2042 * Get IGMP/MLD Bypass group 2043 * Input: 2044 * bypassType - Bypass type 2045 * Output: 2046 * pEnabled - enabled 2047 * Return: 2048 * RT_ERR_OK - Success 2049 * RT_ERR_SMI - SMI access error 2050 * Note: 2051 * None 2052 */ 2053ret_t rtl8367c_getAsicIGMPBypassGroup(rtk_uint32 bypassType, rtk_uint32 *pEnabled) 2054{ 2055 ret_t retVal; 2056 rtk_uint32 offset; 2057 2058 switch(bypassType) 2059 { 2060 case BYPASS_224_0_0_X: 2061 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_0_OFFSET; 2062 break; 2063 case BYPASS_224_0_1_X: 2064 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_1_OFFSET; 2065 break; 2066 case BYPASS_239_255_255_X: 2067 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_239_255_255_OFFSET; 2068 break; 2069 case BYPASS_IPV6_00XX: 2070 offset = RTL8367C_IGMP_MLD_IP6_BYPASS_OFFSET; 2071 break; 2072 default: 2073 return RT_ERR_INPUT; 2074 } 2075 2076 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG3, offset, pEnabled); 2077 if(retVal != RT_ERR_OK) 2078 return retVal; 2079 2080 return RT_ERR_OK; 2081} 2082 2083