target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_eav.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 : Ethernet AV related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_eav.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicEavMacAddress
  21  * Description:
  22  *      Set PTP MAC address
  23  * Input:
  24  *      mac     - PTP mac
  25  * Output:
  26  *      None
  27  * Return:
  28  *      RT_ERR_OK         - Success
  29  *      RT_ERR_SMI      - SMI access error
  30  * Note:
  31  *      None
  32  */
  33 ret_t rtl8367c_setAsicEavMacAddress(ether_addr_t mac)
  34 {
  35     ret_t retVal;
  36     rtk_uint32 regData;
  37     rtk_uint8 *accessPtr;
  38     rtk_uint32 i;
  39
  40     accessPtr =  (rtk_uint8*)&mac;
  41
  42     regData = *accessPtr;
  43     accessPtr ++;
  44     regData = (regData << 8) | *accessPtr;
  45     accessPtr ++;
  46     for(i = 0; i <=2; i++)
  47     {
  48         retVal = rtl8367c_setAsicReg(RTL8367C_REG_MAC_ADDR_H - i, regData);
  49         if(retVal != RT_ERR_OK)
  50             return retVal;
  51
  52         regData = *accessPtr;
  53         accessPtr ++;
  54         regData = (regData << 8) | *accessPtr;
  55         accessPtr ++;
  56     }
  57
  58     return retVal;
  59 }
  60 /* Function Name:
  61  *      rtl8367c_getAsicEavMacAddress
  62  * Description:
  63  *      Get PTP MAC address
  64  * Input:
  65  *      None
  66  * Output:
  67  *      pMac     - PTP  mac
  68  * Return:
  69  *      RT_ERR_OK         - Success
  70  *      RT_ERR_SMI      - SMI access error
  71  * Note:
  72  *      None
  73  */
  74 ret_t rtl8367c_getAsicEavMacAddress(ether_addr_t *pMac)
  75 {
  76     ret_t retVal;
  77     rtk_uint32 regData;
  78     rtk_uint8 *accessPtr;
  79     rtk_uint32 i;
  80
  81     accessPtr = (rtk_uint8*)pMac;
  82
  83     for(i = 0; i <= 2; i++)
  84     {
  85         retVal = rtl8367c_getAsicReg(RTL8367C_REG_MAC_ADDR_H - i, &regData);
  86         if(retVal != RT_ERR_OK)
  87             return retVal;
  88
  89         *accessPtr = (regData & 0xFF00) >> 8;
  90         accessPtr ++;
  91         *accessPtr = regData & 0xFF;
  92         accessPtr ++;
  93     }
  94
  95     return retVal;
  96 }
  97
  98 /* Function Name:
  99  *      rtl8367c_setAsicEavTpid
 100  * Description:
 101  *      Set PTP parser tag TPID.
 102  * Input:
 103  *       outerTag - outter tag TPID
 104  *       innerTag  - inner tag TPID
 105  * Output:
 106  *      None
 107  * Return:
 108  *      RT_ERR_OK   - Success
 109  *      RT_ERR_SMI  - SMI access error
 110  * Note:
 111  *     None
 112  */
 113 ret_t rtl8367c_setAsicEavTpid(rtk_uint32 outerTag, rtk_uint32 innerTag)
 114 {
 115     ret_t retVal;
 116
 117     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_OTAG_TPID, outerTag)) != RT_ERR_OK)
 118         return retVal;
 119     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_ITAG_TPID, innerTag)) != RT_ERR_OK)
 120         return retVal;
 121
 122     return RT_ERR_OK;
 123 }
 124 /* Function Name:
 125  *      rtl8367c_getAsicEavTpid
 126  * Description:
 127  *      Get PTP parser tag TPID.
 128  * Input:
 129  *      None
 130  * Output:
 131  *       pOuterTag - outter tag TPID
 132  *       pInnerTag  - inner tag TPID
 133  * Return:
 134  *      RT_ERR_OK   - Success
 135  *      RT_ERR_SMI  - SMI access error
 136  * Note:
 137  *      None
 138  */
 139 ret_t rtl8367c_getAsicEavTpid(rtk_uint32* pOuterTag, rtk_uint32* pInnerTag)
 140 {
 141     ret_t retVal;
 142
 143     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_OTAG_TPID, pOuterTag)) != RT_ERR_OK)
 144         return retVal;
 145     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_ITAG_TPID, pInnerTag)) != RT_ERR_OK)
 146         return retVal;
 147
 148     return RT_ERR_OK;
 149 }
 150
 151 /* Function Name:
 152  *      rtl8367c_setAsicEavSysTime
 153  * Description:
 154  *      Set PTP system time
 155  * Input:
 156  *      second - seconds
 157  *      nanoSecond - nano seconds
 158  * Output:
 159  *      None
 160  * Return:
 161  *      RT_ERR_OK     - Success
 162  *      RT_ERR_SMI  - SMI access error
 163  * Note:
 164  *      The time granuality is 8 nano seconds.
 165  */
 166 ret_t rtl8367c_setAsicEavSysTime(rtk_uint32 second, rtk_uint32 nanoSecond)
 167 {
 168     ret_t retVal;
 169     rtk_uint32 sec_h, sec_l, nsec8_h, nsec8_l;
 170     rtk_uint32 nano_second_8;
 171     rtk_uint32 regData, busyFlag, count;
 172
 173     if(nanoSecond > RTL8367C_EAV_NANOSECONDMAX)
 174         return RT_ERR_INPUT;
 175
 176     regData = 0;
 177     sec_h = second >>16;
 178     sec_l = second & 0xFFFF;
 179     nano_second_8 = nanoSecond >> 3;
 180     nsec8_h = (nano_second_8 >>16) & RTL8367C_PTP_TIME_NSEC_H_NSEC_MASK;
 181     nsec8_l = nano_second_8 &0xFFFF;
 182
 183     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_SEC_H_SEC, sec_h)) != RT_ERR_OK)
 184         return retVal;
 185     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_SEC_L_SEC, sec_l)) != RT_ERR_OK)
 186         return retVal;
 187     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_NSEC_L_NSEC, nsec8_l)) != RT_ERR_OK)
 188         return retVal;
 189
 190     regData = nsec8_h | (PTP_TIME_WRITE<<RTL8367C_PTP_TIME_NSEC_H_CMD_OFFSET) | RTL8367C_PTP_TIME_NSEC_H_EXEC_MASK;
 191
 192     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, regData)) != RT_ERR_OK)
 193         return retVal;
 194
 195     count = 0;
 196     do {
 197         if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, RTL8367C_PTP_TIME_NSEC_H_EXEC_OFFSET, &busyFlag)) != RT_ERR_OK)
 198             return retVal;
 199         count++;
 200     } while ((busyFlag != 0)&&(count<5));
 201
 202     if (busyFlag != 0)
 203         return RT_ERR_BUSYWAIT_TIMEOUT;
 204
 205     return RT_ERR_OK;
 206 }
 207
 208 /* Function Name:
 209  *      rtl8367c_getAsicEavSysTime
 210  * Description:
 211  *      Get PTP system time
 212  * Input:
 213  *      None
 214  * Output:
 215  *      second - seconds
 216  *      nanoSecond - nano seconds
 217  * Return:
 218  *      RT_ERR_OK     - Success
 219  *      RT_ERR_SMI  - SMI access error
 220  * Note:
 221  *      The time granuality is 8 nano seconds.
 222  */
 223 ret_t rtl8367c_getAsicEavSysTime(rtk_uint32* pSecond, rtk_uint32* pNanoSecond)
 224 {
 225     ret_t retVal;
 226     rtk_uint32 sec_h, sec_l, nsec8_h, nsec8_l;
 227     rtk_uint32 nano_second_8;
 228     rtk_uint32 regData, busyFlag, count;
 229
 230     regData = 0;
 231     regData = (PTP_TIME_READ<<RTL8367C_PTP_TIME_NSEC_H_CMD_OFFSET) | RTL8367C_PTP_TIME_NSEC_H_EXEC_MASK;
 232
 233     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, regData)) != RT_ERR_OK)
 234         return retVal;
 235
 236     count = 0;
 237     do {
 238         if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, RTL8367C_PTP_TIME_NSEC_H_EXEC_OFFSET, &busyFlag)) != RT_ERR_OK)
 239             return retVal;
 240         count++;
 241     } while ((busyFlag != 0)&&(count<5));
 242
 243     if (busyFlag != 0)
 244         return RT_ERR_BUSYWAIT_TIMEOUT;
 245
 246     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PTP_TIME_SEC_H_SEC_RD, &sec_h)) != RT_ERR_OK)
 247         return retVal;
 248     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PTP_TIME_SEC_L_SEC_RD, &sec_l)) != RT_ERR_OK)
 249         return retVal;
 250     if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC_RD, RTL8367C_PTP_TIME_NSEC_H_NSEC_RD_MASK,&nsec8_h)) != RT_ERR_OK)
 251         return retVal;
 252     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PTP_TIME_NSEC_L_NSEC_RD, &nsec8_l)) != RT_ERR_OK)
 253         return retVal;
 254
 255     *pSecond = (sec_h<<16) | sec_l;
 256     nano_second_8 = (nsec8_h<<16) | nsec8_l;
 257     *pNanoSecond = nano_second_8<<3;
 258
 259     return RT_ERR_OK;
 260 }
 261
 262
 263 /* Function Name:
 264  *      rtl8367c_setAsicEavSysTimeAdjust
 265  * Description:
 266  *      Set PTP system time adjust
 267  * Input:
 268  *      type - incresae or decrease
 269  *      second - seconds
 270  *      nanoSecond - nano seconds
 271  * Output:
 272  *      None
 273  * Return:
 274  *      RT_ERR_OK     - Success
 275  *      RT_ERR_SMI  - SMI access error
 276  * Note:
 277  *      Ethernet AV second offset of timer for tuning
 278  */
 279 ret_t rtl8367c_setAsicEavSysTimeAdjust(rtk_uint32 type, rtk_uint32 second, rtk_uint32 nanoSecond)
 280 {
 281     ret_t retVal;
 282     rtk_uint32 sec_h, sec_l, nsec8_h, nsec8_l;
 283     rtk_uint32 nano_second_8;
 284     rtk_uint32 regData, busyFlag, count;
 285
 286     if (type >= PTP_TIME_ADJ_END)
 287         return RT_ERR_INPUT;
 288     if(nanoSecond > RTL8367C_EAV_NANOSECONDMAX)
 289         return RT_ERR_INPUT;
 290
 291     regData = 0;
 292     sec_h = second >>16;
 293     sec_l = second & 0xFFFF;
 294     nano_second_8 = nanoSecond >> 3;
 295     nsec8_h = (nano_second_8 >>16) & RTL8367C_PTP_TIME_NSEC_H_NSEC_MASK;
 296     nsec8_l = nano_second_8 &0xFFFF;
 297
 298     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_SEC_H_SEC, sec_h)) != RT_ERR_OK)
 299         return retVal;
 300     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_SEC_L_SEC, sec_l)) != RT_ERR_OK)
 301         return retVal;
 302     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_NSEC_L_NSEC, nsec8_l)) != RT_ERR_OK)
 303         return retVal;
 304
 305     if (PTP_TIME_ADJ_INC == type)
 306         regData = nsec8_h | (PTP_TIME_INC<<RTL8367C_PTP_TIME_NSEC_H_CMD_OFFSET) | RTL8367C_PTP_TIME_NSEC_H_EXEC_MASK;
 307     else
 308         regData = nsec8_h | (PTP_TIME_DEC<<RTL8367C_PTP_TIME_NSEC_H_CMD_OFFSET) | RTL8367C_PTP_TIME_NSEC_H_EXEC_MASK;
 309
 310     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, regData)) != RT_ERR_OK)
 311         return retVal;
 312
 313     count = 0;
 314     do {
 315         if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_PTP_TIME_NSEC_H_NSEC, RTL8367C_PTP_TIME_NSEC_H_EXEC_OFFSET, &busyFlag)) != RT_ERR_OK)
 316             return retVal;
 317         count++;
 318     } while ((busyFlag != 0)&&(count<5));
 319
 320     if (busyFlag != 0)
 321         return RT_ERR_BUSYWAIT_TIMEOUT;
 322
 323     return RT_ERR_OK;
 324 }
 325
 326 /* Function Name:
 327  *      rtl8367c_setAsicEavSysTimeCtrl
 328  * Description:
 329  *      Set PTP system time control
 330  * Input:
 331  *      command - start or stop
 332  * Output:
 333  *      None
 334  * Return:
 335  *      RT_ERR_OK     - Success
 336  *      RT_ERR_SMI  - SMI access error
 337  * Note:
 338  *      None
 339  */
 340 ret_t rtl8367c_setAsicEavSysTimeCtrl(rtk_uint32 control)
 341 {
 342     ret_t  retVal;
 343     rtk_uint32 regData;
 344
 345     if (control>=PTP_TIME_CTRL_END)
 346          return RT_ERR_INPUT;
 347
 348     regData = 0;
 349     if (PTP_TIME_CTRL_START == control)
 350             regData = RTL8367C_CFG_TIMER_EN_FRC_MASK | RTL8367C_CFG_TIMER_1588_EN_MASK;
 351     else
 352         regData = 0;
 353
 354     if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_PTP_TIME_CFG, regData)) != RT_ERR_OK)
 355         return retVal;
 356
 357     return RT_ERR_OK;
 358 }
 359
 360 /* Function Name:
 361  *      rtl8367c_getAsicEavSysTimeCtrl
 362  * Description:
 363  *      Get PTP system time control
 364  * Input:
 365  *      None
 366  * Output:
 367  *      pControl - start or stop
 368  * Return:
 369  *      RT_ERR_OK     - Success
 370  *      RT_ERR_SMI  - SMI access error
 371  * Note:
 372  *      None
 373  */
 374 ret_t rtl8367c_getAsicEavSysTimeCtrl(rtk_uint32* pControl)
 375 {
 376     ret_t  retVal;
 377     rtk_uint32 regData;
 378     rtk_uint32 mask;
 379
 380     mask = RTL8367C_CFG_TIMER_EN_FRC_MASK | RTL8367C_CFG_TIMER_1588_EN_MASK;
 381
 382     if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PTP_TIME_CFG, &regData)) != RT_ERR_OK)
 383         return retVal;
 384
 385     if( (regData & mask) == mask)
 386         *pControl = PTP_TIME_CTRL_START;
 387     else if( (regData & mask) == 0)
 388         *pControl = PTP_TIME_CTRL_STOP;
 389     else
 390         return RT_ERR_NOT_ALLOWED;
 391
 392     return RT_ERR_OK;
 393 }
 394
 395 /* Function Name:
 396  *      rtl8367c_setAsicEavInterruptMask
 397  * Description:
 398  *      Set PTP interrupt enable mask
 399  * Input:
 400  *      imr     - Interrupt mask
 401  * Output:
 402  *      None
 403  * Return:
 404  *      RT_ERR_OK   - Success
 405  *      RT_ERR_SMI  - SMI access error
 406  * Note:
 407  *      [0]:TX_SYNC,
 408  *      [1]:TX_DELAY,
 409  *      [2]:TX_PDELAY_REQ,
 410  *      [3]:TX_PDELAY_RESP,
 411  *      [4]:RX_SYNC,
 412  *      [5]:RX_DELAY,
 413  *      [6]:RX_PDELAY_REQ,
 414  *      [7]:RX_PDELAY_RESP,
 415  */
 416 ret_t rtl8367c_setAsicEavInterruptMask(rtk_uint32 imr)
 417 {
 418     if ((imr&(RTL8367C_PTP_INTR_MASK<<8))>0)
 419          return RT_ERR_INPUT;
 420
 421     return rtl8367c_setAsicRegBits(RTL8367C_REG_PTP_TIME_CFG2, RTL8367C_PTP_INTR_MASK, imr);
 422 }
 423 /* Function Name:
 424  *      rtl8367c_getAsicEavInterruptMask
 425  * Description:
 426  *      Get PTP interrupt enable mask
 427  * Input:
 428  *      pImr    - Interrupt mask
 429  * Output:
 430  *      None
 431  * Return:
 432  *      RT_ERR_OK   - Success
 433  *      RT_ERR_SMI  - SMI access error
 434  * Note:
 435  *      [0]:TX_SYNC,
 436  *      [1]:TX_DELAY,
 437  *      [2]:TX_PDELAY_REQ,
 438  *      [3]:TX_PDELAY_RESP,
 439  *      [4]:RX_SYNC,
 440  *      [5]:RX_DELAY,
 441  *      [6]:RX_PDELAY_REQ,
 442  *      [7]:RX_PDELAY_RESP,
 443  */
 444 ret_t rtl8367c_getAsicEavInterruptMask(rtk_uint32* pImr)
 445 {
 446     return rtl8367c_getAsicRegBits(RTL8367C_REG_PTP_TIME_CFG2, RTL8367C_PTP_INTR_MASK, pImr);
 447 }
 448
 449 /* Function Name:
 450  *      rtl8367c_getAsicEavInterruptStatus
 451  * Description:
 452  *      Get PTP interrupt port status mask
 453  * Input:
 454  *      pIms    - Interrupt mask
 455  * Output:
 456  *      None
 457  * Return:
 458  *      RT_ERR_OK   - Success
 459  *      RT_ERR_SMI  - SMI access error
 460  * Note:
 461  *      [0]:p0 interrupt,
 462  *      [1]:p1 interrupt,
 463  *      [2]:p2 interrupt,
 464  *      [3]:p3 interrupt,
 465  *      [4]:p4 interrupt,
 466  */
 467 ret_t rtl8367c_getAsicEavInterruptStatus(rtk_uint32* pIms)
 468 {
 469     return rtl8367c_getAsicRegBits(RTL8367C_REG_PTP_INTERRUPT_CFG, RTL8367C_PTP_PORT_MASK, pIms);
 470 }
 471
 472 /* Function Name:
 473  *      rtl8367c_setAsicInterruptMask
 474  * Description:
 475  *      Clear interrupt enable mask
 476  * Input:
 477  *      ims     - Interrupt status mask
 478  * Output:
 479  *      None
 480  * Return:
 481  *      RT_ERR_OK   - Success
 482  *      RT_ERR_SMI  - SMI access error
 483  * Note:
 484  *      This API can be used to clear ASIC interrupt status and register will be cleared by writting 1.
 485  *      [0]:TX_SYNC,
 486  *      [1]:TX_DELAY,
 487  *      [2]:TX_PDELAY_REQ,
 488  *      [3]:TX_PDELAY_RESP,
 489  *      [4]:RX_SYNC,
 490  *      [5]:RX_DELAY,
 491  *      [6]:RX_PDELAY_REQ,
 492  *      [7]:RX_PDELAY_RESP,
 493  */
 494 ret_t rtl8367c_setAsicEavPortInterruptStatus(rtk_uint32 port, rtk_uint32 ims)
 495 {
 496
 497     if(port > RTL8367C_PORTNO)
 498         return RT_ERR_PORT_ID;
 499
 500     if(port < 5)
 501         return rtl8367c_setAsicRegBits(RTL8367C_EAV_PORT_CFG_REG(port), RTL8367C_PTP_INTR_MASK,ims);
 502     else if(port == 5)
 503         return rtl8367c_setAsicRegBits(RTL8367C_REG_P5_EAV_CFG, RTL8367C_PTP_INTR_MASK,ims);
 504     else if(port == 6)
 505         return rtl8367c_setAsicRegBits(RTL8367C_REG_P6_EAV_CFG, RTL8367C_PTP_INTR_MASK,ims);
 506     else if(port == 7)
 507         return rtl8367c_setAsicRegBits(RTL8367C_REG_P7_EAV_CFG, RTL8367C_PTP_INTR_MASK,ims);
 508     else if(port == 8)
 509         return rtl8367c_setAsicRegBits(RTL8367C_REG_P8_EAV_CFG, RTL8367C_PTP_INTR_MASK,ims);
 510     else if(port == 9)
 511         return rtl8367c_setAsicRegBits(RTL8367C_REG_P9_EAV_CFG, RTL8367C_PTP_INTR_MASK,ims);
 512
 513     return RT_ERR_OK;
 514 }
 515 /* Function Name:
 516  *      rtl8367c_getAsicInterruptStatus
 517  * Description:
 518  *      Get interrupt enable mask
 519  * Input:
 520  *      pIms    - Interrupt status mask
 521  * Output:
 522  *      None
 523  * Return:
 524  *      RT_ERR_OK   - Success
 525  *      RT_ERR_SMI  - SMI access error
 526  * Note:
 527  *      [0]:TX_SYNC,
 528  *      [1]:TX_DELAY,
 529  *      [2]:TX_PDELAY_REQ,
 530  *      [3]:TX_PDELAY_RESP,
 531  *      [4]:RX_SYNC,
 532  *      [5]:RX_DELAY,
 533  *      [6]:RX_PDELAY_REQ,
 534  *      [7]:RX_PDELAY_RESP,
 535  */
 536 ret_t rtl8367c_getAsicEavPortInterruptStatus(rtk_uint32 port, rtk_uint32* pIms)
 537 {
 538
 539     if(port > RTL8367C_PORTNO)
 540         return RT_ERR_PORT_ID;
 541     if(port < 5)
 542         return rtl8367c_getAsicRegBits(RTL8367C_EAV_PORT_CFG_REG(port), RTL8367C_PTP_INTR_MASK, pIms);
 543     else if(port == 5)
 544         return rtl8367c_getAsicRegBits(RTL8367C_REG_P5_EAV_CFG, RTL8367C_PTP_INTR_MASK, pIms);
 545     else if(port == 6)
 546         return rtl8367c_getAsicRegBits(RTL8367C_REG_P6_EAV_CFG, RTL8367C_PTP_INTR_MASK,pIms);
 547     else if(port == 7)
 548         return rtl8367c_getAsicRegBits(RTL8367C_REG_P7_EAV_CFG, RTL8367C_PTP_INTR_MASK,pIms);
 549     else if(port == 8)
 550         return rtl8367c_getAsicRegBits(RTL8367C_REG_P8_EAV_CFG, RTL8367C_PTP_INTR_MASK,pIms);
 551     else if(port == 9)
 552         return rtl8367c_getAsicRegBits(RTL8367C_REG_P9_EAV_CFG, RTL8367C_PTP_INTR_MASK,pIms);
 553
 554     return RT_ERR_OK;
 555
 556 }
 557
 558
 559 /* Function Name:
 560  *      rtl8367c_setAsicEavPortEnable
 561  * Description:
 562  *      Set per-port EAV function enable/disable
 563  * Input:
 564  *      port         - Physical port number (0~9)
 565  *      enabled     - 1: enabled, 0: disabled
 566  * Output:
 567  *      None
 568  * Return:
 569  *      RT_ERR_OK         - Success
 570  *      RT_ERR_SMI      - SMI access error
 571  *      RT_ERR_PORT_ID  - Invalid port number
 572  * Note:
 573  *      If EAV function is enabled, PTP event messgae packet will be attached PTP timestamp for trapping
 574  */
 575 ret_t rtl8367c_setAsicEavPortEnable(rtk_uint32 port, rtk_uint32 enabled)
 576 {
 577     if(port > RTL8367C_PORTNO)
 578         return RT_ERR_PORT_ID;
 579
 580     if(port < 5)
 581         return rtl8367c_setAsicRegBit(RTL8367C_EAV_PORT_CFG_REG(port), RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 582     else if(port == 5)
 583         return rtl8367c_setAsicRegBit(RTL8367C_REG_P5_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 584     else if(port == 6)
 585         return rtl8367c_setAsicRegBit(RTL8367C_REG_P6_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 586     else if(port == 7)
 587         return rtl8367c_setAsicRegBit(RTL8367C_REG_P7_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 588     else if(port == 8)
 589         return rtl8367c_setAsicRegBit(RTL8367C_REG_P8_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 590     else if(port == 9)
 591         return rtl8367c_setAsicRegBit(RTL8367C_REG_P9_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, enabled);
 592
 593
 594     return RT_ERR_OK;
 595 }
 596 /* Function Name:
 597  *      rtl8367c_getAsicEavPortEnable
 598  * Description:
 599  *      Get per-port EAV function enable/disable
 600  * Input:
 601  *      port         - Physical port number (0~9)
 602  *      pEnabled     - 1: enabled, 0: disabled
 603  * Output:
 604  *      None
 605  * Return:
 606  *      RT_ERR_OK         - Success
 607  *      RT_ERR_SMI      - SMI access error
 608  *      RT_ERR_PORT_ID  - Invalid port number
 609  * Note:
 610  *      None
 611  */
 612 ret_t rtl8367c_getAsicEavPortEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
 613 {
 614     if(port > RTL8367C_PORTNO)
 615         return RT_ERR_PORT_ID;
 616
 617
 618
 619     if(port < 5)
 620         return rtl8367c_getAsicRegBit(RTL8367C_EAV_PORT_CFG_REG(port), RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 621     else if(port == 5)
 622         return rtl8367c_getAsicRegBit(RTL8367C_REG_P5_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 623     else if(port == 6)
 624         return rtl8367c_getAsicRegBit(RTL8367C_REG_P6_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 625     else if(port == 7)
 626         return rtl8367c_getAsicRegBit(RTL8367C_REG_P7_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 627     else if(port == 8)
 628         return rtl8367c_getAsicRegBit(RTL8367C_REG_P8_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 629     else if(port == 9)
 630         return rtl8367c_getAsicRegBit(RTL8367C_REG_P9_EAV_CFG, RTL8367C_EAV_CFG_PTP_PHY_EN_EN_OFFSET, pEnabled);
 631
 632
 633     return RT_ERR_OK;
 634 }
 635
 636 /* Function Name:
 637  *      rtl8367c_getAsicEavPortTimeStamp
 638  * Description:
 639  *      Get PTP port time stamp
 640  * Input:
 641  *      port         - Physical port number (0~9)
 642  *      type     -  PTP packet type
 643  * Output:
 644  *      timeStamp - seconds
 645  * Return:
 646  *      RT_ERR_OK     - Success
 647  *      RT_ERR_SMI  - SMI access error
 648  * Note:
 649  *      The time granuality is 8 nano seconds.
 650  */
 651 ret_t rtl8367c_getAsicEavPortTimeStamp(rtk_uint32 port, rtk_uint32 type, rtl8367c_ptp_time_stamp_t* timeStamp)
 652 {
 653     ret_t retVal;
 654     rtk_uint32 sec_h, sec_l, nsec8_h, nsec8_l;
 655     rtk_uint32 nano_second_8;
 656
 657     if(port > 9)
 658         return RT_ERR_PORT_ID;
 659     if(type >= PTP_PKT_TYPE_END)
 660         return RT_ERR_INPUT;
 661
 662     if(port < 5){
 663         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_SEQ_ID(port, type), &timeStamp->sequence_id))!=  RT_ERR_OK)
 664             return retVal;
 665         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PORT_SEC_H(port) , &sec_h)) != RT_ERR_OK)
 666            return retVal;
 667         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PORT_SEC_L(port), &sec_l)) != RT_ERR_OK)
 668            return retVal;
 669         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_PORT_NSEC_H(port) , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 670            return retVal;
 671         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_PORT_NSEC_L(port) , &nsec8_l)) != RT_ERR_OK)
 672            return retVal;
 673     }else if(port == 5){
 674         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P5_TX_SYNC_SEQ_ID+type, &timeStamp->sequence_id))!=  RT_ERR_OK)
 675             return retVal;
 676         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P5_PORT_SEC_31_16, &sec_h)) != RT_ERR_OK)
 677            return retVal;
 678         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P5_PORT_SEC_15_0, &sec_l)) != RT_ERR_OK)
 679            return retVal;
 680         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_P5_PORT_NSEC_26_16 , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 681            return retVal;
 682         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P5_PORT_NSEC_15_0, &nsec8_l)) != RT_ERR_OK)
 683            return retVal;
 684     }else if(port == 6){
 685         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P6_TX_SYNC_SEQ_ID+type, &timeStamp->sequence_id))!=  RT_ERR_OK)
 686             return retVal;
 687         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P6_PORT_SEC_31_16, &sec_h)) != RT_ERR_OK)
 688            return retVal;
 689         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P6_PORT_SEC_15_0, &sec_l)) != RT_ERR_OK)
 690            return retVal;
 691         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_P6_PORT_NSEC_26_16 , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 692            return retVal;
 693         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P6_PORT_NSEC_15_0, &nsec8_l)) != RT_ERR_OK)
 694            return retVal;
 695     }else if(port == 7){
 696         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P7_TX_SYNC_SEQ_ID+type, &timeStamp->sequence_id))!=  RT_ERR_OK)
 697             return retVal;
 698         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P7_PORT_SEC_31_16, &sec_h)) != RT_ERR_OK)
 699            return retVal;
 700         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P7_PORT_SEC_15_0, &sec_l)) != RT_ERR_OK)
 701            return retVal;
 702         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_P7_PORT_NSEC_26_16 , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 703            return retVal;
 704         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P7_PORT_NSEC_15_0, &nsec8_l)) != RT_ERR_OK)
 705            return retVal;
 706     }else if(port == 8){
 707         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P8_TX_SYNC_SEQ_ID+type, &timeStamp->sequence_id))!=  RT_ERR_OK)
 708             return retVal;
 709         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P8_PORT_SEC_31_16, &sec_h)) != RT_ERR_OK)
 710            return retVal;
 711         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P8_PORT_SEC_15_0, &sec_l)) != RT_ERR_OK)
 712            return retVal;
 713         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_P8_PORT_NSEC_26_16 , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 714            return retVal;
 715         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P8_PORT_NSEC_15_0, &nsec8_l)) != RT_ERR_OK)
 716            return retVal;
 717     }else if(port == 9){
 718         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P9_TX_SYNC_SEQ_ID+type, &timeStamp->sequence_id))!=  RT_ERR_OK)
 719             return retVal;
 720         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P9_PORT_SEC_31_16, &sec_h)) != RT_ERR_OK)
 721            return retVal;
 722         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P9_PORT_SEC_15_0, &sec_l)) != RT_ERR_OK)
 723            return retVal;
 724         if((retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_P9_PORT_NSEC_26_16 , RTL8367C_PORT_NSEC_H_MASK,&nsec8_h)) != RT_ERR_OK)
 725            return retVal;
 726         if((retVal = rtl8367c_getAsicReg(RTL8367C_REG_P9_PORT_NSEC_15_0, &nsec8_l)) != RT_ERR_OK)
 727            return retVal;
 728     }
 729
 730     timeStamp->second = (sec_h<<16) | sec_l;
 731     nano_second_8 = (nsec8_h<<16) | nsec8_l;
 732     timeStamp->nano_second = nano_second_8<<3;
 733
 734     return RT_ERR_OK;
 735 }
 736
 737
 738 /* Function Name:
 739  *      rtl8367c_setAsicEavTrap
 740  * Description:
 741  *      Set per-port PTP packet trap to CPU
 742  * Input:
 743  *      port         - Physical port number (0~5)
 744  *      enabled     - 1: enabled, 0: disabled
 745  * Output:
 746  *      None
 747  * Return:
 748  *      RT_ERR_OK         - Success
 749  *      RT_ERR_SMI      - SMI access error
 750  *      RT_ERR_PORT_ID  - Invalid port number
 751  * Note:
 752  *      If EAV trap enabled, switch will trap PTP packet to CPU
 753  */
 754 ret_t rtl8367c_setAsicEavTrap(rtk_uint32 port, rtk_uint32 enabled)
 755 {
 756     if(port > RTL8367C_PORTNO)
 757         return RT_ERR_PORT_ID;
 758
 759     return rtl8367c_setAsicRegBit(RTL8367C_REG_PTP_PORT0_CFG1 + (port * 0x20), RTL8367C_PTP_PORT0_CFG1_OFFSET, enabled);
 760 }
 761 /* Function Name:
 762  *      rtl8367c_getAsicEavTimeSyncEn
 763  * Description:
 764  *      Get per-port EPTP packet trap to CPU
 765  * Input:
 766  *      port         - Physical port number (0~5)
 767  *      pEnabled     - 1: enabled, 0: disabled
 768  * Output:
 769  *      None
 770  * Return:
 771  *      RT_ERR_OK         - Success
 772  *      RT_ERR_SMI      - SMI access error
 773  *      RT_ERR_PORT_ID  - Invalid port number
 774  * Note:
 775  *      None
 776  */
 777 ret_t rtl8367c_getAsicEavTrap(rtk_uint32 port, rtk_uint32 *pEnabled)
 778 {
 779     if(port > RTL8367C_PORTNO)
 780         return RT_ERR_PORT_ID;
 781
 782     return rtl8367c_getAsicRegBit(RTL8367C_REG_PTP_PORT0_CFG1 + (port * 0x20), RTL8367C_PTP_PORT0_CFG1_OFFSET, pEnabled);
 783 }
 784
 785 /* Function Name:
 786  *      rtl8367c_setAsicEavEnable
 787  * Description:
 788  *      Set per-port EAV function enable/disable
 789  * Input:
 790  *      port         - Physical port number (0~5)
 791  *      enabled     - 1: enabled, 0: disabled
 792  * Output:
 793  *      None
 794  * Return:
 795  *      RT_ERR_OK         - Success
 796  *      RT_ERR_SMI      - SMI access error
 797  *      RT_ERR_PORT_ID  - Invalid port number
 798  * Note:
 799  *      If EAV function is enabled, PTP event messgae packet will be attached PTP timestamp for trapping
 800  */
 801 ret_t rtl8367c_setAsicEavEnable(rtk_uint32 port, rtk_uint32 enabled)
 802 {
 803     if(port > RTL8367C_PORTNO)
 804         return RT_ERR_PORT_ID;
 805
 806     return rtl8367c_setAsicRegBit(RTL8367C_REG_EAV_CTRL0, port, enabled);
 807 }
 808 /* Function Name:
 809  *      rtl8367c_getAsicEavEnable
 810  * Description:
 811  *      Get per-port EAV function enable/disable
 812  * Input:
 813  *      port         - Physical port number (0~5)
 814  *      pEnabled     - 1: enabled, 0: disabled
 815  * Output:
 816  *      None
 817  * Return:
 818  *      RT_ERR_OK         - Success
 819  *      RT_ERR_SMI      - SMI access error
 820  *      RT_ERR_PORT_ID  - Invalid port number
 821  * Note:
 822  *      None
 823  */
 824 ret_t rtl8367c_getAsicEavEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
 825 {
 826     if(port > RTL8367C_PORTNO)
 827         return RT_ERR_PORT_ID;
 828
 829     return rtl8367c_getAsicRegBit(RTL8367C_REG_EAV_CTRL0, port, pEnabled);
 830 }
 831 /* Function Name:
 832  *      rtl8367c_setAsicEavPriRemapping
 833  * Description:
 834  *      Set non-EAV streaming priority remapping
 835  * Input:
 836  *      srcpriority - Priority value
 837  *      priority     - Absolute priority value
 838  * Output:
 839  *      None
 840  * Return:
 841  *      RT_ERR_OK                     - Success
 842  *      RT_ERR_SMI                  - SMI access error
 843  *      RT_ERR_QOS_INT_PRIORITY      - Invalid priority
 844  * Note:
 845  *      None
 846  */
 847 ret_t rtl8367c_setAsicEavPriRemapping(rtk_uint32 srcpriority, rtk_uint32 priority)
 848 {
 849     if(srcpriority > RTL8367C_PRIMAX || priority > RTL8367C_PRIMAX)
 850         return RT_ERR_QOS_INT_PRIORITY;
 851
 852     return rtl8367c_setAsicRegBits(RTL8367C_EAV_PRIORITY_REMAPPING_REG(srcpriority), RTL8367C_EAV_PRIORITY_REMAPPING_MASK(srcpriority),priority);
 853 }
 854 /* Function Name:
 855  *      rtl8367c_getAsicEavPriRemapping
 856  * Description:
 857  *      Get non-EAV streaming priority remapping
 858  * Input:
 859  *      srcpriority - Priority value
 860  *      pPriority     - Absolute priority value
 861  * Output:
 862  *      None
 863  * Return:
 864  *      RT_ERR_OK                     - Success
 865  *      RT_ERR_SMI                  - SMI access error
 866  *      RT_ERR_QOS_INT_PRIORITY      - Invalid priority
 867  * Note:
 868  *      None
 869  */
 870 ret_t rtl8367c_getAsicEavPriRemapping(rtk_uint32 srcpriority, rtk_uint32 *pPriority)
 871 {
 872     if(srcpriority > RTL8367C_PRIMAX )
 873         return RT_ERR_QOS_INT_PRIORITY;
 874
 875     return rtl8367c_getAsicRegBits(RTL8367C_EAV_PRIORITY_REMAPPING_REG(srcpriority), RTL8367C_EAV_PRIORITY_REMAPPING_MASK(srcpriority),pPriority);
 876 }
 877