target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/igmp.c

   1 /*
   2  * Copyright (C) 2013 Realtek Semiconductor Corp.
   3  * All Rights Reserved.
   4  *
   5  * Unless you and Realtek execute a separate written software license
   6  * agreement governing use of this software, this software is licensed
   7  * to you under the terms of the GNU General Public License version 2,
   8  * available at https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
   9  *
  10  * $Revision: 76306 $
  11  * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
  12  *
  13  * Purpose : RTK switch high-level API for RTL8367/RTL8367C
  14  * Feature : Here is a list of all functions and variables in IGMP module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <igmp.h>
  21 #include <string.h>
  22
  23 #include <rtl8367c_asicdrv.h>
  24 #include <rtl8367c_asicdrv_igmp.h>
  25 #include <rtl8367c_asicdrv_lut.h>
  26
  27
  28 /* Function Name:
  29  *      rtk_igmp_init
  30  * Description:
  31  *      This API enables H/W IGMP and set a default initial configuration.
  32  * Input:
  33  *      None.
  34  * Output:
  35  *      None.
  36  * Return:
  37  *      RT_ERR_OK              - OK
  38  *      RT_ERR_FAILED          - Failed
  39  *      RT_ERR_SMI             - SMI access error
  40  * Note:
  41  *      This API enables H/W IGMP and set a default initial configuration.
  42  */
  43 rtk_api_ret_t rtk_igmp_init(void)
  44 {
  45     rtk_api_ret_t retVal;
  46     rtk_port_t port;
  47
  48     /* Check initialization state */
  49     RTK_CHK_INIT_STATE();
  50
  51     if ((retVal = rtl8367c_setAsicLutIpMulticastLookup(ENABLED))!=RT_ERR_OK)
  52         return retVal;
  53
  54     if ((retVal = rtl8367c_setAsicLutIpLookupMethod(1))!=RT_ERR_OK)
  55         return retVal;
  56
  57     RTK_SCAN_ALL_PHY_PORTMASK(port)
  58     {
  59         if ((retVal = rtl8367c_setAsicIGMPv1Opeartion(port, PROTOCOL_OP_ASIC))!=RT_ERR_OK)
  60             return retVal;
  61
  62         if ((retVal = rtl8367c_setAsicIGMPv2Opeartion(port, PROTOCOL_OP_ASIC))!=RT_ERR_OK)
  63             return retVal;
  64
  65         if ((retVal = rtl8367c_setAsicIGMPv3Opeartion(port, PROTOCOL_OP_FLOOD))!=RT_ERR_OK)
  66             return retVal;
  67
  68         if ((retVal = rtl8367c_setAsicMLDv1Opeartion(port, PROTOCOL_OP_ASIC))!=RT_ERR_OK)
  69             return retVal;
  70
  71         if ((retVal = rtl8367c_setAsicMLDv2Opeartion(port, PROTOCOL_OP_FLOOD))!=RT_ERR_OK)
  72             return retVal;
  73     }
  74
  75     if ((retVal = rtl8367c_setAsicIGMPAllowDynamicRouterPort(rtk_switch_phyPortMask_get()))!=RT_ERR_OK)
  76         return retVal;
  77
  78     if ((retVal = rtl8367c_setAsicIGMPFastLeaveEn(ENABLED))!=RT_ERR_OK)
  79         return retVal;
  80
  81     if ((retVal = rtl8367c_setAsicIGMPReportLeaveFlood(1))!=RT_ERR_OK)
  82         return retVal;
  83
  84     if ((retVal = rtl8367c_setAsicIgmp(ENABLED))!=RT_ERR_OK)
  85         return retVal;
  86
  87     return RT_ERR_OK;
  88 }
  89
  90 /* Function Name:
  91  *      rtk_igmp_state_set
  92  * Description:
  93  *      This API set H/W IGMP state.
  94  * Input:
  95  *      enabled     - H/W IGMP state
  96  * Output:
  97  *      None.
  98  * Return:
  99  *      RT_ERR_OK              - OK
 100  *      RT_ERR_FAILED          - Failed
 101  *      RT_ERR_SMI             - SMI access error
 102  *      RT_ERR_INPUT           - Error parameter
 103  * Note:
 104  *      This API set H/W IGMP state.
 105  */
 106 rtk_api_ret_t rtk_igmp_state_set(rtk_enable_t enabled)
 107 {
 108     rtk_api_ret_t retVal;
 109
 110     /* Check initialization state */
 111     RTK_CHK_INIT_STATE();
 112
 113     if (enabled >= RTK_ENABLE_END)
 114         return RT_ERR_INPUT;
 115
 116     if ((retVal = rtl8367c_setAsicIgmp(enabled))!=RT_ERR_OK)
 117         return retVal;
 118
 119     return RT_ERR_OK;
 120 }
 121
 122 /* Function Name:
 123  *      rtk_igmp_state_get
 124  * Description:
 125  *      This API get H/W IGMP state.
 126  * Input:
 127  *      None.
 128  * Output:
 129  *      pEnabled        - H/W IGMP state
 130  * Return:
 131  *      RT_ERR_OK              - OK
 132  *      RT_ERR_FAILED          - Failed
 133  *      RT_ERR_SMI             - SMI access error
 134  *      RT_ERR_INPUT           - Error parameter
 135  * Note:
 136  *      This API set current H/W IGMP state.
 137  */
 138 rtk_api_ret_t rtk_igmp_state_get(rtk_enable_t *pEnabled)
 139 {
 140     rtk_api_ret_t retVal;
 141
 142     /* Check initialization state */
 143     RTK_CHK_INIT_STATE();
 144
 145     if(pEnabled == NULL)
 146         return RT_ERR_NULL_POINTER;
 147
 148     if ((retVal = rtl8367c_getAsicIgmp(pEnabled))!=RT_ERR_OK)
 149         return retVal;
 150
 151     return RT_ERR_OK;
 152 }
 153
 154 /* Function Name:
 155  *      rtk_igmp_static_router_port_set
 156  * Description:
 157  *      Configure static router port
 158  * Input:
 159  *      pPortmask    - Static Port mask
 160  * Output:
 161  *      None.
 162  * Return:
 163  *      RT_ERR_OK              - OK
 164  *      RT_ERR_FAILED          - Failed
 165  *      RT_ERR_SMI             - SMI access error
 166  *      RT_ERR_PORT_MASK       - Error parameter
 167  * Note:
 168  *      This API set static router port
 169  */
 170 rtk_api_ret_t rtk_igmp_static_router_port_set(rtk_portmask_t *pPortmask)
 171 {
 172     rtk_api_ret_t retVal;
 173     rtk_uint32 pmask;
 174
 175     /* Check initialization state */
 176     RTK_CHK_INIT_STATE();
 177
 178     /* Check Valid port mask */
 179     if(pPortmask == NULL)
 180         return RT_ERR_NULL_POINTER;
 181
 182     RTK_CHK_PORTMASK_VALID(pPortmask);
 183
 184     if ((retVal = rtk_switch_portmask_L2P_get(pPortmask, &pmask))!=RT_ERR_OK)
 185         return retVal;
 186
 187     if ((retVal = rtl8367c_setAsicIGMPStaticRouterPort(pmask))!=RT_ERR_OK)
 188         return retVal;
 189
 190     return RT_ERR_OK;
 191 }
 192
 193 /* Function Name:
 194  *      rtk_igmp_static_router_port_get
 195  * Description:
 196  *      Get static router port
 197  * Input:
 198  *      None.
 199  * Output:
 200  *      pPortmask       - Static port mask
 201  * Return:
 202  *      RT_ERR_OK              - OK
 203  *      RT_ERR_FAILED          - Failed
 204  *      RT_ERR_SMI             - SMI access error
 205  *      RT_ERR_PORT_MASK       - Error parameter
 206  * Note:
 207  *      This API get static router port
 208  */
 209 rtk_api_ret_t rtk_igmp_static_router_port_get(rtk_portmask_t *pPortmask)
 210 {
 211     rtk_api_ret_t retVal;
 212     rtk_uint32 pmask;
 213
 214     /* Check initialization state */
 215     RTK_CHK_INIT_STATE();
 216
 217     if(pPortmask == NULL)
 218         return RT_ERR_NULL_POINTER;
 219
 220     if ((retVal = rtl8367c_getAsicIGMPStaticRouterPort(&pmask))!=RT_ERR_OK)
 221         return retVal;
 222
 223     if ((retVal = rtk_switch_portmask_P2L_get(pmask, pPortmask))!=RT_ERR_OK)
 224         return retVal;
 225
 226     return RT_ERR_OK;
 227 }
 228
 229 /* Function Name:
 230  *      rtk_igmp_protocol_set
 231  * Description:
 232  *      set IGMP/MLD protocol action
 233  * Input:
 234  *      port        - Port ID
 235  *      protocol    - IGMP/MLD protocol
 236  *      action      - Per-port and per-protocol IGMP action seeting
 237  * Output:
 238  *      None.
 239  * Return:
 240  *      RT_ERR_OK              - OK
 241  *      RT_ERR_FAILED          - Failed
 242  *      RT_ERR_SMI             - SMI access error
 243  *      RT_ERR_PORT_MASK       - Error parameter
 244  * Note:
 245  *      This API set IGMP/MLD protocol action
 246  */
 247 rtk_api_ret_t rtk_igmp_protocol_set(rtk_port_t port, rtk_igmp_protocol_t protocol, rtk_igmp_action_t action)
 248 {
 249     rtk_uint32      operation;
 250     rtk_api_ret_t   retVal;
 251
 252     /* Check initialization state */
 253     RTK_CHK_INIT_STATE();
 254
 255     /* Check port valid */
 256     RTK_CHK_PORT_VALID(port);
 257
 258     if(protocol >= PROTOCOL_END)
 259         return RT_ERR_INPUT;
 260
 261     if(action >= IGMP_ACTION_END)
 262         return RT_ERR_INPUT;
 263
 264     switch(action)
 265     {
 266         case IGMP_ACTION_FORWARD:
 267             operation = PROTOCOL_OP_FLOOD;
 268             break;
 269         case IGMP_ACTION_TRAP2CPU:
 270             operation = PROTOCOL_OP_TRAP;
 271             break;
 272         case IGMP_ACTION_DROP:
 273             operation = PROTOCOL_OP_DROP;
 274             break;
 275         case IGMP_ACTION_ASIC:
 276             operation = PROTOCOL_OP_ASIC;
 277             break;
 278         default:
 279             return RT_ERR_INPUT;
 280     }
 281
 282     switch(protocol)
 283     {
 284         case PROTOCOL_IGMPv1:
 285             if ((retVal = rtl8367c_setAsicIGMPv1Opeartion(rtk_switch_port_L2P_get(port), operation))!=RT_ERR_OK)
 286                 return retVal;
 287
 288             break;
 289         case PROTOCOL_IGMPv2:
 290             if ((retVal = rtl8367c_setAsicIGMPv2Opeartion(rtk_switch_port_L2P_get(port), operation))!=RT_ERR_OK)
 291                 return retVal;
 292
 293             break;
 294         case PROTOCOL_IGMPv3:
 295             if ((retVal = rtl8367c_setAsicIGMPv3Opeartion(rtk_switch_port_L2P_get(port), operation))!=RT_ERR_OK)
 296                 return retVal;
 297
 298             break;
 299         case PROTOCOL_MLDv1:
 300             if ((retVal = rtl8367c_setAsicMLDv1Opeartion(rtk_switch_port_L2P_get(port), operation))!=RT_ERR_OK)
 301                 return retVal;
 302
 303             break;
 304         case PROTOCOL_MLDv2:
 305             if ((retVal = rtl8367c_setAsicMLDv2Opeartion(rtk_switch_port_L2P_get(port), operation))!=RT_ERR_OK)
 306                 return retVal;
 307
 308             break;
 309         default:
 310             return RT_ERR_INPUT;
 311
 312     }
 313
 314     return RT_ERR_OK;
 315 }
 316
 317 /* Function Name:
 318  *      rtk_igmp_protocol_get
 319  * Description:
 320  *      set IGMP/MLD protocol action
 321  * Input:
 322  *      port        - Port ID
 323  *      protocol    - IGMP/MLD protocol
 324  *      action      - Per-port and per-protocol IGMP action seeting
 325  * Output:
 326  *      None.
 327  * Return:
 328  *      RT_ERR_OK              - OK
 329  *      RT_ERR_FAILED          - Failed
 330  *      RT_ERR_SMI             - SMI access error
 331  *      RT_ERR_PORT_MASK       - Error parameter
 332  * Note:
 333  *      This API set IGMP/MLD protocol action
 334  */
 335 rtk_api_ret_t rtk_igmp_protocol_get(rtk_port_t port, rtk_igmp_protocol_t protocol, rtk_igmp_action_t *pAction)
 336 {
 337     rtk_uint32      operation;
 338     rtk_api_ret_t   retVal;
 339
 340     /* Check initialization state */
 341     RTK_CHK_INIT_STATE();
 342
 343     /* Check port valid */
 344     RTK_CHK_PORT_VALID(port);
 345
 346     if(protocol >= PROTOCOL_END)
 347         return RT_ERR_INPUT;
 348
 349     if(pAction == NULL)
 350         return RT_ERR_NULL_POINTER;
 351
 352     switch(protocol)
 353     {
 354         case PROTOCOL_IGMPv1:
 355             if ((retVal = rtl8367c_getAsicIGMPv1Opeartion(rtk_switch_port_L2P_get(port), &operation))!=RT_ERR_OK)
 356                 return retVal;
 357
 358             break;
 359         case PROTOCOL_IGMPv2:
 360             if ((retVal = rtl8367c_getAsicIGMPv2Opeartion(rtk_switch_port_L2P_get(port), &operation))!=RT_ERR_OK)
 361                 return retVal;
 362
 363             break;
 364         case PROTOCOL_IGMPv3:
 365             if ((retVal = rtl8367c_getAsicIGMPv3Opeartion(rtk_switch_port_L2P_get(port), &operation))!=RT_ERR_OK)
 366                 return retVal;
 367
 368             break;
 369         case PROTOCOL_MLDv1:
 370             if ((retVal = rtl8367c_getAsicMLDv1Opeartion(rtk_switch_port_L2P_get(port), &operation))!=RT_ERR_OK)
 371                 return retVal;
 372
 373             break;
 374         case PROTOCOL_MLDv2:
 375             if ((retVal = rtl8367c_getAsicMLDv2Opeartion(rtk_switch_port_L2P_get(port), &operation))!=RT_ERR_OK)
 376                 return retVal;
 377
 378             break;
 379         default:
 380             return RT_ERR_INPUT;
 381
 382     }
 383
 384     switch(operation)
 385     {
 386         case PROTOCOL_OP_FLOOD:
 387             *pAction = IGMP_ACTION_FORWARD;
 388             break;
 389         case PROTOCOL_OP_TRAP:
 390             *pAction = IGMP_ACTION_TRAP2CPU;
 391             break;
 392         case PROTOCOL_OP_DROP:
 393             *pAction = IGMP_ACTION_DROP;
 394             break;
 395         case PROTOCOL_OP_ASIC:
 396             *pAction = IGMP_ACTION_ASIC;
 397             break;
 398         default:
 399             return RT_ERR_FAILED;
 400     }
 401
 402     return RT_ERR_OK;
 403 }
 404
 405 /* Function Name:
 406  *      rtk_igmp_fastLeave_set
 407  * Description:
 408  *      set IGMP/MLD FastLeave state
 409  * Input:
 410  *      state       - ENABLED: Enable FastLeave, DISABLED: disable FastLeave
 411  * Output:
 412  *      None.
 413  * Return:
 414  *      RT_ERR_OK              - OK
 415  *      RT_ERR_INPUT           - Error Input
 416  *      RT_ERR_FAILED          - Failed
 417  *      RT_ERR_SMI             - SMI access error
 418  * Note:
 419  *      This API set IGMP/MLD FastLeave state
 420  */
 421 rtk_api_ret_t rtk_igmp_fastLeave_set(rtk_enable_t state)
 422 {
 423     rtk_api_ret_t   retVal;
 424
 425     /* Check initialization state */
 426     RTK_CHK_INIT_STATE();
 427
 428     if(state >= RTK_ENABLE_END)
 429         return RT_ERR_INPUT;
 430
 431     if ((retVal = rtl8367c_setAsicIGMPFastLeaveEn((rtk_uint32)state))!=RT_ERR_OK)
 432         return retVal;
 433
 434     return RT_ERR_OK;
 435 }
 436
 437 /* Function Name:
 438  *      rtk_igmp_fastLeave_get
 439  * Description:
 440  *      get IGMP/MLD FastLeave state
 441  * Input:
 442  *      None
 443  * Output:
 444  *      pState      - ENABLED: Enable FastLeave, DISABLED: disable FastLeave
 445  * Return:
 446  *      RT_ERR_OK              - OK
 447  *      RT_ERR_NULL_POINTER    - NULL pointer
 448  *      RT_ERR_FAILED          - Failed
 449  *      RT_ERR_SMI             - SMI access error
 450  * Note:
 451  *      This API get IGMP/MLD FastLeave state
 452  */
 453 rtk_api_ret_t rtk_igmp_fastLeave_get(rtk_enable_t *pState)
 454 {
 455     rtk_uint32      fast_leave;
 456     rtk_api_ret_t   retVal;
 457
 458     /* Check initialization state */
 459     RTK_CHK_INIT_STATE();
 460
 461     if(pState == NULL)
 462         return RT_ERR_NULL_POINTER;
 463
 464     if ((retVal = rtl8367c_getAsicIGMPFastLeaveEn(&fast_leave))!=RT_ERR_OK)
 465         return retVal;
 466
 467     *pState = ((fast_leave == 1) ? ENABLED : DISABLED);
 468     return RT_ERR_OK;
 469 }
 470
 471 /* Function Name:
 472  *      rtk_igmp_maxGroup_set
 473  * Description:
 474  *      Set per port multicast group learning limit.
 475  * Input:
 476  *      port        - Port ID
 477  *      group       - The number of multicast group learning limit.
 478  * Output:
 479  *      None.
 480  * Return:
 481  *      RT_ERR_OK              - OK
 482  *      RT_ERR_PORT_ID         - Error Port ID
 483  *      RT_ERR_OUT_OF_RANGE    - parameter out of range
 484  *      RT_ERR_FAILED          - Failed
 485  *      RT_ERR_SMI             - SMI access error
 486  * Note:
 487  *      This API set per port multicast group learning limit.
 488  */
 489 rtk_api_ret_t rtk_igmp_maxGroup_set(rtk_port_t port, rtk_uint32 group)
 490 {
 491     rtk_api_ret_t   retVal;
 492
 493     /* Check initialization state */
 494     RTK_CHK_INIT_STATE();
 495
 496     /* Check port valid */
 497     RTK_CHK_PORT_VALID(port);
 498
 499     if(group > RTL8367C_IGMP_MAX_GOUP)
 500         return RT_ERR_OUT_OF_RANGE;
 501
 502     if ((retVal = rtl8367c_setAsicIGMPPortMAXGroup(rtk_switch_port_L2P_get(port), group))!=RT_ERR_OK)
 503         return retVal;
 504
 505     return RT_ERR_OK;
 506 }
 507
 508 /* Function Name:
 509  *      rtk_igmp_maxGroup_get
 510  * Description:
 511  *      Get per port multicast group learning limit.
 512  * Input:
 513  *      port        - Port ID
 514  * Output:
 515  *      pGroup      - The number of multicast group learning limit.
 516  * Return:
 517  *      RT_ERR_OK              - OK
 518  *      RT_ERR_PORT_ID         - Error Port ID
 519  *      RT_ERR_NULL_POINTER    - Null pointer
 520  *      RT_ERR_FAILED          - Failed
 521  *      RT_ERR_SMI             - SMI access error
 522  * Note:
 523  *      This API get per port multicast group learning limit.
 524  */
 525 rtk_api_ret_t rtk_igmp_maxGroup_get(rtk_port_t port, rtk_uint32 *pGroup)
 526 {
 527     rtk_api_ret_t   retVal;
 528
 529     /* Check initialization state */
 530     RTK_CHK_INIT_STATE();
 531
 532     /* Check port valid */
 533     RTK_CHK_PORT_VALID(port);
 534
 535     if(pGroup == NULL)
 536         return RT_ERR_NULL_POINTER;
 537
 538     if ((retVal = rtl8367c_getAsicIGMPPortMAXGroup(rtk_switch_port_L2P_get(port), pGroup))!=RT_ERR_OK)
 539         return retVal;
 540
 541     return RT_ERR_OK;
 542 }
 543
 544 /* Function Name:
 545  *      rtk_igmp_currentGroup_get
 546  * Description:
 547  *      Get per port multicast group learning count.
 548  * Input:
 549  *      port        - Port ID
 550  * Output:
 551  *      pGroup      - The number of multicast group learning count.
 552  * Return:
 553  *      RT_ERR_OK              - OK
 554  *      RT_ERR_PORT_ID         - Error Port ID
 555  *      RT_ERR_NULL_POINTER    - Null pointer
 556  *      RT_ERR_FAILED          - Failed
 557  *      RT_ERR_SMI             - SMI access error
 558  * Note:
 559  *      This API get per port multicast group learning count.
 560  */
 561 rtk_api_ret_t rtk_igmp_currentGroup_get(rtk_port_t port, rtk_uint32 *pGroup)
 562 {
 563     rtk_api_ret_t   retVal;
 564
 565     /* Check initialization state */
 566     RTK_CHK_INIT_STATE();
 567
 568     /* Check port valid */
 569     RTK_CHK_PORT_VALID(port);
 570
 571     if(pGroup == NULL)
 572         return RT_ERR_NULL_POINTER;
 573
 574     if ((retVal = rtl8367c_getAsicIGMPPortCurrentGroup(rtk_switch_port_L2P_get(port), pGroup))!=RT_ERR_OK)
 575         return retVal;
 576
 577     return RT_ERR_OK;
 578 }
 579
 580 /* Function Name:
 581  *      rtk_igmp_tableFullAction_set
 582  * Description:
 583  *      set IGMP/MLD Table Full Action
 584  * Input:
 585  *      action      - Table Full Action
 586  * Output:
 587  *      None.
 588  * Return:
 589  *      RT_ERR_OK              - OK
 590  *      RT_ERR_INPUT           - Error Input
 591  *      RT_ERR_FAILED          - Failed
 592  *      RT_ERR_SMI             - SMI access error
 593  * Note:
 594  */
 595 rtk_api_ret_t rtk_igmp_tableFullAction_set(rtk_igmp_tableFullAction_t action)
 596 {
 597     rtk_api_ret_t   retVal;
 598
 599     /* Check initialization state */
 600     RTK_CHK_INIT_STATE();
 601
 602     if(action >= IGMP_TABLE_FULL_OP_END)
 603         return RT_ERR_INPUT;
 604
 605     if ((retVal = rtl8367c_setAsicIGMPTableFullOP((rtk_uint32)action))!=RT_ERR_OK)
 606         return retVal;
 607
 608     return RT_ERR_OK;
 609 }
 610
 611 /* Function Name:
 612  *      rtk_igmp_tableFullAction_get
 613  * Description:
 614  *      get IGMP/MLD Table Full Action
 615  * Input:
 616  *      None
 617  * Output:
 618  *      pAction     - Table Full Action
 619  * Return:
 620  *      RT_ERR_OK              - OK
 621  *      RT_ERR_NULL_POINTER    - Null pointer
 622  *      RT_ERR_FAILED          - Failed
 623  *      RT_ERR_SMI             - SMI access error
 624  * Note:
 625  */
 626 rtk_api_ret_t rtk_igmp_tableFullAction_get(rtk_igmp_tableFullAction_t *pAction)
 627 {
 628     rtk_api_ret_t   retVal;
 629
 630     /* Check initialization state */
 631     RTK_CHK_INIT_STATE();
 632
 633     if(NULL == pAction)
 634         return RT_ERR_NULL_POINTER;
 635
 636     if ((retVal = rtl8367c_getAsicIGMPTableFullOP((rtk_uint32 *)pAction))!=RT_ERR_OK)
 637         return retVal;
 638
 639     return RT_ERR_OK;
 640 }
 641
 642 /* Function Name:
 643  *      rtk_igmp_checksumErrorAction_set
 644  * Description:
 645  *      set IGMP/MLD Checksum Error Action
 646  * Input:
 647  *      action      - Checksum error Action
 648  * Output:
 649  *      None.
 650  * Return:
 651  *      RT_ERR_OK              - OK
 652  *      RT_ERR_INPUT           - Error Input
 653  *      RT_ERR_FAILED          - Failed
 654  *      RT_ERR_SMI             - SMI access error
 655  * Note:
 656  */
 657 rtk_api_ret_t rtk_igmp_checksumErrorAction_set(rtk_igmp_checksumErrorAction_t action)
 658 {
 659     rtk_api_ret_t   retVal;
 660
 661     /* Check initialization state */
 662     RTK_CHK_INIT_STATE();
 663
 664     if(action >= IGMP_CRC_ERR_OP_END)
 665         return RT_ERR_INPUT;
 666
 667     if ((retVal = rtl8367c_setAsicIGMPCRCErrOP((rtk_uint32)action))!=RT_ERR_OK)
 668         return retVal;
 669
 670     return RT_ERR_OK;
 671 }
 672
 673
 674 /* Function Name:
 675  *      rtk_igmp_checksumErrorAction_get
 676  * Description:
 677  *      get IGMP/MLD Checksum Error Action
 678  * Input:
 679  *      None
 680  * Output:
 681  *      pAction     - Checksum error Action
 682  * Return:
 683  *      RT_ERR_OK              - OK
 684  *      RT_ERR_NULL_POINTER    - Null pointer
 685  *      RT_ERR_FAILED          - Failed
 686  *      RT_ERR_SMI             - SMI access error
 687  * Note:
 688  */
 689 rtk_api_ret_t rtk_igmp_checksumErrorAction_get(rtk_igmp_checksumErrorAction_t *pAction)
 690 {
 691     rtk_api_ret_t   retVal;
 692
 693     /* Check initialization state */
 694     RTK_CHK_INIT_STATE();
 695
 696     if(NULL == pAction)
 697         return RT_ERR_NULL_POINTER;
 698
 699     if ((retVal = rtl8367c_getAsicIGMPCRCErrOP((rtk_uint32 *)pAction))!=RT_ERR_OK)
 700         return retVal;
 701
 702     return RT_ERR_OK;
 703 }
 704
 705 /* Function Name:
 706  *      rtk_igmp_leaveTimer_set
 707  * Description:
 708  *      set IGMP/MLD Leave timer
 709  * Input:
 710  *      timer       - Leave timer
 711  * Output:
 712  *      None.
 713  * Return:
 714  *      RT_ERR_OK              - OK
 715  *      RT_ERR_INPUT           - Error Input
 716  *      RT_ERR_FAILED          - Failed
 717  *      RT_ERR_SMI             - SMI access error
 718  * Note:
 719  */
 720 rtk_api_ret_t rtk_igmp_leaveTimer_set(rtk_uint32 timer)
 721 {
 722     rtk_api_ret_t   retVal;
 723
 724     /* Check initialization state */
 725     RTK_CHK_INIT_STATE();
 726
 727     if(timer > RTL8367C_MAX_LEAVE_TIMER)
 728         return RT_ERR_INPUT;
 729
 730     if ((retVal = rtl8367c_setAsicIGMPLeaveTimer(timer))!=RT_ERR_OK)
 731         return retVal;
 732
 733     return RT_ERR_OK;
 734 }
 735
 736 /* Function Name:
 737  *      rtk_igmp_leaveTimer_get
 738  * Description:
 739  *      get IGMP/MLD Leave timer
 740  * Input:
 741  *      None
 742  * Output:
 743  *      pTimer      - Leave Timer.
 744  * Return:
 745  *      RT_ERR_OK              - OK
 746  *      RT_ERR_NULL_POINTER    - Null pointer
 747  *      RT_ERR_FAILED          - Failed
 748  *      RT_ERR_SMI             - SMI access error
 749  * Note:
 750  */
 751 rtk_api_ret_t rtk_igmp_leaveTimer_get(rtk_uint32 *pTimer)
 752 {
 753     rtk_api_ret_t   retVal;
 754
 755     /* Check initialization state */
 756     RTK_CHK_INIT_STATE();
 757
 758     if(NULL == pTimer)
 759         return RT_ERR_NULL_POINTER;
 760
 761     if ((retVal = rtl8367c_getAsicIGMPLeaveTimer(pTimer))!=RT_ERR_OK)
 762         return retVal;
 763
 764     return RT_ERR_OK;
 765 }
 766
 767 /* Function Name:
 768  *      rtk_igmp_queryInterval_set
 769  * Description:
 770  *      set IGMP/MLD Query Interval
 771  * Input:
 772  *      interval     - Query Interval
 773  * Output:
 774  *      None.
 775  * Return:
 776  *      RT_ERR_OK              - OK
 777  *      RT_ERR_INPUT           - Error Input
 778  *      RT_ERR_FAILED          - Failed
 779  *      RT_ERR_SMI             - SMI access error
 780  * Note:
 781  */
 782 rtk_api_ret_t rtk_igmp_queryInterval_set(rtk_uint32 interval)
 783 {
 784     rtk_api_ret_t   retVal;
 785
 786     /* Check initialization state */
 787     RTK_CHK_INIT_STATE();
 788
 789     if(interval > RTL8367C_MAX_QUERY_INT)
 790         return RT_ERR_INPUT;
 791
 792     if ((retVal = rtl8367c_setAsicIGMPQueryInterval(interval))!=RT_ERR_OK)
 793         return retVal;
 794
 795     return RT_ERR_OK;
 796 }
 797
 798 /* Function Name:
 799  *      rtk_igmp_queryInterval_get
 800  * Description:
 801  *      get IGMP/MLD Query Interval
 802  * Input:
 803  *      None.
 804  * Output:
 805  *      pInterval   - Query Interval
 806  * Return:
 807  *      RT_ERR_OK              - OK
 808  *      RT_ERR_NULL_POINTER    - Null pointer
 809  *      RT_ERR_FAILED          - Failed
 810  *      RT_ERR_SMI             - SMI access error
 811  * Note:
 812  */
 813 rtk_api_ret_t rtk_igmp_queryInterval_get(rtk_uint32 *pInterval)
 814 {
 815     rtk_api_ret_t   retVal;
 816
 817     /* Check initialization state */
 818     RTK_CHK_INIT_STATE();
 819
 820     if(NULL == pInterval)
 821         return RT_ERR_NULL_POINTER;
 822
 823     if ((retVal = rtl8367c_getAsicIGMPQueryInterval(pInterval))!=RT_ERR_OK)
 824         return retVal;
 825
 826     return RT_ERR_OK;
 827 }
 828
 829 /* Function Name:
 830  *      rtk_igmp_robustness_set
 831  * Description:
 832  *      set IGMP/MLD Robustness value
 833  * Input:
 834  *      robustness     - Robustness value
 835  * Output:
 836  *      None.
 837  * Return:
 838  *      RT_ERR_OK              - OK
 839  *      RT_ERR_INPUT           - Error Input
 840  *      RT_ERR_FAILED          - Failed
 841  *      RT_ERR_SMI             - SMI access error
 842  * Note:
 843  */
 844 rtk_api_ret_t rtk_igmp_robustness_set(rtk_uint32 robustness)
 845 {
 846     rtk_api_ret_t   retVal;
 847
 848     /* Check initialization state */
 849     RTK_CHK_INIT_STATE();
 850
 851     if(robustness > RTL8367C_MAX_ROB_VAR)
 852         return RT_ERR_INPUT;
 853
 854     if ((retVal = rtl8367c_setAsicIGMPRobVar(robustness))!=RT_ERR_OK)
 855         return retVal;
 856
 857     return RT_ERR_OK;
 858 }
 859
 860 /* Function Name:
 861  *      rtk_igmp_robustness_get
 862  * Description:
 863  *      get IGMP/MLD Robustness value
 864  * Input:
 865  *      None
 866  * Output:
 867  *      pRobustness     - Robustness value.
 868  * Return:
 869  *      RT_ERR_OK              - OK
 870  *      RT_ERR_NULL_POINTER    - Null pointer
 871  *      RT_ERR_FAILED          - Failed
 872  *      RT_ERR_SMI             - SMI access error
 873  * Note:
 874  */
 875 rtk_api_ret_t rtk_igmp_robustness_get(rtk_uint32 *pRobustness)
 876 {
 877     rtk_api_ret_t   retVal;
 878
 879     /* Check initialization state */
 880     RTK_CHK_INIT_STATE();
 881
 882     if(NULL == pRobustness)
 883         return RT_ERR_NULL_POINTER;
 884
 885     if ((retVal = rtl8367c_getAsicIGMPRobVar(pRobustness))!=RT_ERR_OK)
 886         return retVal;
 887
 888     return RT_ERR_OK;
 889 }
 890
 891 /* Function Name:
 892  *      rtk_igmp_dynamicRouterRortAllow_set
 893  * Description:
 894  *      Configure dynamic router port allow option
 895  * Input:
 896  *      pPortmask    - Dynamic Port allow mask
 897  * Output:
 898  *      None.
 899  * Return:
 900  *      RT_ERR_OK              - OK
 901  *      RT_ERR_FAILED          - Failed
 902  *      RT_ERR_SMI             - SMI access error
 903  *      RT_ERR_PORT_MASK       - Error parameter
 904  * Note:
 905  *
 906  */
 907 rtk_api_ret_t rtk_igmp_dynamicRouterPortAllow_set(rtk_portmask_t *pPortmask)
 908 {
 909     rtk_api_ret_t   retVal;
 910     rtk_uint32 pmask;
 911
 912     /* Check initialization state */
 913     RTK_CHK_INIT_STATE();
 914
 915     if(NULL == pPortmask)
 916         return RT_ERR_NULL_POINTER;
 917
 918     RTK_CHK_PORTMASK_VALID(pPortmask);
 919
 920     if ((retVal = rtk_switch_portmask_L2P_get(pPortmask, &pmask))!=RT_ERR_OK)
 921         return retVal;
 922
 923     if ((retVal = rtl8367c_setAsicIGMPAllowDynamicRouterPort(pmask))!=RT_ERR_OK)
 924         return retVal;
 925
 926     return RT_ERR_OK;
 927 }
 928
 929 /* Function Name:
 930  *      rtk_igmp_dynamicRouterRortAllow_get
 931  * Description:
 932  *      Get dynamic router port allow option
 933  * Input:
 934  *      None.
 935  * Output:
 936  *      pPortmask    - Dynamic Port allow mask
 937  * Return:
 938  *      RT_ERR_OK              - OK
 939  *      RT_ERR_FAILED          - Failed
 940  *      RT_ERR_NULL_POINTER    - Null pointer
 941  *      RT_ERR_SMI             - SMI access error
 942  *      RT_ERR_PORT_MASK       - Error parameter
 943  * Note:
 944  *
 945  */
 946 rtk_api_ret_t rtk_igmp_dynamicRouterPortAllow_get(rtk_portmask_t *pPortmask)
 947 {
 948     rtk_api_ret_t   retVal;
 949     rtk_uint32 pmask;
 950
 951     /* Check initialization state */
 952     RTK_CHK_INIT_STATE();
 953
 954     if(NULL == pPortmask)
 955         return RT_ERR_NULL_POINTER;
 956
 957     if ((retVal = rtl8367c_getAsicIGMPAllowDynamicRouterPort(&pmask))!=RT_ERR_OK)
 958         return retVal;
 959
 960     if ((retVal = rtk_switch_portmask_P2L_get(pmask, pPortmask))!=RT_ERR_OK)
 961         return retVal;
 962
 963     return RT_ERR_OK;
 964 }
 965
 966 /* Function Name:
 967  *      rtk_igmp_dynamicRouterPort_get
 968  * Description:
 969  *      Get dynamic router port
 970  * Input:
 971  *      None.
 972  * Output:
 973  *      pDynamicRouterPort    - Dynamic Router Port
 974  * Return:
 975  *      RT_ERR_OK              - OK
 976  *      RT_ERR_FAILED          - Failed
 977  *      RT_ERR_NULL_POINTER    - Null pointer
 978  *      RT_ERR_SMI             - SMI access error
 979  *      RT_ERR_PORT_MASK       - Error parameter
 980  * Note:
 981  *
 982  */
 983 rtk_api_ret_t rtk_igmp_dynamicRouterPort_get(rtk_igmp_dynamicRouterPort_t *pDynamicRouterPort)
 984 {
 985     rtk_api_ret_t   retVal;
 986     rtk_uint32 port;
 987     rtk_uint32 timer;
 988
 989     /* Check initialization state */
 990     RTK_CHK_INIT_STATE();
 991
 992     if(NULL == pDynamicRouterPort)
 993         return RT_ERR_NULL_POINTER;
 994
 995     if ((retVal = rtl8367c_getAsicIGMPdynamicRouterPort1(&port, &timer))!= RT_ERR_OK)
 996         return retVal;
 997
 998     if (port == RTL8367C_ROUTER_PORT_INVALID)
 999     {
1000         pDynamicRouterPort->dynamicRouterPort0Valid = DISABLED;
1001         pDynamicRouterPort->dynamicRouterPort0      = 0;
1002         pDynamicRouterPort->dynamicRouterPort0Timer = 0;
1003     }
1004     else
1005     {
1006         pDynamicRouterPort->dynamicRouterPort0Valid = ENABLED;
1007         pDynamicRouterPort->dynamicRouterPort0      = rtk_switch_port_P2L_get(port);
1008         pDynamicRouterPort->dynamicRouterPort0Timer = timer;
1009     }
1010
1011     if ((retVal = rtl8367c_getAsicIGMPdynamicRouterPort2(&port, &timer))!= RT_ERR_OK)
1012         return retVal;
1013
1014     if (port == RTL8367C_ROUTER_PORT_INVALID)
1015     {
1016         pDynamicRouterPort->dynamicRouterPort1Valid = DISABLED;
1017         pDynamicRouterPort->dynamicRouterPort1      = 0;
1018         pDynamicRouterPort->dynamicRouterPort1Timer = 0;
1019     }
1020     else
1021     {
1022         pDynamicRouterPort->dynamicRouterPort1Valid = ENABLED;
1023         pDynamicRouterPort->dynamicRouterPort1      = rtk_switch_port_P2L_get(port);
1024         pDynamicRouterPort->dynamicRouterPort1Timer = timer;
1025     }
1026
1027     return RT_ERR_OK;
1028 }
1029
1030 /* Function Name:
1031  *      rtk_igmp_suppressionEnable_set
1032  * Description:
1033  *      Configure IGMPv1/v2 & MLDv1 Report/Leave/Done suppression
1034  * Input:
1035  *      reportSuppression   - Report suppression
1036  *      leaveSuppression    - Leave suppression
1037  * Output:
1038  *      None.
1039  * Return:
1040  *      RT_ERR_OK              - OK
1041  *      RT_ERR_FAILED          - Failed
1042  *      RT_ERR_SMI             - SMI access error
1043  *      RT_ERR_INPUT           - Error Input
1044  * Note:
1045  *
1046  */
1047 rtk_api_ret_t rtk_igmp_suppressionEnable_set(rtk_enable_t reportSuppression, rtk_enable_t leaveSuppression)
1048 {
1049     rtk_api_ret_t   retVal;
1050
1051     /* Check initialization state */
1052     RTK_CHK_INIT_STATE();
1053
1054     if(reportSuppression >= RTK_ENABLE_END)
1055         return RT_ERR_INPUT;
1056
1057     if(leaveSuppression >= RTK_ENABLE_END)
1058         return RT_ERR_INPUT;
1059
1060     if ((retVal = rtl8367c_setAsicIGMPSuppression((rtk_uint32)reportSuppression, (rtk_uint32)leaveSuppression))!=RT_ERR_OK)
1061         return retVal;
1062
1063     return RT_ERR_OK;
1064 }
1065
1066 /* Function Name:
1067  *      rtk_igmp_suppressionEnable_get
1068  * Description:
1069  *      Get IGMPv1/v2 & MLDv1 Report/Leave/Done suppression
1070  * Input:
1071  *      None
1072  * Output:
1073  *      pReportSuppression  - Report suppression
1074  *      pLeaveSuppression   - Leave suppression
1075  * Return:
1076  *      RT_ERR_OK              - OK
1077  *      RT_ERR_FAILED          - Failed
1078  *      RT_ERR_SMI             - SMI access error
1079  *      RT_ERR_NULL_POINTER    - Null pointer
1080  * Note:
1081  *
1082  */
1083 rtk_api_ret_t rtk_igmp_suppressionEnable_get(rtk_enable_t *pReportSuppression, rtk_enable_t *pLeaveSuppression)
1084 {
1085     rtk_api_ret_t   retVal;
1086
1087     /* Check initialization state */
1088     RTK_CHK_INIT_STATE();
1089
1090     if(NULL == pReportSuppression)
1091         return RT_ERR_NULL_POINTER;
1092
1093     if(NULL == pLeaveSuppression)
1094         return RT_ERR_NULL_POINTER;
1095
1096     if ((retVal = rtl8367c_getAsicIGMPSuppression((rtk_uint32 *)pReportSuppression, (rtk_uint32 *)pLeaveSuppression))!=RT_ERR_OK)
1097         return retVal;
1098
1099     return RT_ERR_OK;
1100 }
1101
1102 /* Function Name:
1103  *      rtk_igmp_portRxPktEnable_set
1104  * Description:
1105  *      Configure IGMP/MLD RX Packet configuration
1106  * Input:
1107  *      port       - Port ID
1108  *      pRxCfg     - RX Packet Configuration
1109  * Output:
1110  *      None.
1111  * Return:
1112  *      RT_ERR_OK              - OK
1113  *      RT_ERR_FAILED          - Failed
1114  *      RT_ERR_SMI             - SMI access error
1115  *      RT_ERR_INPUT           - Error Input
1116  *      RT_ERR_NULL_POINTER    - Null pointer
1117  * Note:
1118  *
1119  */
1120 rtk_api_ret_t rtk_igmp_portRxPktEnable_set(rtk_port_t port, rtk_igmp_rxPktEnable_t *pRxCfg)
1121 {
1122     rtk_api_ret_t   retVal;
1123
1124     /* Check initialization state */
1125     RTK_CHK_INIT_STATE();
1126
1127     /* Check port valid */
1128     RTK_CHK_PORT_VALID(port);
1129
1130     if(NULL == pRxCfg)
1131         return RT_ERR_NULL_POINTER;
1132
1133     if(pRxCfg->rxQuery >= RTK_ENABLE_END)
1134         return RT_ERR_INPUT;
1135
1136     if(pRxCfg->rxReport >= RTK_ENABLE_END)
1137         return RT_ERR_INPUT;
1138
1139     if(pRxCfg->rxLeave >= RTK_ENABLE_END)
1140         return RT_ERR_INPUT;
1141
1142     if(pRxCfg->rxMRP >= RTK_ENABLE_END)
1143         return RT_ERR_INPUT;
1144
1145     if(pRxCfg->rxMcast >= RTK_ENABLE_END)
1146         return RT_ERR_INPUT;
1147
1148     if ((retVal = rtl8367c_setAsicIGMPQueryRX(rtk_switch_port_L2P_get(port), (rtk_uint32)pRxCfg->rxQuery))!=RT_ERR_OK)
1149         return retVal;
1150
1151     if ((retVal = rtl8367c_setAsicIGMPReportRX(rtk_switch_port_L2P_get(port), (rtk_uint32)pRxCfg->rxReport))!=RT_ERR_OK)
1152         return retVal;
1153
1154     if ((retVal = rtl8367c_setAsicIGMPLeaveRX(rtk_switch_port_L2P_get(port), (rtk_uint32)pRxCfg->rxLeave))!=RT_ERR_OK)
1155         return retVal;
1156
1157     if ((retVal = rtl8367c_setAsicIGMPMRPRX(rtk_switch_port_L2P_get(port), (rtk_uint32)pRxCfg->rxMRP))!=RT_ERR_OK)
1158         return retVal;
1159
1160     if ((retVal = rtl8367c_setAsicIGMPMcDataRX(rtk_switch_port_L2P_get(port), (rtk_uint32)pRxCfg->rxMcast))!=RT_ERR_OK)
1161         return retVal;
1162
1163     return RT_ERR_OK;
1164 }
1165
1166 /* Function Name:
1167  *      rtk_igmp_portRxPktEnable_get
1168  * Description:
1169  *      Get IGMP/MLD RX Packet configuration
1170  * Input:
1171  *      port       - Port ID
1172  *      pRxCfg     - RX Packet Configuration
1173  * Output:
1174  *      None.
1175  * Return:
1176  *      RT_ERR_OK              - OK
1177  *      RT_ERR_FAILED          - Failed
1178  *      RT_ERR_SMI             - SMI access error
1179  *      RT_ERR_INPUT           - Error Input
1180  *      RT_ERR_NULL_POINTER    - Null pointer
1181  * Note:
1182  *
1183  */
1184 rtk_api_ret_t rtk_igmp_portRxPktEnable_get(rtk_port_t port, rtk_igmp_rxPktEnable_t *pRxCfg)
1185 {
1186     rtk_api_ret_t   retVal;
1187
1188     /* Check initialization state */
1189     RTK_CHK_INIT_STATE();
1190
1191     /* Check port valid */
1192     RTK_CHK_PORT_VALID(port);
1193
1194     if(NULL == pRxCfg)
1195         return RT_ERR_NULL_POINTER;
1196
1197     if ((retVal = rtl8367c_getAsicIGMPQueryRX(rtk_switch_port_L2P_get(port), (rtk_uint32 *)&(pRxCfg->rxQuery)))!=RT_ERR_OK)
1198         return retVal;
1199
1200     if ((retVal = rtl8367c_getAsicIGMPReportRX(rtk_switch_port_L2P_get(port), (rtk_uint32 *)&(pRxCfg->rxReport)))!=RT_ERR_OK)
1201         return retVal;
1202
1203     if ((retVal = rtl8367c_getAsicIGMPLeaveRX(rtk_switch_port_L2P_get(port), (rtk_uint32 *)&(pRxCfg->rxLeave)))!=RT_ERR_OK)
1204         return retVal;
1205
1206     if ((retVal = rtl8367c_getAsicIGMPMRPRX(rtk_switch_port_L2P_get(port), (rtk_uint32 *)&(pRxCfg->rxMRP)))!=RT_ERR_OK)
1207         return retVal;
1208
1209     if ((retVal = rtl8367c_getAsicIGMPMcDataRX(rtk_switch_port_L2P_get(port), (rtk_uint32 *)&(pRxCfg->rxMcast)))!=RT_ERR_OK)
1210         return retVal;
1211
1212     return RT_ERR_OK;
1213 }
1214
1215 /* Function Name:
1216  *      rtk_igmp_groupInfo_get
1217  * Description:
1218  *      Get IGMP/MLD Group database
1219  * Input:
1220  *      indes       - Index (0~255)
1221  * Output:
1222  *      pGroup      - Group database information.
1223  * Return:
1224  *      RT_ERR_OK              - OK
1225  *      RT_ERR_FAILED          - Failed
1226  *      RT_ERR_SMI             - SMI access error
1227  *      RT_ERR_INPUT           - Error Input
1228  *      RT_ERR_NULL_POINTER    - Null pointer
1229  * Note:
1230  *
1231  */
1232 rtk_api_ret_t rtk_igmp_groupInfo_get(rtk_uint32 index, rtk_igmp_groupInfo_t *pGroup)
1233 {
1234     rtk_api_ret_t   retVal;
1235     rtk_uint32      valid;
1236     rtl8367c_igmpgroup  grp;
1237
1238     /* Check initialization state */
1239     RTK_CHK_INIT_STATE();
1240
1241     /* Check index */
1242     if(index > RTL8367C_IGMP_MAX_GOUP)
1243         return RT_ERR_INPUT;
1244
1245     if(NULL == pGroup)
1246         return RT_ERR_NULL_POINTER;
1247
1248     if ((retVal = rtl8367c_getAsicIGMPGroup(index, &valid, &grp))!=RT_ERR_OK)
1249         return retVal;
1250
1251     memset(pGroup, 0x00, sizeof(rtk_igmp_groupInfo_t));
1252     pGroup->valid = valid;
1253     pGroup->reportSuppFlag = grp.report_supp_flag;
1254
1255     if(grp.p0_timer != 0)
1256     {
1257         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(0));
1258         pGroup->timer[rtk_switch_port_P2L_get(0)] = grp.p0_timer;
1259     }
1260
1261     if(grp.p1_timer != 0)
1262     {
1263         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(1));
1264         pGroup->timer[rtk_switch_port_P2L_get(1)] = grp.p1_timer;
1265     }
1266
1267     if(grp.p2_timer != 0)
1268     {
1269         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(2));
1270         pGroup->timer[rtk_switch_port_P2L_get(2)] = grp.p2_timer;
1271     }
1272
1273     if(grp.p3_timer != 0)
1274     {
1275         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(3));
1276         pGroup->timer[rtk_switch_port_P2L_get(3)] = grp.p3_timer;
1277     }
1278
1279     if(grp.p4_timer != 0)
1280     {
1281         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(4));
1282         pGroup->timer[rtk_switch_port_P2L_get(4)] = grp.p4_timer;
1283     }
1284
1285     if(grp.p5_timer != 0)
1286     {
1287         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(5));
1288         pGroup->timer[rtk_switch_port_P2L_get(5)] = grp.p5_timer;
1289     }
1290
1291     if(grp.p6_timer != 0)
1292     {
1293         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(6));
1294         pGroup->timer[rtk_switch_port_P2L_get(6)] = grp.p6_timer;
1295     }
1296
1297     if(grp.p7_timer != 0)
1298     {
1299         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(7));
1300         pGroup->timer[rtk_switch_port_P2L_get(7)] = grp.p7_timer;
1301     }
1302
1303     if(grp.p8_timer != 0)
1304     {
1305         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(8));
1306         pGroup->timer[rtk_switch_port_P2L_get(8)] = grp.p8_timer;
1307     }
1308
1309     if(grp.p9_timer != 0)
1310     {
1311         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(9));
1312         pGroup->timer[rtk_switch_port_P2L_get(9)] = grp.p9_timer;
1313     }
1314
1315     if(grp.p10_timer != 0)
1316     {
1317         RTK_PORTMASK_PORT_SET((pGroup->member), rtk_switch_port_P2L_get(10));
1318         pGroup->timer[rtk_switch_port_P2L_get(10)] = grp.p10_timer;
1319     }
1320
1321     return RT_ERR_OK;
1322 }
1323
1324 /* Function Name:
1325  *      rtk_igmp_ReportLeaveFwdAction_set
1326  * Description:
1327  *      Set Report Leave packet forwarding action
1328  * Input:
1329  *      action      - Action
1330  * Output:
1331  *      None.
1332  * Return:
1333  *      RT_ERR_OK              - OK
1334  *      RT_ERR_FAILED          - Failed
1335  *      RT_ERR_SMI             - SMI access error
1336  *      RT_ERR_INPUT           - Error Input
1337  * Note:
1338  *
1339  */
1340 rtk_api_ret_t rtk_igmp_ReportLeaveFwdAction_set(rtk_igmp_ReportLeaveFwdAct_t action)
1341 {
1342     rtk_api_ret_t   retVal;
1343     rtk_uint32      regData;
1344
1345     /* Check initialization state */
1346     RTK_CHK_INIT_STATE();
1347
1348     switch(action)
1349     {
1350         case IGMP_REPORT_LEAVE_TO_ROUTER:
1351             regData = 1;
1352             break;
1353         case IGMP_REPORT_LEAVE_TO_ALLPORT:
1354             regData = 2;
1355             break;
1356         case IGMP_REPORT_LEAVE_TO_ROUTER_PORT_ADV:
1357             regData = 3;
1358             break;
1359         default:
1360             return RT_ERR_INPUT;
1361     }
1362
1363     if ((retVal = rtl8367c_setAsicIGMPReportLeaveFlood(regData))!=RT_ERR_OK)
1364         return retVal;
1365
1366     return RT_ERR_OK;
1367 }
1368
1369 /* Function Name:
1370  *      rtk_igmp_ReportLeaveFwdAction_get
1371  * Description:
1372  *      Get Report Leave packet forwarding action
1373  * Input:
1374  *      action      - Action
1375  * Output:
1376  *      None.
1377  * Return:
1378  *      RT_ERR_OK              - OK
1379  *      RT_ERR_FAILED          - Failed
1380  *      RT_ERR_SMI             - SMI access error
1381  *      RT_ERR_INPUT           - Error Input
1382  *      RT_ERR_NULL_POINTER    - Null Pointer
1383  * Note:
1384  *
1385  */
1386 rtk_api_ret_t rtk_igmp_ReportLeaveFwdAction_get(rtk_igmp_ReportLeaveFwdAct_t *pAction)
1387 {
1388     rtk_api_ret_t   retVal;
1389     rtk_uint32      regData;
1390
1391     /* Check initialization state */
1392     RTK_CHK_INIT_STATE();
1393
1394     if(NULL == pAction)
1395         return RT_ERR_NULL_POINTER;
1396
1397     if ((retVal = rtl8367c_getAsicIGMPReportLeaveFlood(&regData))!=RT_ERR_OK)
1398         return retVal;
1399
1400     switch(regData)
1401     {
1402         case 1:
1403             *pAction = IGMP_REPORT_LEAVE_TO_ROUTER;
1404             break;
1405         case 2:
1406             *pAction = IGMP_REPORT_LEAVE_TO_ALLPORT;
1407             break;
1408         case 3:
1409             *pAction = IGMP_REPORT_LEAVE_TO_ROUTER_PORT_ADV;
1410             break;
1411         default:
1412             return RT_ERR_FAILED;
1413     }
1414
1415     return RT_ERR_OK;
1416 }
1417
1418 /* Function Name:
1419  *      rtk_igmp_dropLeaveZeroEnable_set
1420  * Description:
1421  *      Set the function of droppping Leave packet with group IP = 0.0.0.0
1422  * Input:
1423  *      enabled      - Action 1: drop, 0:pass
1424  * Output:
1425  *      None.
1426  * Return:
1427  *      RT_ERR_OK              - OK
1428  *      RT_ERR_FAILED          - Failed
1429  *      RT_ERR_SMI             - SMI access error
1430  *      RT_ERR_INPUT           - Error Input
1431  * Note:
1432  *
1433  */
1434 rtk_api_ret_t rtk_igmp_dropLeaveZeroEnable_set(rtk_enable_t enabled)
1435 {
1436     rtk_api_ret_t   retVal;
1437
1438     /* Check initialization state */
1439     RTK_CHK_INIT_STATE();
1440
1441     if(enabled >= RTK_ENABLE_END)
1442         return RT_ERR_INPUT;
1443
1444     if ((retVal = rtl8367c_setAsicIGMPDropLeaveZero(enabled))!=RT_ERR_OK)
1445         return retVal;
1446
1447     return RT_ERR_OK;
1448
1449 }
1450
1451 /* Function Name:
1452  *      rtk_igmp_dropLeaveZeroEnable_get
1453  * Description:
1454  *      Get the function of droppping Leave packet with group IP = 0.0.0.0
1455  * Input:
1456  *      None
1457  * Output:
1458  *      pEnabled.   - Action 1: drop, 0:pass
1459  * Return:
1460  *      RT_ERR_OK              - OK
1461  *      RT_ERR_FAILED          - Failed
1462  *      RT_ERR_SMI             - SMI access error
1463  *      RT_ERR_INPUT           - Error Input
1464  *      RT_ERR_NULL_POINTER    - Null Pointer
1465  * Note:
1466  *
1467  */
1468 rtk_api_ret_t rtk_igmp_dropLeaveZeroEnable_get(rtk_enable_t *pEnabled)
1469 {
1470     rtk_api_ret_t   retVal;
1471
1472     /* Check initialization state */
1473     RTK_CHK_INIT_STATE();
1474
1475     if(NULL == pEnabled)
1476         return RT_ERR_NULL_POINTER;
1477
1478     if ((retVal = rtl8367c_getAsicIGMPDropLeaveZero((rtk_uint32 *)pEnabled))!=RT_ERR_OK)
1479         return retVal;
1480
1481     return RT_ERR_OK;
1482
1483 }
1484
1485 /* Function Name:
1486  *      rtk_igmp_bypassGroupRange_set
1487  * Description:
1488  *      Set Bypass group
1489  * Input:
1490  *      group       - bypassed group
1491  *      enabled     - enabled 1: Bypassed, 0: not bypass
1492  * Output:
1493  *      None.
1494  * Return:
1495  *      RT_ERR_OK              - OK
1496  *      RT_ERR_FAILED          - Failed
1497  *      RT_ERR_SMI             - SMI access error
1498  *      RT_ERR_INPUT           - Error Input
1499  * Note:
1500  *
1501  */
1502 rtk_api_ret_t rtk_igmp_bypassGroupRange_set(rtk_igmp_bypassGroup_t group, rtk_enable_t enabled)
1503 {
1504     rtk_api_ret_t   retVal;
1505
1506     /* Check initialization state */
1507     RTK_CHK_INIT_STATE();
1508
1509     if(group >= IGMP_BYPASS_GROUP_END)
1510         return RT_ERR_INPUT;
1511
1512     if(enabled >= RTK_ENABLE_END)
1513         return RT_ERR_INPUT;
1514
1515     if ((retVal = rtl8367c_setAsicIGMPBypassGroup(group, enabled))!=RT_ERR_OK)
1516         return retVal;
1517
1518     return RT_ERR_OK;
1519 }
1520
1521 /* Function Name:
1522  *      rtk_igmp_bypassGroupRange_get
1523  * Description:
1524  *      get Bypass group
1525  * Input:
1526  *      group       - bypassed group
1527  * Output:
1528  *      pEnable     - enabled 1: Bypassed, 0: not bypass
1529  * Return:
1530  *      RT_ERR_OK              - OK
1531  *      RT_ERR_FAILED          - Failed
1532  *      RT_ERR_SMI             - SMI access error
1533  *      RT_ERR_INPUT           - Error Input
1534  *      RT_ERR_NULL_POINTER    - Null Pointer
1535  * Note:
1536  *
1537  */
1538 rtk_api_ret_t rtk_igmp_bypassGroupRange_get(rtk_igmp_bypassGroup_t group, rtk_enable_t *pEnable)
1539 {
1540     rtk_api_ret_t   retVal;
1541
1542     /* Check initialization state */
1543     RTK_CHK_INIT_STATE();
1544
1545     if(group >= IGMP_BYPASS_GROUP_END)
1546         return RT_ERR_INPUT;
1547
1548     if(NULL == pEnable)
1549         return RT_ERR_NULL_POINTER;
1550
1551     if ((retVal = rtl8367c_getAsicIGMPBypassGroup(group, pEnable))!=RT_ERR_OK)
1552         return retVal;
1553
1554     return RT_ERR_OK;
1555 }