target/linux/mediatek/files/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_scheduling.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 : Packet Scheduling related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_scheduling.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicLeakyBucketParameter
  21  * Description:
  22  *      Set Leaky Bucket Paramters
  23  * Input:
  24  *      tick    - Tick is used for time slot size unit
  25  *      token   - Token is used for adding budget in each time slot
  26  * Output:
  27  *      None
  28  * Return:
  29  *      RT_ERR_OK       - Success
  30  *      RT_ERR_SMI      - SMI access error
  31  *      RT_ERR_TICK     - Invalid TICK
  32  *      RT_ERR_TOKEN    - Invalid TOKEN
  33  * Note:
  34  *      None
  35  */
  36 ret_t rtl8367c_setAsicLeakyBucketParameter(rtk_uint32 tick, rtk_uint32 token)
  37 {
  38     ret_t retVal;
  39
  40     if(tick > 0xFF)
  41         return RT_ERR_TICK;
  42
  43     if(token > 0xFF)
  44         return RT_ERR_TOKEN;
  45
  46     retVal = rtl8367c_setAsicRegBits(RTL8367C_LEAKY_BUCKET_TICK_REG, RTL8367C_LEAKY_BUCKET_TICK_MASK, tick);
  47
  48     if(retVal != RT_ERR_OK)
  49         return retVal;
  50
  51     retVal = rtl8367c_setAsicRegBits(RTL8367C_LEAKY_BUCKET_TOKEN_REG, RTL8367C_LEAKY_BUCKET_TOKEN_MASK, token);
  52
  53     return retVal;
  54 }
  55 /* Function Name:
  56  *      rtl8367c_getAsicLeakyBucketParameter
  57  * Description:
  58  *      Get Leaky Bucket Paramters
  59  * Input:
  60  *      tick    - Tick is used for time slot size unit
  61  *      token   - Token is used for adding budget in each time slot
  62  * Output:
  63  *      None
  64  * Return:
  65  *      RT_ERR_OK   - Success
  66  *      RT_ERR_SMI  - SMI access error
  67  * Note:
  68  *      None
  69  */
  70 ret_t rtl8367c_getAsicLeakyBucketParameter(rtk_uint32 *tick, rtk_uint32 *token)
  71 {
  72     ret_t retVal;
  73
  74     retVal = rtl8367c_getAsicRegBits(RTL8367C_LEAKY_BUCKET_TICK_REG, RTL8367C_LEAKY_BUCKET_TICK_MASK, tick);
  75
  76     if(retVal != RT_ERR_OK)
  77         return retVal;
  78
  79     retVal = rtl8367c_getAsicRegBits(RTL8367C_LEAKY_BUCKET_TOKEN_REG, RTL8367C_LEAKY_BUCKET_TOKEN_MASK, token);
  80
  81     return retVal;
  82 }
  83 /* Function Name:
  84  *      rtl8367c_setAsicAprMeter
  85  * Description:
  86  *      Set per-port per-queue APR shared meter index
  87  * Input:
  88  *      port    - Physical port number (0~10)
  89  *      qid     - Queue id
  90  *      apridx  - dedicated shared meter index for APR (0~7)
  91  * Output:
  92  *      None
  93  * Return:
  94  *      RT_ERR_OK               - Success
  95  *      RT_ERR_SMI              - SMI access error
  96  *      RT_ERR_PORT_ID          - Invalid port number
  97  *      RT_ERR_QUEUE_ID         - Invalid queue id
  98  *      RT_ERR_FILTER_METER_ID  - Invalid meter
  99  * Note:
 100  *      None
 101  */
 102 ret_t rtl8367c_setAsicAprMeter(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 apridx)
 103 {
 104     ret_t retVal;
 105     rtk_uint32 regAddr;
 106
 107     if(port > RTL8367C_PORTIDMAX)
 108         return RT_ERR_PORT_ID;
 109
 110     if(qid > RTL8367C_QIDMAX)
 111         return RT_ERR_QUEUE_ID;
 112
 113     if(apridx > RTL8367C_PORT_QUEUE_METER_INDEX_MAX)
 114         return RT_ERR_FILTER_METER_ID;
 115
 116     if(port < 8)
 117         retVal = rtl8367c_setAsicRegBits(RTL8367C_SCHEDULE_PORT_APR_METER_REG(port, qid), RTL8367C_SCHEDULE_PORT_APR_METER_MASK(qid), apridx);
 118     else {
 119         regAddr = RTL8367C_REG_SCHEDULE_PORT8_APR_METER_CTRL0 + ((port-8) << 1) + (qid / 5);
 120         retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_SCHEDULE_PORT_APR_METER_MASK(qid), apridx);
 121     }
 122
 123     return retVal;
 124 }
 125 /* Function Name:
 126  *      rtl8367c_getAsicAprMeter
 127  * Description:
 128  *      Get per-port per-queue APR shared meter index
 129  * Input:
 130  *      port    - Physical port number (0~10)
 131  *      qid     - Queue id
 132  *      apridx  - dedicated shared meter index for APR (0~7)
 133  * Output:
 134  *      None
 135  * Return:
 136  *      RT_ERR_OK       - Success
 137  *      RT_ERR_SMI      - SMI access error
 138  *      RT_ERR_PORT_ID  - Invalid port number
 139  *      RT_ERR_QUEUE_ID - Invalid queue id
 140  * Note:
 141  *      None
 142  */
 143 ret_t rtl8367c_getAsicAprMeter(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 *apridx)
 144 {
 145     ret_t retVal;
 146     rtk_uint32 regAddr;
 147
 148     if(port > RTL8367C_PORTIDMAX)
 149         return RT_ERR_PORT_ID;
 150
 151     if(qid > RTL8367C_QIDMAX)
 152         return RT_ERR_QUEUE_ID;
 153
 154     if(port < 8)
 155         retVal = rtl8367c_getAsicRegBits(RTL8367C_SCHEDULE_PORT_APR_METER_REG(port, qid), RTL8367C_SCHEDULE_PORT_APR_METER_MASK(qid), apridx);
 156     else {
 157         regAddr = RTL8367C_REG_SCHEDULE_PORT8_APR_METER_CTRL0 + ((port-8) << 1) + (qid / 5);
 158         retVal = rtl8367c_getAsicRegBits(regAddr, RTL8367C_SCHEDULE_PORT_APR_METER_MASK(qid), apridx);
 159     }
 160
 161     return retVal;
 162 }
 163 /* Function Name:
 164  *      rtl8367c_setAsicAprEnable
 165  * Description:
 166  *      Set per-port APR enable
 167  * Input:
 168  *      port        - Physical port number (0~7)
 169  *      aprEnable   - APR enable seting 1:enable 0:disable
 170  * Output:
 171  *      None
 172  * Return:
 173  *      RT_ERR_OK       - Success
 174  *      RT_ERR_SMI      - SMI access error
 175  *      RT_ERR_PORT_ID  - Invalid port number
 176  * Note:
 177  *      None
 178  */
 179 ret_t rtl8367c_setAsicAprEnable(rtk_uint32 port, rtk_uint32 aprEnable)
 180 {
 181     ret_t retVal;
 182
 183     if(port > RTL8367C_PORTIDMAX)
 184         return RT_ERR_PORT_ID;
 185
 186     retVal = rtl8367c_setAsicRegBit(RTL8367C_SCHEDULE_APR_CTRL_REG, RTL8367C_SCHEDULE_APR_CTRL_OFFSET(port), aprEnable);
 187
 188     return retVal;
 189 }
 190 /* Function Name:
 191  *      rtl8367c_getAsicAprEnable
 192  * Description:
 193  *      Get per-port APR enable
 194  * Input:
 195  *      port        - Physical port number (0~7)
 196  *      aprEnable   - APR enable seting 1:enable 0:disable
 197  * Output:
 198  *      None
 199  * Return:
 200  *      RT_ERR_OK       - Success
 201  *      RT_ERR_SMI      - SMI access error
 202  *      RT_ERR_PORT_ID  - Invalid port number
 203  * Note:
 204  *      None
 205  */
 206 ret_t rtl8367c_getAsicAprEnable(rtk_uint32 port, rtk_uint32 *aprEnable)
 207 {
 208     ret_t retVal;
 209
 210     if(port > RTL8367C_PORTIDMAX)
 211         return RT_ERR_PORT_ID;
 212
 213     retVal = rtl8367c_getAsicRegBit(RTL8367C_SCHEDULE_APR_CTRL_REG, RTL8367C_SCHEDULE_APR_CTRL_OFFSET(port), aprEnable);
 214
 215     return retVal;
 216 }
 217 /* Function Name:
 218  *      rtl8367c_setAsicWFQWeight
 219  * Description:
 220  *      Set weight  of a queue
 221  * Input:
 222  *      port    - Physical port number (0~10)
 223  *      qid     - The queue ID wanted to set
 224  *      qWeight - The weight value wanted to set (valid:0~127)
 225  * Output:
 226  *      None
 227  * Return:
 228  *      RT_ERR_OK               - Success
 229  *      RT_ERR_SMI              - SMI access error
 230  *      RT_ERR_PORT_ID          - Invalid port number
 231  *      RT_ERR_QUEUE_ID         - Invalid queue id
 232  *      RT_ERR_QOS_QUEUE_WEIGHT - Invalid queue weight
 233  * Note:
 234  *      None
 235  */
 236 ret_t rtl8367c_setAsicWFQWeight(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 qWeight)
 237 {
 238     ret_t retVal;
 239
 240     /* Invalid input parameter */
 241     if(port > RTL8367C_PORTIDMAX)
 242         return RT_ERR_PORT_ID;
 243
 244     if(qid > RTL8367C_QIDMAX)
 245         return RT_ERR_QUEUE_ID;
 246
 247     if(qWeight > RTL8367C_QWEIGHTMAX && qid > 0)
 248         return RT_ERR_QOS_QUEUE_WEIGHT;
 249
 250     retVal = rtl8367c_setAsicReg(RTL8367C_SCHEDULE_PORT_QUEUE_WFQ_WEIGHT_REG(port, qid), qWeight);
 251
 252     return retVal;
 253 }
 254 /* Function Name:
 255  *      rtl8367c_getAsicWFQWeight
 256  * Description:
 257  *      Get weight  of a queue
 258  * Input:
 259  *      port    - Physical port number (0~10)
 260  *      qid     - The queue ID wanted to set
 261  *      qWeight - The weight value wanted to set (valid:0~127)
 262  * Output:
 263  *      None
 264  * Return:
 265  *      RT_ERR_OK               - Success
 266  *      RT_ERR_SMI              - SMI access error
 267  *      RT_ERR_PORT_ID          - Invalid port number
 268  *      RT_ERR_QUEUE_ID         - Invalid queue id
 269  * Note:
 270  *      None
 271  */
 272 ret_t rtl8367c_getAsicWFQWeight(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 *qWeight)
 273 {
 274     ret_t retVal;
 275
 276
 277     /* Invalid input parameter */
 278     if(port  > RTL8367C_PORTIDMAX)
 279         return RT_ERR_PORT_ID;
 280
 281     if(qid > RTL8367C_QIDMAX)
 282         return RT_ERR_QUEUE_ID;
 283
 284
 285     retVal = rtl8367c_getAsicReg(RTL8367C_SCHEDULE_PORT_QUEUE_WFQ_WEIGHT_REG(port, qid), qWeight);
 286
 287     return retVal;
 288 }
 289 /* Function Name:
 290  *      rtl8367c_setAsicWFQBurstSize
 291  * Description:
 292  *      Set WFQ leaky bucket burst size
 293  * Input:
 294  *      burstsize   - Leaky bucket burst size, unit byte
 295  * Output:
 296  *      None
 297  * Return:
 298  *      RT_ERR_OK   - Success
 299  *      RT_ERR_SMI  - SMI access error
 300  * Note:
 301  *      None
 302  */
 303 ret_t rtl8367c_setAsicWFQBurstSize(rtk_uint32 burstsize)
 304 {
 305     ret_t retVal;
 306
 307     retVal = rtl8367c_setAsicReg(RTL8367C_SCHEDULE_WFQ_BURST_SIZE_REG, burstsize);
 308
 309     return retVal;
 310 }
 311 /* Function Name:
 312  *      rtl8367c_getAsicWFQBurstSize
 313  * Description:
 314  *      Get WFQ leaky bucket burst size
 315  * Input:
 316  *      burstsize   - Leaky bucket burst size, unit byte
 317  * Output:
 318  *      None
 319  * Return:
 320  *      RT_ERR_OK   - Success
 321  *      RT_ERR_SMI  - SMI access error
 322  * Note:
 323  *      None
 324  */
 325 ret_t rtl8367c_getAsicWFQBurstSize(rtk_uint32 *burstsize)
 326 {
 327     ret_t retVal;
 328
 329     retVal = rtl8367c_getAsicReg(RTL8367C_SCHEDULE_WFQ_BURST_SIZE_REG, burstsize);
 330
 331     return retVal;
 332 }
 333 /* Function Name:
 334  *      rtl8367c_setAsicQueueType
 335  * Description:
 336  *      Set type of a queue
 337  * Input:
 338  *      port        - Physical port number (0~10)
 339  *      qid         - The queue ID wanted to set
 340  *      queueType   - The specified queue type. 0b0: Strict priority, 0b1: WFQ
 341  * Output:
 342  *      None
 343  * Return:
 344  *      RT_ERR_OK       - Success
 345  *      RT_ERR_SMI      - SMI access error
 346  *      RT_ERR_PORT_ID  - Invalid port number
 347  *      RT_ERR_QUEUE_ID - Invalid queue id
 348  * Note:
 349  *      None
 350  */
 351 ret_t rtl8367c_setAsicQueueType(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 queueType)
 352 {
 353     ret_t retVal;
 354
 355     /* Invalid input parameter */
 356     if(port > RTL8367C_PORTIDMAX)
 357         return RT_ERR_PORT_ID;
 358
 359     if(qid > RTL8367C_QIDMAX)
 360         return RT_ERR_QUEUE_ID;
 361
 362     /* Set Related Registers */
 363     retVal = rtl8367c_setAsicRegBit(RTL8367C_SCHEDULE_QUEUE_TYPE_REG(port), RTL8367C_SCHEDULE_QUEUE_TYPE_OFFSET(port, qid),queueType);
 364
 365     return retVal;
 366 }
 367 /* Function Name:
 368  *      rtl8367c_getAsicQueueType
 369  * Description:
 370  *      Get type of a queue
 371  * Input:
 372  *      port        - Physical port number (0~7)
 373  *      qid         - The queue ID wanted to set
 374  *      queueType   - The specified queue type. 0b0: Strict priority, 0b1: WFQ
 375  * Output:
 376  *      None
 377  * Return:
 378  *      RT_ERR_OK       - Success
 379  *      RT_ERR_SMI      - SMI access error
 380  *      RT_ERR_PORT_ID  - Invalid port number
 381  *      RT_ERR_QUEUE_ID - Invalid queue id
 382  * Note:
 383  *      None
 384  */
 385 ret_t rtl8367c_getAsicQueueType(rtk_uint32 port, rtk_uint32 qid, rtk_uint32 *queueType)
 386 {
 387     ret_t retVal;
 388
 389     /* Invalid input parameter */
 390     if(port  > RTL8367C_PORTIDMAX)
 391         return RT_ERR_PORT_ID;
 392
 393     if(qid > RTL8367C_QIDMAX)
 394         return RT_ERR_QUEUE_ID;
 395
 396     retVal = rtl8367c_getAsicRegBit(RTL8367C_SCHEDULE_QUEUE_TYPE_REG(port), RTL8367C_SCHEDULE_QUEUE_TYPE_OFFSET(port, qid),queueType);
 397
 398     return retVal;
 399 }
 400 /* Function Name:
 401  *      rtl8367c_setAsicPortEgressRate
 402  * Description:
 403  *      Set per-port egress rate
 404  * Input:
 405  *      port        - Physical port number (0~10)
 406  *      rate        - Egress rate
 407  * Output:
 408  *      None
 409  * Return:
 410  *      RT_ERR_OK           - Success
 411  *      RT_ERR_SMI          - SMI access error
 412  *      RT_ERR_PORT_ID      - Invalid port number
 413  *      RT_ERR_QOS_EBW_RATE - Invalid bandwidth/rate
 414  * Note:
 415  *      None
 416  */
 417 ret_t rtl8367c_setAsicPortEgressRate(rtk_uint32 port, rtk_uint32 rate)
 418 {
 419     ret_t retVal;
 420     rtk_uint32 regAddr, regData;
 421
 422     if(port > RTL8367C_PORTIDMAX)
 423         return RT_ERR_PORT_ID;
 424
 425     if(rate > RTL8367C_QOS_GRANULARTY_MAX)
 426         return RT_ERR_QOS_EBW_RATE;
 427
 428     regAddr = RTL8367C_PORT_EGRESSBW_LSB_REG(port);
 429     regData = RTL8367C_QOS_GRANULARTY_LSB_MASK & rate;
 430
 431     retVal = rtl8367c_setAsicReg(regAddr, regData);
 432
 433     if(retVal != RT_ERR_OK)
 434         return retVal;
 435
 436     regAddr = RTL8367C_PORT_EGRESSBW_MSB_REG(port);
 437     regData = (RTL8367C_QOS_GRANULARTY_MSB_MASK & rate) >> RTL8367C_QOS_GRANULARTY_MSB_OFFSET;
 438
 439     retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_PORT6_EGRESSBW_CTRL1_MASK, regData);
 440
 441     return retVal;
 442 }
 443 /* Function Name:
 444  *      rtl8367c_getAsicPortEgressRate
 445  * Description:
 446  *      Get per-port egress rate
 447  * Input:
 448  *      port        - Physical port number (0~10)
 449  *      rate        - Egress rate
 450  * Output:
 451  *      None
 452  * Return:
 453  *      RT_ERR_OK           - Success
 454  *      RT_ERR_SMI          - SMI access error
 455  *      RT_ERR_PORT_ID      - Invalid port number
 456  * Note:
 457  *      None
 458  */
 459 ret_t rtl8367c_getAsicPortEgressRate(rtk_uint32 port, rtk_uint32 *rate)
 460 {
 461     ret_t retVal;
 462     rtk_uint32 regAddr, regData,regData2;
 463
 464     if(port > RTL8367C_PORTIDMAX)
 465         return RT_ERR_PORT_ID;
 466
 467     regAddr = RTL8367C_PORT_EGRESSBW_LSB_REG(port);
 468
 469     retVal = rtl8367c_getAsicReg(regAddr, &regData);
 470     if(retVal != RT_ERR_OK)
 471         return retVal;
 472
 473     regAddr = RTL8367C_PORT_EGRESSBW_MSB_REG(port);
 474     retVal = rtl8367c_getAsicRegBits(regAddr, RTL8367C_PORT6_EGRESSBW_CTRL1_MASK, &regData2);
 475     if(retVal != RT_ERR_OK)
 476         return retVal;
 477
 478     *rate = regData | (regData2 << RTL8367C_QOS_GRANULARTY_MSB_OFFSET);
 479
 480     return RT_ERR_OK;
 481 }
 482 /* Function Name:
 483  *      rtl8367c_setAsicPortEgressRateIfg
 484  * Description:
 485  *      Set per-port egress rate calculate include/exclude IFG
 486  * Input:
 487  *      ifg     - 1:include IFG 0:exclude IFG
 488  * Output:
 489  *      None
 490  * Return:
 491  *      RT_ERR_OK   - Success
 492  *      RT_ERR_SMI  - SMI access error
 493  * Note:
 494  *      None
 495  */
 496 ret_t rtl8367c_setAsicPortEgressRateIfg(rtk_uint32 ifg)
 497 {
 498     ret_t retVal;
 499
 500     retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SCHEDULE_WFQ_CTRL, RTL8367C_SCHEDULE_WFQ_CTRL_OFFSET, ifg);
 501
 502     return retVal;
 503 }
 504 /* Function Name:
 505  *      rtl8367c_getAsicPortEgressRateIfg
 506  * Description:
 507  *      Get per-port egress rate calculate include/exclude IFG
 508  * Input:
 509  *      ifg     - 1:include IFG 0:exclude IFG
 510  * Output:
 511  *      None
 512  * Return:
 513  *      RT_ERR_OK   - Success
 514  *      RT_ERR_SMI  - SMI access error
 515  * Note:
 516  *      None
 517  */
 518 ret_t rtl8367c_getAsicPortEgressRateIfg(rtk_uint32 *ifg)
 519 {
 520     ret_t retVal;
 521
 522     retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_SCHEDULE_WFQ_CTRL, RTL8367C_SCHEDULE_WFQ_CTRL_OFFSET, ifg);
 523
 524     return retVal;
 525 }