target/linux/mediatek/files/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_qos.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 : RTL8367C switch high-level API for RTL8367C
  14  * Feature : QoS related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_qos.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicPriorityDot1qRemapping
  21  * Description:
  22  *      Set 802.1Q absolutely priority
  23  * Input:
  24  *      srcpriority - Priority value
  25  *      priority     - Absolute priority value
  26  * Output:
  27  *      None
  28  * Return:
  29  *      RT_ERR_OK                 - Success
  30  *      RT_ERR_SMI              - SMI access error
  31  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
  32  * Note:
  33  *      None
  34  */
  35 ret_t rtl8367c_setAsicPriorityDot1qRemapping(rtk_uint32 srcpriority, rtk_uint32 priority )
  36 {
  37     if((srcpriority > RTL8367C_PRIMAX) || (priority > RTL8367C_PRIMAX))
  38         return RT_ERR_QOS_INT_PRIORITY;
  39
  40     return rtl8367c_setAsicRegBits(RTL8367C_QOS_1Q_PRIORITY_REMAPPING_REG(srcpriority), RTL8367C_QOS_1Q_PRIORITY_REMAPPING_MASK(srcpriority),priority);
  41 }
  42 /* Function Name:
  43  *      rtl8367c_getAsicPriorityDot1qRemapping
  44  * Description:
  45  *      Get 802.1Q absolutely priority
  46  * Input:
  47  *      srcpriority - Priority value
  48  *      pPriority     - Absolute priority value
  49  * Output:
  50  *      None
  51  * Return:
  52  *      RT_ERR_OK     - Success
  53  *      RT_ERR_SMI  - SMI access error
  54  * Note:
  55  *      None
  56  */
  57 ret_t rtl8367c_getAsicPriorityDot1qRemapping(rtk_uint32 srcpriority, rtk_uint32 *pPriority )
  58 {
  59     if(srcpriority > RTL8367C_PRIMAX )
  60         return RT_ERR_QOS_INT_PRIORITY;
  61
  62     return rtl8367c_getAsicRegBits(RTL8367C_QOS_1Q_PRIORITY_REMAPPING_REG(srcpriority), RTL8367C_QOS_1Q_PRIORITY_REMAPPING_MASK(srcpriority), pPriority);
  63 }
  64 /* Function Name:
  65  *      rtl8367c_setAsicPriorityPortBased
  66  * Description:
  67  *      Set port based priority
  68  * Input:
  69  *      port         - Physical port number (0~7)
  70  *      priority     - Priority value
  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  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
  78  * Note:
  79  *      None
  80  */
  81 ret_t rtl8367c_setAsicPriorityPortBased(rtk_uint32 port, rtk_uint32 priority )
  82 {
  83     ret_t retVal;
  84
  85     if(port > RTL8367C_PORTIDMAX)
  86         return RT_ERR_PORT_ID;
  87
  88     if(priority > RTL8367C_PRIMAX )
  89         return RT_ERR_QOS_INT_PRIORITY;
  90
  91     if(port < 8)
  92     {
  93         retVal = rtl8367c_setAsicRegBits(RTL8367C_QOS_PORTBASED_PRIORITY_REG(port), RTL8367C_QOS_PORTBASED_PRIORITY_MASK(port), priority);
  94         if(retVal != RT_ERR_OK)
  95             return retVal;
  96     }
  97     else
  98     {
  99         retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_QOS_PORTBASED_PRIORITY_CTRL2, 0x7 << ((port - 8) << 2), priority);
 100         if(retVal != RT_ERR_OK)
 101             return retVal;
 102     }
 103
 104     return RT_ERR_OK;
 105 }
 106 /* Function Name:
 107  *      rtl8367c_getAsicPriorityPortBased
 108  * Description:
 109  *      Get port based priority
 110  * Input:
 111  *      port         - Physical port number (0~7)
 112  *      pPriority     - Priority value
 113  * Output:
 114  *      None
 115  * Return:
 116  *      RT_ERR_OK         - Success
 117  *      RT_ERR_SMI      - SMI access error
 118  *      RT_ERR_PORT_ID  - Invalid port number
 119  * Note:
 120  *      None
 121  */
 122 ret_t rtl8367c_getAsicPriorityPortBased(rtk_uint32 port, rtk_uint32 *pPriority )
 123 {
 124     ret_t retVal;
 125
 126     if(port > RTL8367C_PORTIDMAX)
 127         return RT_ERR_PORT_ID;
 128
 129     if(port < 8)
 130     {
 131         retVal = rtl8367c_getAsicRegBits(RTL8367C_QOS_PORTBASED_PRIORITY_REG(port), RTL8367C_QOS_PORTBASED_PRIORITY_MASK(port), pPriority);
 132         if(retVal != RT_ERR_OK)
 133             return retVal;
 134     }
 135     else
 136     {
 137         retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_QOS_PORTBASED_PRIORITY_CTRL2, 0x7 << ((port - 8) << 2), pPriority);
 138         if(retVal != RT_ERR_OK)
 139             return retVal;
 140     }
 141
 142     return RT_ERR_OK;
 143 }
 144 /* Function Name:
 145  *      rtl8367c_setAsicPriorityDscpBased
 146  * Description:
 147  *      Set DSCP-based priority
 148  * Input:
 149  *      dscp         - DSCP value
 150  *      priority     - Priority value
 151  * Output:
 152  *      None
 153  * Return:
 154  *      RT_ERR_OK                 - Success
 155  *      RT_ERR_SMI              - SMI access error
 156  *      RT_ERR_QOS_DSCP_VALUE    - Invalid DSCP value
 157  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
 158  * Note:
 159  *      None
 160  */
 161 ret_t rtl8367c_setAsicPriorityDscpBased(rtk_uint32 dscp, rtk_uint32 priority )
 162 {
 163     if(priority > RTL8367C_PRIMAX )
 164         return RT_ERR_QOS_INT_PRIORITY;
 165
 166     if(dscp > RTL8367C_DSCPMAX)
 167         return RT_ERR_QOS_DSCP_VALUE;
 168
 169     return rtl8367c_setAsicRegBits(RTL8367C_QOS_DSCP_TO_PRIORITY_REG(dscp), RTL8367C_QOS_DSCP_TO_PRIORITY_MASK(dscp), priority);
 170 }
 171 /* Function Name:
 172  *      rtl8367c_getAsicPriorityDscpBased
 173  * Description:
 174  *      Get DSCP-based priority
 175  * Input:
 176  *      dscp         - DSCP value
 177  *      pPriority     - Priority value
 178  * Output:
 179  *      None
 180  * Return:
 181  *      RT_ERR_OK                 - Success
 182  *      RT_ERR_SMI              - SMI access error
 183  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
 184  * Note:
 185  *      None
 186  */
 187 ret_t rtl8367c_getAsicPriorityDscpBased(rtk_uint32 dscp, rtk_uint32 *pPriority )
 188 {
 189     if(dscp > RTL8367C_DSCPMAX)
 190         return RT_ERR_QOS_DSCP_VALUE;
 191
 192     return rtl8367c_getAsicRegBits(RTL8367C_QOS_DSCP_TO_PRIORITY_REG(dscp), RTL8367C_QOS_DSCP_TO_PRIORITY_MASK(dscp), pPriority);
 193 }
 194 /* Function Name:
 195  *      rtl8367c_setAsicPriorityDecision
 196  * Description:
 197  *      Set priority decision table
 198  * Input:
 199  *      prisrc         - Priority decision source
 200  *      decisionPri - Decision priority assignment
 201  * Output:
 202  *      None
 203  * Return:
 204  *      RT_ERR_OK                     - Success
 205  *      RT_ERR_SMI                  - SMI access error
 206  *      RT_ERR_QOS_INT_PRIORITY        - Invalid priority
 207  *      RT_ERR_QOS_SEL_PRI_SOURCE    - Invalid priority decision source parameter
 208  * Note:
 209  *      None
 210  */
 211 ret_t rtl8367c_setAsicPriorityDecision(rtk_uint32 index, rtk_uint32 prisrc, rtk_uint32 decisionPri)
 212 {
 213     ret_t retVal;
 214
 215     if(index >= PRIDEC_IDX_END )
 216         return RT_ERR_ENTRY_INDEX;
 217
 218     if(prisrc >= PRIDEC_END )
 219         return RT_ERR_QOS_SEL_PRI_SOURCE;
 220
 221     if(decisionPri > RTL8367C_DECISIONPRIMAX )
 222         return RT_ERR_QOS_INT_PRIORITY;
 223
 224     switch(index)
 225     {
 226         case PRIDEC_IDX0:
 227             if((retVal = rtl8367c_setAsicRegBits(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_REG(prisrc), RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_MASK(prisrc), decisionPri))!=  RT_ERR_OK)
 228                 return retVal;
 229             break;
 230         case PRIDEC_IDX1:
 231             if((retVal = rtl8367c_setAsicRegBits(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION2_REG(prisrc), RTL8367C_QOS_INTERNAL_PRIORITY_DECISION2_MASK(prisrc), decisionPri))!=  RT_ERR_OK)
 232                 return retVal;
 233             break;
 234         default:
 235             break;
 236     };
 237
 238     return RT_ERR_OK;
 239
 240
 241 }
 242
 243 /* Function Name:
 244  *      rtl8367c_getAsicPriorityDecision
 245  * Description:
 246  *      Get priority decision table
 247  * Input:
 248  *      prisrc         - Priority decision source
 249  *      pDecisionPri - Decision priority assignment
 250  * Output:
 251  *      None
 252  * Return:
 253  *      RT_ERR_OK                     - Success
 254  *      RT_ERR_SMI                  - SMI access error
 255  *      RT_ERR_QOS_SEL_PRI_SOURCE    - Invalid priority decision source parameter
 256  * Note:
 257  *      None
 258  */
 259 ret_t rtl8367c_getAsicPriorityDecision(rtk_uint32 index, rtk_uint32 prisrc, rtk_uint32* pDecisionPri)
 260 {
 261     ret_t retVal;
 262
 263     if(index >= PRIDEC_IDX_END )
 264         return RT_ERR_ENTRY_INDEX;
 265
 266     if(prisrc >= PRIDEC_END )
 267         return RT_ERR_QOS_SEL_PRI_SOURCE;
 268
 269     switch(index)
 270     {
 271         case PRIDEC_IDX0:
 272             if((retVal = rtl8367c_getAsicRegBits(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_REG(prisrc), RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_MASK(prisrc), pDecisionPri))!=  RT_ERR_OK)
 273                 return retVal;
 274             break;
 275         case PRIDEC_IDX1:
 276             if((retVal = rtl8367c_getAsicRegBits(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION2_REG(prisrc), RTL8367C_QOS_INTERNAL_PRIORITY_DECISION2_MASK(prisrc), pDecisionPri))!=  RT_ERR_OK)
 277                 return retVal;
 278             break;
 279         default:
 280             break;
 281     };
 282
 283     return RT_ERR_OK;
 284
 285 }
 286
 287 /* Function Name:
 288  *      rtl8367c_setAsicPortPriorityDecisionIndex
 289  * Description:
 290  *      Set priority decision index for each port
 291  * Input:
 292  *      port     - Physical port number (0~7)
 293  *      index     - Table index
 294  * Output:
 295  *      None
 296  * Return:
 297  *      RT_ERR_OK             - Success
 298  *      RT_ERR_SMI          - SMI access error
 299  *      RT_ERR_PORT_ID      - Invalid port number
 300  *      RT_ERR_QUEUE_NUM      - Invalid queue number
 301  * Note:
 302  *      None
 303  */
 304 ret_t rtl8367c_setAsicPortPriorityDecisionIndex(rtk_uint32 port, rtk_uint32 index )
 305 {
 306     if(port > RTL8367C_PORTIDMAX)
 307         return RT_ERR_PORT_ID;
 308
 309     if(index >= PRIDEC_IDX_END)
 310         return RT_ERR_ENTRY_INDEX;
 311
 312     return rtl8367c_setAsicRegBit(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_IDX_CTRL, port, index);
 313 }
 314 /* Function Name:
 315  *      rtl8367c_getAsicPortPriorityDecisionIndex
 316  * Description:
 317  *      Get priority decision index  for each port
 318  * Input:
 319  *      port     - Physical port number (0~7)
 320  *      pIndex     - Table index
 321  * Output:
 322  *      None
 323  * Return:
 324  *      RT_ERR_OK             - Success
 325  *      RT_ERR_SMI          - SMI access error
 326  *      RT_ERR_PORT_ID      - Invalid port number
 327  * Note:
 328  *      None
 329  */
 330 ret_t rtl8367c_getAsicPortPriorityDecisionIndex(rtk_uint32 port, rtk_uint32 *pIndex )
 331 {
 332     if(port > RTL8367C_PORTIDMAX)
 333         return RT_ERR_PORT_ID;
 334
 335     return rtl8367c_getAsicRegBit(RTL8367C_QOS_INTERNAL_PRIORITY_DECISION_IDX_CTRL, port, pIndex);
 336 }
 337
 338 /* Function Name:
 339  *      rtl8367c_setAsicOutputQueueMappingIndex
 340  * Description:
 341  *      Set output queue number for each port
 342  * Input:
 343  *      port     - Physical port number (0~7)
 344  *      index     - Mapping table index
 345  * Output:
 346  *      None
 347  * Return:
 348  *      RT_ERR_OK             - Success
 349  *      RT_ERR_SMI          - SMI access error
 350  *      RT_ERR_PORT_ID      - Invalid port number
 351  *      RT_ERR_QUEUE_NUM      - Invalid queue number
 352  * Note:
 353  *      None
 354  */
 355 ret_t rtl8367c_setAsicOutputQueueMappingIndex(rtk_uint32 port, rtk_uint32 index )
 356 {
 357     if(port > RTL8367C_PORTIDMAX)
 358         return RT_ERR_PORT_ID;
 359
 360     if(index >= RTL8367C_QUEUENO)
 361         return RT_ERR_QUEUE_NUM;
 362
 363     return rtl8367c_setAsicRegBits(RTL8367C_QOS_PORT_QUEUE_NUMBER_REG(port), RTL8367C_QOS_PORT_QUEUE_NUMBER_MASK(port), index);
 364 }
 365 /* Function Name:
 366  *      rtl8367c_getAsicOutputQueueMappingIndex
 367  * Description:
 368  *      Get output queue number for each port
 369  * Input:
 370  *      port     - Physical port number (0~7)
 371  *      pIndex     - Mapping table index
 372  * Output:
 373  *      None
 374  * Return:
 375  *      RT_ERR_OK             - Success
 376  *      RT_ERR_SMI          - SMI access error
 377  *      RT_ERR_PORT_ID      - Invalid port number
 378  * Note:
 379  *      None
 380  */
 381 ret_t rtl8367c_getAsicOutputQueueMappingIndex(rtk_uint32 port, rtk_uint32 *pIndex )
 382 {
 383     if(port > RTL8367C_PORTIDMAX)
 384         return RT_ERR_PORT_ID;
 385
 386     return rtl8367c_getAsicRegBits(RTL8367C_QOS_PORT_QUEUE_NUMBER_REG(port), RTL8367C_QOS_PORT_QUEUE_NUMBER_MASK(port), pIndex);
 387 }
 388 /* Function Name:
 389  *      rtl8367c_setAsicPriorityToQIDMappingTable
 390  * Description:
 391  *      Set priority to QID mapping table parameters
 392  * Input:
 393  *      index         - Mapping table index
 394  *      priority     - The priority value
 395  *      qid         - Queue id
 396  * Output:
 397  *      None
 398  * Return:
 399  *      RT_ERR_OK                 - Success
 400  *      RT_ERR_SMI              - SMI access error
 401  *      RT_ERR_QUEUE_ID          - Invalid queue id
 402  *      RT_ERR_QUEUE_NUM          - Invalid queue number
 403  *      RT_ERR_QOS_INT_PRIORITY - Invalid priority
 404  * Note:
 405  *      None
 406  */
 407 ret_t rtl8367c_setAsicPriorityToQIDMappingTable(rtk_uint32 index, rtk_uint32 priority, rtk_uint32 qid )
 408 {
 409     if(index >= RTL8367C_QUEUENO)
 410         return RT_ERR_QUEUE_NUM;
 411
 412     if(priority > RTL8367C_PRIMAX)
 413         return RT_ERR_QOS_INT_PRIORITY;
 414
 415     if(qid > RTL8367C_QIDMAX)
 416         return RT_ERR_QUEUE_ID;
 417
 418     return rtl8367c_setAsicRegBits(RTL8367C_QOS_1Q_PRIORITY_TO_QID_REG(index, priority), RTL8367C_QOS_1Q_PRIORITY_TO_QID_MASK(priority), qid);
 419 }
 420 /* Function Name:
 421  *      rtl8367c_getAsicPriorityToQIDMappingTable
 422  * Description:
 423  *      Get priority to QID mapping table parameters
 424  * Input:
 425  *      index         - Mapping table index
 426  *      priority     - The priority value
 427  *      pQid         - Queue id
 428  * Output:
 429  *      None
 430  * Return:
 431  *      RT_ERR_OK                 - Success
 432  *      RT_ERR_SMI              - SMI access error
 433  *      RT_ERR_QUEUE_NUM          - Invalid queue number
 434  *      RT_ERR_QOS_INT_PRIORITY - Invalid priority
 435  * Note:
 436  *      None
 437  */
 438 ret_t rtl8367c_getAsicPriorityToQIDMappingTable(rtk_uint32 index, rtk_uint32 priority, rtk_uint32* pQid)
 439 {
 440     if(index >= RTL8367C_QUEUENO)
 441         return RT_ERR_QUEUE_NUM;
 442
 443     if(priority > RTL8367C_PRIMAX)
 444         return RT_ERR_QOS_INT_PRIORITY;
 445
 446     return rtl8367c_getAsicRegBits(RTL8367C_QOS_1Q_PRIORITY_TO_QID_REG(index, priority), RTL8367C_QOS_1Q_PRIORITY_TO_QID_MASK(priority), pQid);
 447 }
 448 /* Function Name:
 449  *      rtl8367c_setAsicRemarkingDot1pAbility
 450  * Description:
 451  *      Set 802.1p remarking ability
 452  * Input:
 453  *      port     - Physical port number (0~7)
 454  *      enabled - 1: enabled, 0: disabled
 455  * Output:
 456  *      None
 457  * Return:
 458  *      RT_ERR_OK             - Success
 459  *      RT_ERR_SMI          - SMI access error
 460  *      RT_ERR_PORT_ID      - Invalid port number
 461  * Note:
 462  *      None
 463  */
 464 ret_t rtl8367c_setAsicRemarkingDot1pAbility(rtk_uint32 port, rtk_uint32 enabled)
 465 {
 466     return rtl8367c_setAsicRegBit(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_1QREMARK_ENABLE_OFFSET, enabled);
 467 }
 468 /* Function Name:
 469  *      rtl8367c_getAsicRemarkingDot1pAbility
 470  * Description:
 471  *      Get 802.1p remarking ability
 472  * Input:
 473  *      port     - Physical port number (0~7)
 474  *      pEnabled - 1: enabled, 0: disabled
 475  * Output:
 476  *      None
 477  * Return:
 478  *      RT_ERR_OK     - Success
 479  *      RT_ERR_SMI  - SMI access error
 480  * Note:
 481  *      None
 482  */
 483 ret_t rtl8367c_getAsicRemarkingDot1pAbility(rtk_uint32 port, rtk_uint32* pEnabled)
 484 {
 485     return rtl8367c_getAsicRegBit(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_1QREMARK_ENABLE_OFFSET, pEnabled);
 486 }
 487 /* Function Name:
 488  *      rtl8367c_setAsicRemarkingDot1pParameter
 489  * Description:
 490  *      Set 802.1p remarking parameter
 491  * Input:
 492  *      priority     - Priority value
 493  *      newPriority - New priority value
 494  * Output:
 495  *      None
 496  * Return:
 497  *      RT_ERR_OK                 - Success
 498  *      RT_ERR_SMI              - SMI access error
 499  *      RT_ERR_QOS_INT_PRIORITY - Invalid priority
 500  * Note:
 501  *      None
 502  */
 503 ret_t rtl8367c_setAsicRemarkingDot1pParameter(rtk_uint32 priority, rtk_uint32 newPriority )
 504 {
 505     if(priority > RTL8367C_PRIMAX || newPriority > RTL8367C_PRIMAX)
 506         return RT_ERR_QOS_INT_PRIORITY;
 507
 508     return rtl8367c_setAsicRegBits(RTL8367C_QOS_1Q_REMARK_REG(priority), RTL8367C_QOS_1Q_REMARK_MASK(priority), newPriority);
 509 }
 510 /* Function Name:
 511  *      rtl8367c_getAsicRemarkingDot1pParameter
 512  * Description:
 513  *      Get 802.1p remarking parameter
 514  * Input:
 515  *      priority     - Priority value
 516  *      pNewPriority - New priority value
 517  * Output:
 518  *      None
 519  * Return:
 520  *      RT_ERR_OK                 - Success
 521  *      RT_ERR_SMI              - SMI access error
 522  *      RT_ERR_QOS_INT_PRIORITY - Invalid priority
 523  * Note:
 524  *      None
 525  */
 526 ret_t rtl8367c_getAsicRemarkingDot1pParameter(rtk_uint32 priority, rtk_uint32 *pNewPriority )
 527 {
 528     if(priority > RTL8367C_PRIMAX )
 529         return RT_ERR_QOS_INT_PRIORITY;
 530
 531     return rtl8367c_getAsicRegBits(RTL8367C_QOS_1Q_REMARK_REG(priority), RTL8367C_QOS_1Q_REMARK_MASK(priority), pNewPriority);
 532 }
 533
 534 /* Function Name:
 535  *      rtl8367c_setAsicRemarkingDot1pSrc
 536  * Description:
 537  *      Set remarking source of 802.1p remarking.
 538  * Input:
 539  *      type      - remarking source
 540  * Output:
 541  *      None
 542  * Return:
 543  *      RT_ERR_OK
 544  *      RT_ERR_FAILED
 545  *      RT_ERR_NOT_INIT         - The module is not initial
 546  *      RT_ERR_PORT_ID  - invalid port id
 547  *      RT_ERR_INPUT            - invalid input parameter
 548
 549  * Note:
 550  *      The API can configure 802.1p remark functionality to map original DSCP value or internal
 551  *      priority to TX DSCP value.
 552  */
 553 ret_t rtl8367c_setAsicRemarkingDot1pSrc(rtk_uint32 type)
 554 {
 555
 556     if(type >= DOT1P_PRISEL_END )
 557         return RT_ERR_QOS_SEL_PRI_SOURCE;
 558
 559     return rtl8367c_setAsicRegBit(RTL8367C_REG_RMK_CFG_SEL_CTRL, RTL8367C_RMK_1Q_CFG_SEL_OFFSET, type);
 560 }
 561
 562
 563 /* Function Name:
 564  *      rtl8367c_getAsicRemarkingDot1pSrc
 565  * Description:
 566  *      Get remarking source of 802.1p remarking.
 567  * Output:
 568  *      pType      - remarking source
 569  * Return:
 570  *      RT_ERR_OK
 571  *      RT_ERR_FAILED
 572  *      RT_ERR_NOT_INIT         - The module is not initial
 573  *      RT_ERR_PORT_ID          - invalid port id
 574  *      RT_ERR_INPUT            - invalid input parameter
 575  *      RT_ERR_NULL_POINTER     - input parameter may be null pointer
 576
 577  * Note:
 578  *      None
 579  */
 580 ret_t rtl8367c_getAsicRemarkingDot1pSrc(rtk_uint32 *pType)
 581 {
 582     return rtl8367c_getAsicRegBit(RTL8367C_REG_RMK_CFG_SEL_CTRL, RTL8367C_RMK_1Q_CFG_SEL_OFFSET, pType);
 583 }
 584
 585
 586
 587
 588
 589 /* Function Name:
 590  *      rtl8367c_setAsicRemarkingDscpAbility
 591  * Description:
 592  *      Set DSCP remarking ability
 593  * Input:
 594  *      enabled     - 1: enabled, 0: disabled
 595  * Output:
 596  *      None
 597  * Return:
 598  *      RT_ERR_OK     - Success
 599  *      RT_ERR_SMI  - SMI access error
 600  * Note:
 601  *      None
 602  */
 603 ret_t rtl8367c_setAsicRemarkingDscpAbility(rtk_uint32 enabled)
 604 {
 605     return rtl8367c_setAsicRegBit(RTL8367C_REMARKING_CTRL_REG, RTL8367C_REMARKING_DSCP_ENABLE_OFFSET, enabled);
 606 }
 607 /* Function Name:
 608  *      rtl8367c_getAsicRemarkingDscpAbility
 609  * Description:
 610  *      Get DSCP remarking ability
 611  * Input:
 612  *      enabled     - 1: enabled, 0: disabled
 613  * Output:
 614  *      None
 615  * Return:
 616  *      RT_ERR_OK     - Success
 617  *      RT_ERR_SMI  - SMI access error
 618  * Note:
 619  *      None
 620  */
 621 ret_t rtl8367c_getAsicRemarkingDscpAbility(rtk_uint32* pEnabled)
 622 {
 623     return rtl8367c_getAsicRegBit(RTL8367C_REMARKING_CTRL_REG, RTL8367C_REMARKING_DSCP_ENABLE_OFFSET, pEnabled);
 624 }
 625 /* Function Name:
 626  *      rtl8367c_setAsicRemarkingDscpParameter
 627  * Description:
 628  *      Set DSCP remarking parameter
 629  * Input:
 630  *      priority     - Priority value
 631  *      newDscp     - New DSCP value
 632  * Output:
 633  *      None
 634  * Return:
 635  *      RT_ERR_OK                 - Success
 636  *      RT_ERR_SMI              - SMI access error
 637  *      RT_ERR_QOS_DSCP_VALUE    - Invalid DSCP value
 638  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
 639  * Note:
 640  *      None
 641  */
 642 ret_t rtl8367c_setAsicRemarkingDscpParameter(rtk_uint32 priority, rtk_uint32 newDscp )
 643 {
 644     if(priority > RTL8367C_PRIMAX )
 645         return RT_ERR_QOS_INT_PRIORITY;
 646
 647     if(newDscp > RTL8367C_DSCPMAX)
 648         return RT_ERR_QOS_DSCP_VALUE;
 649
 650     return rtl8367c_setAsicRegBits(RTL8367C_QOS_DSCP_REMARK_REG(priority), RTL8367C_QOS_DSCP_REMARK_MASK(priority), newDscp);
 651 }
 652 /* Function Name:
 653  *      rtl8367c_getAsicRemarkingDscpParameter
 654  * Description:
 655  *      Get DSCP remarking parameter
 656  * Input:
 657  *      priority     - Priority value
 658  *      pNewDscp     - New DSCP value
 659  * Output:
 660  *      None
 661  * Return:
 662  *      RT_ERR_OK                 - Success
 663  *      RT_ERR_SMI              - SMI access error
 664  *      RT_ERR_QOS_INT_PRIORITY    - Invalid priority
 665  * Note:
 666  *      None
 667  */
 668 ret_t rtl8367c_getAsicRemarkingDscpParameter(rtk_uint32 priority, rtk_uint32* pNewDscp )
 669 {
 670     if(priority > RTL8367C_PRIMAX )
 671         return RT_ERR_QOS_INT_PRIORITY;
 672
 673     return rtl8367c_getAsicRegBits(RTL8367C_QOS_DSCP_REMARK_REG(priority), RTL8367C_QOS_DSCP_REMARK_MASK(priority), pNewDscp);
 674 }
 675
 676 /* Function Name:
 677  *      rtl8367c_setAsicRemarkingDscpSrc
 678  * Description:
 679  *      Set remarking source of DSCP remarking.
 680  * Input:
 681  *      type      - remarking source
 682  * Output:
 683  *      None
 684  * Return:
 685  *      RT_ERR_OK
 686  *      RT_ERR_FAILED
 687  *      RT_ERR_NOT_INIT         - The module is not initial
 688  *      RT_ERR_PORT_ID  - invalid port id
 689  *      RT_ERR_INPUT            - invalid input parameter
 690
 691  * Note:
 692  *      The API can configure DSCP remark functionality to map original DSCP value or internal
 693  *      priority to TX DSCP value.
 694  */
 695 ret_t rtl8367c_setAsicRemarkingDscpSrc(rtk_uint32 type)
 696 {
 697
 698     if(type >= DSCP_PRISEL_END )
 699         return RT_ERR_QOS_SEL_PRI_SOURCE;
 700
 701     return rtl8367c_setAsicRegBits(RTL8367C_REG_RMK_CFG_SEL_CTRL, RTL8367C_RMK_DSCP_CFG_SEL_MASK, type);
 702 }
 703
 704
 705 /* Function Name:
 706  *      rtl8367c_getAsicRemarkingDscpSrc
 707  * Description:
 708  *      Get remarking source of DSCP remarking.
 709  * Output:
 710  *      pType      - remarking source
 711  * Return:
 712  *      RT_ERR_OK
 713  *      RT_ERR_FAILED
 714  *      RT_ERR_NOT_INIT         - The module is not initial
 715  *      RT_ERR_PORT_ID          - invalid port id
 716  *      RT_ERR_INPUT            - invalid input parameter
 717  *      RT_ERR_NULL_POINTER     - input parameter may be null pointer
 718
 719  * Note:
 720  *      None
 721  */
 722 ret_t rtl8367c_getAsicRemarkingDscpSrc(rtk_uint32 *pType)
 723 {
 724     return rtl8367c_getAsicRegBits(RTL8367C_REG_RMK_CFG_SEL_CTRL, RTL8367C_RMK_DSCP_CFG_SEL_MASK, pType);
 725 }
 726
 727 /* Function Name:
 728  *      rtl8367c_setAsicRemarkingDscp2Dscp
 729  * Description:
 730  *      Set DSCP to remarked DSCP mapping.
 731  * Input:
 732  *      dscp    - DSCP value
 733  *      rmkDscp - remarked DSCP value
 734  * Output:
 735  *      None.
 736  * Return:
 737  *      RT_ERR_OK
 738  *      RT_ERR_FAILED
 739  *      RT_ERR_UNIT_ID          - Invalid unit id
 740  *      RT_ERR_QOS_DSCP_VALUE   - Invalid dscp value
 741  * Note:
 742  *      dscp parameter can be DSCP value or internal priority according to configuration of API
 743  *      dal_apollomp_qos_dscpRemarkSrcSel_set(), because DSCP remark functionality can map original DSCP
 744  *      value or internal priority to TX DSCP value.
 745  */
 746 ret_t rtl8367c_setAsicRemarkingDscp2Dscp(rtk_uint32 dscp, rtk_uint32 rmkDscp)
 747 {
 748     if((dscp > RTL8367C_DSCPMAX ) || (rmkDscp > RTL8367C_DSCPMAX))
 749         return RT_ERR_QOS_INT_PRIORITY;
 750
 751     return rtl8367c_setAsicRegBits(RTL8367C_QOS_DSCP_TO_DSCP_REG(dscp), RTL8367C_QOS_DSCP_TO_DSCP_MASK(dscp), rmkDscp);
 752 }
 753
 754 /* Function Name:
 755  *      rtl8367c_getAsicRemarkingDscp2Dscp
 756  * Description:
 757  *      Get DSCP to remarked DSCP mapping.
 758  * Input:
 759  *      dscp    - DSCP value
 760  * Output:
 761  *      pRmkDscp   - remarked DSCP value
 762  * Return:
 763  *      RT_ERR_OK
 764  *      RT_ERR_FAILED
 765  *      RT_ERR_QOS_DSCP_VALUE   - Invalid dscp value
 766  *      RT_ERR_NULL_POINTER     - NULL pointer
 767  * Note:
 768  *      None.
 769  */
 770 ret_t rtl8367c_getAsicRemarkingDscp2Dscp(rtk_uint32 dscp, rtk_uint32 *pRmkDscp)
 771 {
 772     if(dscp > RTL8367C_DSCPMAX)
 773         return RT_ERR_QOS_DSCP_VALUE;
 774
 775     return rtl8367c_getAsicRegBits(RTL8367C_QOS_DSCP_TO_DSCP_REG(dscp), RTL8367C_QOS_DSCP_TO_DSCP_MASK(dscp), pRmkDscp);
 776
 777 }
 778