target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv.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 :
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv.h>
  19
  20 #if defined(RTK_X86_ASICDRV)
  21 #include <I2Clib.h>
  22 #else
  23 #include <smi.h>
  24 #endif
  25
  26 /*for driver verify testing only*/
  27 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
  28 #define CLE_VIRTUAL_REG_SIZE        0x10000
  29 rtk_uint16 CleVirtualReg[CLE_VIRTUAL_REG_SIZE];
  30 #endif
  31
  32 #if defined(CONFIG_RTL865X_CLE) || defined (RTK_X86_CLE)
  33 rtk_uint32 cleDebuggingDisplay;
  34 #endif
  35
  36 #ifdef EMBEDDED_SUPPORT
  37 extern void setReg(rtk_uint16, rtk_uint16);
  38 extern rtk_uint16 getReg(rtk_uint16);
  39 #endif
  40
  41 /* Function Name:
  42  *      rtl8367c_setAsicRegBit
  43  * Description:
  44  *      Set a bit value of a specified register
  45  * Input:
  46  *      reg     - register's address
  47  *      bit     - bit location
  48  *      value   - value to set. It can be value 0 or 1.
  49  * Output:
  50  *      None
  51  * Return:
  52  *      RT_ERR_OK       - Success
  53  *      RT_ERR_SMI      - SMI access error
  54  *      RT_ERR_INPUT    - Invalid input parameter
  55  * Note:
  56  *      Set a bit of a specified register to 1 or 0.
  57  */
  58 ret_t rtl8367c_setAsicRegBit(rtk_uint32 reg, rtk_uint32 bit, rtk_uint32 value)
  59 {
  60
  61 #if defined(RTK_X86_ASICDRV)
  62     rtk_uint32 regData;
  63     ret_t retVal;
  64
  65     if(bit >= RTL8367C_REGBITLENGTH)
  66         return RT_ERR_INPUT;
  67
  68     retVal = Access_Read(reg, 2, &regData);
  69     if(TRUE != retVal)
  70         return RT_ERR_SMI;
  71
  72     if(0x8367B == cleDebuggingDisplay)
  73         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
  74
  75     if(value)
  76         regData = regData | (1 << bit);
  77     else
  78         regData = regData & (~(1 << bit));
  79
  80     retVal = Access_Write(reg,2, regData);
  81     if(TRUE != retVal)
  82         return RT_ERR_SMI;
  83
  84     if(0x8367B == cleDebuggingDisplay)
  85         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, regData);
  86
  87
  88 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
  89
  90     if(bit >= RTL8367C_REGBITLENGTH)
  91         return RT_ERR_INPUT;
  92
  93     else if(reg >= CLE_VIRTUAL_REG_SIZE)
  94         return RT_ERR_OUT_OF_RANGE;
  95
  96     if(value)
  97     {
  98         CleVirtualReg[reg] =  CleVirtualReg[reg] | (1 << bit);
  99     }
 100     else
 101     {
 102         CleVirtualReg[reg] =  CleVirtualReg[reg] & (~(1 << bit));
 103     }
 104
 105     if(0x8367B == cleDebuggingDisplay)
 106         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, CleVirtualReg[reg]);
 107
 108 #elif defined(EMBEDDED_SUPPORT)
 109     rtk_uint16 tmp;
 110
 111     if(reg > RTL8367C_REGDATAMAX || value > 1)
 112         return RT_ERR_INPUT;
 113
 114     tmp = getReg(reg);
 115     tmp &= (1 << bitIdx);
 116     tmp |= (value << bitIdx);
 117     setReg(reg, tmp);
 118
 119 #else
 120     rtk_uint32 regData;
 121     ret_t retVal;
 122
 123     if(bit >= RTL8367C_REGBITLENGTH)
 124         return RT_ERR_INPUT;
 125
 126     retVal = smi_read(reg, &regData);
 127     if(retVal != RT_ERR_OK)
 128         return RT_ERR_SMI;
 129
 130   #ifdef CONFIG_RTL865X_CLE
 131     if(0x8367B == cleDebuggingDisplay)
 132         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 133   #endif
 134     if(value)
 135         regData = regData | (1 << bit);
 136     else
 137         regData = regData & (~(1 << bit));
 138
 139     retVal = smi_write(reg, regData);
 140     if(retVal != RT_ERR_OK)
 141         return RT_ERR_SMI;
 142
 143   #ifdef CONFIG_RTL865X_CLE
 144     if(0x8367B == cleDebuggingDisplay)
 145         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, regData);
 146   #endif
 147
 148 #endif
 149     return RT_ERR_OK;
 150 }
 151 /* Function Name:
 152  *      rtl8367c_getAsicRegBit
 153  * Description:
 154  *      Get a bit value of a specified register
 155  * Input:
 156  *      reg     - register's address
 157  *      bit     - bit location
 158  *      value   - value to get.
 159  * Output:
 160  *      None
 161  * Return:
 162  *      RT_ERR_OK       - Success
 163  *      RT_ERR_SMI      - SMI access error
 164  *      RT_ERR_INPUT    - Invalid input parameter
 165  * Note:
 166  *      None
 167  */
 168 ret_t rtl8367c_getAsicRegBit(rtk_uint32 reg, rtk_uint32 bit, rtk_uint32 *pValue)
 169 {
 170
 171 #if defined(RTK_X86_ASICDRV)
 172
 173     rtk_uint32 regData;
 174     ret_t retVal;
 175
 176     if(bit >= RTL8367C_REGBITLENGTH)
 177         return RT_ERR_INPUT;
 178
 179     retVal = Access_Read(reg, 2, &regData);
 180     if(TRUE != retVal)
 181         return RT_ERR_SMI;
 182
 183     *pValue = (regData & (0x1 << bit)) >> bit;
 184
 185     if(0x8367B == cleDebuggingDisplay)
 186         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 187
 188 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
 189
 190     if(bit >= RTL8367C_REGBITLENGTH)
 191         return RT_ERR_INPUT;
 192
 193     if(reg >= CLE_VIRTUAL_REG_SIZE)
 194         return RT_ERR_OUT_OF_RANGE;
 195
 196     *pValue = (CleVirtualReg[reg] & (0x1 << bit)) >> bit;
 197
 198     if(0x8367B == cleDebuggingDisplay)
 199         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, CleVirtualReg[reg]);
 200
 201 #elif defined(EMBEDDED_SUPPORT)
 202     rtk_uint16 tmp;
 203
 204     if(reg > RTL8367C_REGDATAMAX )
 205         return RT_ERR_INPUT;
 206
 207     tmp = getReg(reg);
 208     tmp = tmp >> bitIdx;
 209     tmp &= 1;
 210     *value = tmp;
 211 #else
 212     rtk_uint32 regData;
 213     ret_t retVal;
 214
 215     retVal = smi_read(reg, &regData);
 216     if(retVal != RT_ERR_OK)
 217         return RT_ERR_SMI;
 218
 219   #ifdef CONFIG_RTL865X_CLE
 220     if(0x8367B == cleDebuggingDisplay)
 221         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 222   #endif
 223
 224     *pValue = (regData & (0x1 << bit)) >> bit;
 225
 226 #endif
 227     return RT_ERR_OK;
 228 }
 229 /* Function Name:
 230  *      rtl8367c_setAsicRegBits
 231  * Description:
 232  *      Set bits value of a specified register
 233  * Input:
 234  *      reg     - register's address
 235  *      bits    - bits mask for setting
 236  *      value   - bits value for setting
 237  * Output:
 238  *      None
 239  * Return:
 240  *      RT_ERR_OK       - Success
 241  *      RT_ERR_SMI      - SMI access error
 242  *      RT_ERR_INPUT    - Invalid input parameter
 243  * Note:
 244  *      Set bits of a specified register to value. Both bits and value are be treated as bit-mask
 245  */
 246 ret_t rtl8367c_setAsicRegBits(rtk_uint32 reg, rtk_uint32 bits, rtk_uint32 value)
 247 {
 248
 249 #if defined(RTK_X86_ASICDRV)
 250
 251     rtk_uint32 regData;
 252     ret_t retVal;
 253     rtk_uint32 bitsShift;
 254     rtk_uint32 valueShifted;
 255
 256     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 257         return RT_ERR_INPUT;
 258
 259     bitsShift = 0;
 260     while(!(bits & (1 << bitsShift)))
 261     {
 262         bitsShift++;
 263         if(bitsShift >= RTL8367C_REGBITLENGTH)
 264             return RT_ERR_INPUT;
 265     }
 266
 267     valueShifted = value << bitsShift;
 268     if(valueShifted > RTL8367C_REGDATAMAX)
 269         return RT_ERR_INPUT;
 270
 271     retVal = Access_Read(reg, 2, &regData);
 272     if(TRUE != retVal)
 273         return RT_ERR_SMI;
 274
 275     if(0x8367B == cleDebuggingDisplay)
 276         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 277
 278     regData = regData & (~bits);
 279     regData = regData | (valueShifted & bits);
 280
 281     retVal = Access_Write(reg,2, regData);
 282     if(TRUE != retVal)
 283         return RT_ERR_SMI;
 284
 285     if(0x8367B == cleDebuggingDisplay)
 286         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, regData);
 287
 288 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
 289     rtk_uint32 regData;
 290     rtk_uint32 bitsShift;
 291     rtk_uint32 valueShifted;
 292
 293     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 294         return RT_ERR_INPUT;
 295
 296     bitsShift = 0;
 297     while(!(bits & (1 << bitsShift)))
 298     {
 299         bitsShift++;
 300         if(bitsShift >= RTL8367C_REGBITLENGTH)
 301             return RT_ERR_INPUT;
 302     }
 303     valueShifted = value << bitsShift;
 304
 305     if(valueShifted > RTL8367C_REGDATAMAX)
 306         return RT_ERR_INPUT;
 307
 308     if(reg >= CLE_VIRTUAL_REG_SIZE)
 309         return RT_ERR_OUT_OF_RANGE;
 310
 311     regData = CleVirtualReg[reg] & (~bits);
 312     regData = regData | (valueShifted & bits);
 313
 314     CleVirtualReg[reg] = regData;
 315
 316     if(0x8367B == cleDebuggingDisplay)
 317         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, regData);
 318
 319 #elif defined(EMBEDDED_SUPPORT)
 320     rtk_uint32 regData;
 321     rtk_uint32 bitsShift;
 322     rtk_uint32 valueShifted;
 323
 324     if(reg > RTL8367C_REGDATAMAX )
 325         return RT_ERR_INPUT;
 326
 327     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 328         return RT_ERR_INPUT;
 329
 330     bitsShift = 0;
 331     while(!(bits & (1 << bitsShift)))
 332     {
 333         bitsShift++;
 334         if(bitsShift >= RTL8367C_REGBITLENGTH)
 335             return RT_ERR_INPUT;
 336     }
 337
 338     valueShifted = value << bitsShift;
 339     if(valueShifted > RTL8367C_REGDATAMAX)
 340         return RT_ERR_INPUT;
 341
 342     regData = getReg(reg);
 343     regData = regData & (~bits);
 344     regData = regData | (valueShifted & bits);
 345
 346     setReg(reg, regData);
 347
 348 #else
 349     rtk_uint32 regData;
 350     ret_t retVal;
 351     rtk_uint32 bitsShift;
 352     rtk_uint32 valueShifted;
 353
 354     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 355         return RT_ERR_INPUT;
 356
 357     bitsShift = 0;
 358     while(!(bits & (1 << bitsShift)))
 359     {
 360         bitsShift++;
 361         if(bitsShift >= RTL8367C_REGBITLENGTH)
 362             return RT_ERR_INPUT;
 363     }
 364     valueShifted = value << bitsShift;
 365
 366     if(valueShifted > RTL8367C_REGDATAMAX)
 367         return RT_ERR_INPUT;
 368
 369     retVal = smi_read(reg, &regData);
 370     if(retVal != RT_ERR_OK)
 371         return RT_ERR_SMI;
 372   #ifdef CONFIG_RTL865X_CLE
 373     if(0x8367B == cleDebuggingDisplay)
 374         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 375   #endif
 376
 377     regData = regData & (~bits);
 378     regData = regData | (valueShifted & bits);
 379
 380     retVal = smi_write(reg, regData);
 381     if(retVal != RT_ERR_OK)
 382         return RT_ERR_SMI;
 383   #ifdef CONFIG_RTL865X_CLE
 384     if(0x8367B == cleDebuggingDisplay)
 385         PRINT("W[0x%4.4x]=0x%4.4x\n", reg, regData);
 386   #endif
 387 #endif
 388     return RT_ERR_OK;
 389 }
 390 /* Function Name:
 391  *      rtl8367c_getAsicRegBits
 392  * Description:
 393  *      Get bits value of a specified register
 394  * Input:
 395  *      reg     - register's address
 396  *      bits    - bits mask for setting
 397  *      value   - bits value for setting
 398  * Output:
 399  *      None
 400  * Return:
 401  *      RT_ERR_OK       - Success
 402  *      RT_ERR_SMI      - SMI access error
 403  *      RT_ERR_INPUT    - Invalid input parameter
 404  * Note:
 405  *      None
 406  */
 407 ret_t rtl8367c_getAsicRegBits(rtk_uint32 reg, rtk_uint32 bits, rtk_uint32 *pValue)
 408 {
 409
 410 #if defined(RTK_X86_ASICDRV)
 411
 412     rtk_uint32 regData;
 413     ret_t retVal;
 414     rtk_uint32 bitsShift;
 415
 416     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 417         return RT_ERR_INPUT;
 418
 419     bitsShift = 0;
 420     while(!(bits & (1 << bitsShift)))
 421     {
 422         bitsShift++;
 423         if(bitsShift >= RTL8367C_REGBITLENGTH)
 424             return RT_ERR_INPUT;
 425     }
 426
 427     retVal = Access_Read(reg, 2, &regData);
 428     if(TRUE != retVal)
 429         return RT_ERR_SMI;
 430
 431     *pValue = (regData & bits) >> bitsShift;
 432
 433     if(0x8367B == cleDebuggingDisplay)
 434         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 435
 436 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
 437     rtk_uint32 bitsShift;
 438
 439     if(bits >= (1 << RTL8367C_REGBITLENGTH) )
 440         return RT_ERR_INPUT;
 441
 442     bitsShift = 0;
 443     while(!(bits & (1 << bitsShift)))
 444     {
 445         bitsShift++;
 446         if(bitsShift >= RTL8367C_REGBITLENGTH)
 447             return RT_ERR_INPUT;
 448     }
 449
 450     if(reg >= CLE_VIRTUAL_REG_SIZE)
 451         return RT_ERR_OUT_OF_RANGE;
 452
 453      *pValue = (CleVirtualReg[reg] & bits) >> bitsShift;
 454
 455     if(0x8367B == cleDebuggingDisplay)
 456         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, CleVirtualReg[reg]);
 457
 458 #elif defined(EMBEDDED_SUPPORT)
 459     rtk_uint32 regData;
 460     rtk_uint32 bitsShift;
 461
 462     if(reg > RTL8367C_REGDATAMAX )
 463         return RT_ERR_INPUT;
 464
 465     if(bits >= (1UL << RTL8367C_REGBITLENGTH) )
 466         return RT_ERR_INPUT;
 467
 468     bitsShift = 0;
 469     while(!(bits & (1UL << bitsShift)))
 470     {
 471         bitsShift++;
 472         if(bitsShift >= RTL8367C_REGBITLENGTH)
 473             return RT_ERR_INPUT;
 474     }
 475
 476     regData = getReg(reg);
 477     *value = (regData & bits) >> bitsShift;
 478
 479 #else
 480     rtk_uint32 regData;
 481     ret_t retVal;
 482     rtk_uint32 bitsShift;
 483
 484     if(bits>= (1<<RTL8367C_REGBITLENGTH) )
 485         return RT_ERR_INPUT;
 486
 487     bitsShift = 0;
 488     while(!(bits & (1 << bitsShift)))
 489     {
 490         bitsShift++;
 491         if(bitsShift >= RTL8367C_REGBITLENGTH)
 492             return RT_ERR_INPUT;
 493     }
 494
 495     retVal = smi_read(reg, &regData);
 496     if(retVal != RT_ERR_OK) return RT_ERR_SMI;
 497
 498     *pValue = (regData & bits) >> bitsShift;
 499   #ifdef CONFIG_RTL865X_CLE
 500     if(0x8367B == cleDebuggingDisplay)
 501         PRINT("R[0x%4.4x]=0x%4.4x\n",reg, regData);
 502   #endif
 503
 504 #endif
 505     return RT_ERR_OK;
 506 }
 507 /* Function Name:
 508  *      rtl8367c_setAsicReg
 509  * Description:
 510  *      Set content of asic register
 511  * Input:
 512  *      reg     - register's address
 513  *      value   - Value setting to register
 514  * Output:
 515  *      None
 516  * Return:
 517  *      RT_ERR_OK       - Success
 518  *      RT_ERR_SMI      - SMI access error
 519  * Note:
 520  *      The value will be set to ASIC mapping address only and it is always return RT_ERR_OK while setting un-mapping address registers
 521  */
 522 ret_t rtl8367c_setAsicReg(rtk_uint32 reg, rtk_uint32 value)
 523 {
 524 #if defined(RTK_X86_ASICDRV)/*RTK-CNSD2-NickWu-20061222: for x86 compile*/
 525
 526     ret_t retVal;
 527
 528     retVal = Access_Write(reg,2,value);
 529     if(TRUE != retVal) return RT_ERR_SMI;
 530
 531     if(0x8367B == cleDebuggingDisplay)
 532         PRINT("W[0x%4.4x]=0x%4.4x\n",reg,value);
 533
 534 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
 535
 536     /*MIBs emulating*/
 537     if(reg == RTL8367C_REG_MIB_ADDRESS)
 538     {
 539         CleVirtualReg[RTL8367C_MIB_COUNTER_BASE_REG] = 0x1;
 540         CleVirtualReg[RTL8367C_MIB_COUNTER_BASE_REG+1] = 0x2;
 541         CleVirtualReg[RTL8367C_MIB_COUNTER_BASE_REG+2] = 0x3;
 542         CleVirtualReg[RTL8367C_MIB_COUNTER_BASE_REG+3] = 0x4;
 543     }
 544
 545     if(reg >= CLE_VIRTUAL_REG_SIZE)
 546         return RT_ERR_OUT_OF_RANGE;
 547
 548     CleVirtualReg[reg] = value;
 549
 550     if(0x8367B == cleDebuggingDisplay)
 551         PRINT("W[0x%4.4x]=0x%4.4x\n",reg,CleVirtualReg[reg]);
 552
 553 #elif defined(EMBEDDED_SUPPORT)
 554     if(reg > RTL8367C_REGDATAMAX || value > RTL8367C_REGDATAMAX )
 555         return RT_ERR_INPUT;
 556
 557     setReg(reg, value);
 558
 559 #else
 560     ret_t retVal;
 561
 562     retVal = smi_write(reg, value);
 563     if(retVal != RT_ERR_OK)
 564         return RT_ERR_SMI;
 565   #ifdef CONFIG_RTL865X_CLE
 566     if(0x8367B == cleDebuggingDisplay)
 567         PRINT("W[0x%4.4x]=0x%4.4x\n",reg,value);
 568   #endif
 569
 570 #endif
 571
 572     return RT_ERR_OK;
 573 }
 574 /* Function Name:
 575  *      rtl8367c_getAsicReg
 576  * Description:
 577  *      Get content of asic register
 578  * Input:
 579  *      reg     - register's address
 580  *      value   - Value setting to register
 581  * Output:
 582  *      None
 583  * Return:
 584  *      RT_ERR_OK       - Success
 585  *      RT_ERR_SMI      - SMI access error
 586  * Note:
 587  *      Value 0x0000 will be returned for ASIC un-mapping address
 588  */
 589 ret_t rtl8367c_getAsicReg(rtk_uint32 reg, rtk_uint32 *pValue)
 590 {
 591
 592 #if defined(RTK_X86_ASICDRV)
 593
 594     rtk_uint32 regData;
 595     ret_t retVal;
 596
 597     retVal = Access_Read(reg, 2, &regData);
 598     if(TRUE != retVal)
 599         return RT_ERR_SMI;
 600
 601     *pValue = regData;
 602
 603     if(0x8367B == cleDebuggingDisplay)
 604         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 605
 606 #elif defined(CONFIG_RTL8367C_ASICDRV_TEST)
 607     if(reg >= CLE_VIRTUAL_REG_SIZE)
 608         return RT_ERR_OUT_OF_RANGE;
 609
 610     *pValue = CleVirtualReg[reg];
 611
 612     if(0x8367B == cleDebuggingDisplay)
 613         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, CleVirtualReg[reg]);
 614
 615 #elif defined(EMBEDDED_SUPPORT)
 616     if(reg > RTL8367C_REGDATAMAX  )
 617         return RT_ERR_INPUT;
 618
 619     *value = getReg(reg);
 620
 621 #else
 622     rtk_uint32 regData;
 623     ret_t retVal;
 624
 625     retVal = smi_read(reg, &regData);
 626     if(retVal != RT_ERR_OK)
 627         return RT_ERR_SMI;
 628
 629     *pValue = regData;
 630   #ifdef CONFIG_RTL865X_CLE
 631     if(0x8367B == cleDebuggingDisplay)
 632         PRINT("R[0x%4.4x]=0x%4.4x\n", reg, regData);
 633   #endif
 634
 635 #endif
 636
 637     return RT_ERR_OK;
 638 }
 639