target/linux/mediatek/files-5.4/drivers/net/phy/rtk/rtl8367c/i2c.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: 63932 $
  11  * $Date: 2015-12-08 14:06:29 +0800 (周二, 08 十二月 2015) $
  12  *
  13  * Purpose : RTK switch high-level API for RTL8367/RTL8367C
  14  * Feature : Here is a list of all functions and variables in i2c module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <port.h>
  21 #include <string.h>
  22 #include <rtl8367c_reg.h>
  23
  24 #include <rtl8367c_asicdrv_i2c.h>
  25 #include <rtk_switch.h>
  26 #include <rtl8367c_asicdrv.h>
  27 #include <rtk_types.h>
  28 #include <i2c.h>
  29
  30
  31 static rtk_I2C_16bit_mode_t rtk_i2c_mode = I2C_LSB_16BIT_MODE;
  32
  33
  34 /* Function Name:
  35  *      rtk_i2c_init
  36  * Description:
  37  *      I2C smart function initialization.
  38  * Input:
  39  *      None
  40  * Output:
  41  *      None
  42  * Return:
  43  *      RT_ERR_OK           - OK
  44  *      RT_ERR_FAILED       - Failed
  45  * Note:
  46  *      This API is used to initialize EEE status.
  47  *      need used GPIO pins
  48  *      OpenDrain and clock
  49  */
  50 rtk_api_ret_t rtk_i2c_init(void)
  51 {
  52     rtk_uint32 retVal;
  53   switch_chip_t ChipID;
  54   /* probe switch */
  55   if((retVal = rtk_switch_probe(&ChipID)) != RT_ERR_OK)
  56       return retVal;
  57
  58   if( ChipID == CHIP_RTL8370B )
  59   {
  60    /*set GPIO8, GPIO9, OpenDrain as I2C, clock = 252KHZ   */
  61       if((retVal = rtl8367c_setAsicReg(RTL8367C_REG_M_I2C_SYS_CTL, 0x5c3f)) != RT_ERR_OK)
  62         return retVal;
  63   }
  64   else
  65       return RT_ERR_FAILED;
  66   return  RT_ERR_OK;
  67 }
  68
  69
  70 /* Function Name:
  71  *      rtk_i2c_mode_set
  72  * Description:
  73  *      Set I2C data byte-order.
  74  * Input:
  75  *      i2cmode - byte-order mode
  76  * Output:
  77  *      None
  78  * Return:
  79  *      RT_ERR_OK           - OK
  80  *      RT_ERR_FAILED       - Failed
  81  *      RT_ERR_INPUT        - Invalid input parameter.
  82  * Note:
  83  *      This API can set I2c traffic's byte-order .
  84  */
  85 rtk_api_ret_t rtk_i2c_mode_set( rtk_I2C_16bit_mode_t i2cmode )
  86 {
  87     if(i2cmode >= I2C_Mode_END)
  88     {
  89         return RT_ERR_INPUT;
  90     }
  91     else if(i2cmode == I2C_70B_LSB_16BIT_MODE)
  92     {
  93         rtk_i2c_mode = I2C_70B_LSB_16BIT_MODE;
  94
  95         return RT_ERR_OK;
  96     }
  97     else if( i2cmode == I2C_LSB_16BIT_MODE)
  98     {
  99         rtk_i2c_mode = I2C_LSB_16BIT_MODE;
 100         return RT_ERR_OK;
 101     }
 102     else
 103         return RT_ERR_FAILED;
 104
 105     return RT_ERR_OK;
 106 }
 107
 108
 109 /* Function Name:
 110  *      rtk_i2c_mode_get
 111  * Description:
 112  *      Get i2c traffic byte-order setting.
 113  * Input:
 114  *      None
 115  * Output:
 116  *      pI2cMode - i2c byte-order
 117  * Return:
 118  *      RT_ERR_OK               - OK
 119  *      RT_ERR_FAILED           - Failed
 120  *      RT_ERR_NULL_POINTER     - input parameter is null pointer
 121  * Note:
 122  *      The API can get i2c traffic byte-order setting.
 123  */
 124 rtk_api_ret_t rtk_i2c_mode_get( rtk_I2C_16bit_mode_t * pI2cMode)
 125 {
 126     /* Check initialization state */
 127     RTK_CHK_INIT_STATE();
 128     if(NULL == pI2cMode)
 129         return RT_ERR_NULL_POINTER;
 130     if(rtk_i2c_mode == I2C_70B_LSB_16BIT_MODE)
 131         *pI2cMode = 1;
 132     else if ((rtk_i2c_mode == I2C_LSB_16BIT_MODE))
 133         *pI2cMode = 0;
 134     else
 135         return RT_ERR_FAILED;
 136     return RT_ERR_OK;
 137 }
 138
 139
 140 /* Function Name:
 141  *      rtk_i2c_gpioPinGroup_set
 142  * Description:
 143  *      Set i2c SDA & SCL used GPIO pins group.
 144  * Input:
 145  *      pins_group - GPIO pins group
 146  * Output:
 147  *      None
 148  * Return:
 149  *      RT_ERR_OK               - OK
 150  *      RT_ERR_FAILED           - Failed
 151  *      RT_ERR_INPUT        - Invalid input parameter.
 152  * Note:
 153  *      The API can set i2c used gpio pins group.
 154  *      There are three group pins could be used
 155  */
 156 rtk_api_ret_t rtk_i2c_gpioPinGroup_set( rtk_I2C_gpio_pin_t pins_group )
 157 {
 158     rtk_uint32 retVal;
 159
 160
 161     if( ( pins_group > I2C_GPIO_PIN_END )|| ( pins_group < I2C_GPIO_PIN_8_9) )
 162         return RT_ERR_INPUT;
 163
 164     if( (retVal = rtl8367c_setAsicI2CGpioPinGroup(pins_group) ) != RT_ERR_OK )
 165         return retVal ;
 166
 167     return RT_ERR_OK;
 168 }
 169
 170 /* Function Name:
 171  *      rtk_i2c_gpioPinGroup_get
 172  * Description:
 173  *      Get i2c SDA & SCL used GPIO pins group.
 174  * Input:
 175  *      None
 176  * Output:
 177  *      pPins_group - GPIO pins group
 178  * Return:
 179  *      RT_ERR_OK               - OK
 180  *      RT_ERR_NULL_POINTER     - input parameter is null pointer
 181  * Note:
 182  *      The API can get i2c used gpio pins group.
 183  *      There are three group pins could be used
 184  */
 185 rtk_api_ret_t rtk_i2c_gpioPinGroup_get( rtk_I2C_gpio_pin_t * pPins_group )
 186 {
 187     rtk_uint32 retVal;
 188     /* Check initialization state */
 189     RTK_CHK_INIT_STATE();
 190
 191     if(NULL == pPins_group)
 192         return RT_ERR_NULL_POINTER;
 193     if( (retVal = rtl8367c_getAsicI2CGpioPinGroup(pPins_group) ) != RT_ERR_OK )
 194         return retVal;
 195
 196     return RT_ERR_OK;
 197 }
 198
 199 /* Function Name:
 200  *      rtk_i2c_data_read
 201  * Description:
 202  *      read i2c slave device register.
 203  * Input:
 204  *      deviceAddr   -   access Slave device address
 205  *      slaveRegAddr -   access Slave register address
 206  * Output:
 207  *      pRegData     -   read data
 208  * Return:
 209  *      RT_ERR_OK               - OK
 210  *      RT_ERR_NULL_POINTER     - input parameter is null pointer
 211  * Note:
 212  *      The API can access i2c slave and read i2c slave device register.
 213  */
 214 rtk_api_ret_t rtk_i2c_data_read(rtk_uint8 deviceAddr, rtk_uint32 slaveRegAddr, rtk_uint32 *pRegData)
 215 {
 216      rtk_uint32 retVal, counter=0;
 217      rtk_uint8 controlByte_W, controlByte_R;
 218      rtk_uint8 slaveRegAddr_L, slaveRegAddr_H = 0x0, temp;
 219      rtk_uint8 regData_L, regData_H;
 220
 221    /* control byte :deviceAddress + W,  deviceAddress + R   */
 222     controlByte_W = (rtk_uint8)(deviceAddr << 1) ;
 223     controlByte_R = (rtk_uint8)(controlByte_W | 0x1);
 224
 225     slaveRegAddr_L = (rtk_uint8) (slaveRegAddr & 0x00FF) ;
 226     slaveRegAddr_H = (rtk_uint8) (slaveRegAddr >>8) ;
 227
 228     if( rtk_i2c_mode == I2C_70B_LSB_16BIT_MODE)
 229     {
 230         temp = slaveRegAddr_L ;
 231         slaveRegAddr_L = slaveRegAddr_H;
 232         slaveRegAddr_H = temp;
 233     }
 234
 235
 236   /*check bus state: idle*/
 237   for(counter = 3000; counter>0; counter--)
 238   {
 239     if ( (retVal = rtl8367c_setAsicI2C_checkBusIdle() ) == RT_ERR_OK)
 240          break;
 241   }
 242   if( counter ==0 )
 243       return retVal; /*i2c is busy*/
 244
 245    /*tx Start cmd*/
 246    if( (retVal = rtl8367c_setAsicI2CStartCmd() ) != RT_ERR_OK )
 247        return retVal ;
 248
 249
 250   /*tx control _W*/
 251    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(controlByte_W))!= RT_ERR_OK )
 252       return retVal ;
 253
 254
 255   /*check if RX ack from slave*/
 256    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 257         return retVal;
 258
 259     /* tx slave buffer address low 8 bits */
 260    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(slaveRegAddr_L))!= RT_ERR_OK )
 261          return retVal  ;
 262
 263    /*check if RX ack from slave*/
 264    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 265         return retVal;
 266
 267
 268
 269         /* tx slave buffer address high 8 bits */
 270    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(slaveRegAddr_H))!= RT_ERR_OK )
 271          return retVal  ;
 272
 273
 274    /*check if RX ack from slave*/
 275    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 276         return retVal;
 277
 278
 279    /*tx Start cmd*/
 280    if( (retVal = rtl8367c_setAsicI2CStartCmd() ) != RT_ERR_OK )
 281        return retVal ;
 282
 283       /*tx control _R*/
 284    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(controlByte_R))!= RT_ERR_OK )
 285        return retVal ;
 286
 287
 288   /*check if RX ack from slave*/
 289    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 290         return retVal;
 291
 292
 293     /* rx low 8bit data*/
 294    if( ( retVal = rtl8367c_setAsicI2CRxOneCharCmd( &regData_L) ) != RT_ERR_OK )
 295         return retVal;
 296
 297
 298
 299     /* tx ack to slave, keep receive */
 300     if( (retVal = rtl8367c_setAsicI2CTxAckCmd()) != RT_ERR_OK )
 301         return retVal;
 302
 303      /* rx high 8bit data*/
 304     if( ( retVal = rtl8367c_setAsicI2CRxOneCharCmd( &regData_H) ) != RT_ERR_OK )
 305         return retVal;
 306
 307
 308
 309     /* tx Noack to slave, Stop receive */
 310      if( (retVal = rtl8367c_setAsicI2CTxNoAckCmd()) != RT_ERR_OK )
 311         return retVal;
 312
 313
 314     /*tx Stop cmd */
 315     if( (retVal = rtl8367c_setAsicI2CStopCmd()) != RT_ERR_OK )
 316         return retVal;
 317
 318     *pRegData = (regData_H << 8) | regData_L;
 319
 320     return RT_ERR_OK;
 321 }
 322
 323 /* Function Name:
 324  *      rtk_i2c_data_write
 325  * Description:
 326  *      write data to i2c slave device register
 327  * Input:
 328  *      deviceAddr   -   access Slave device address
 329  *      slaveRegAddr -   access Slave register address
 330  *      regData      -   data to set
 331  * Output:
 332  *      None
 333  * Return:
 334  *      RT_ERR_OK               - OK
 335  * Note:
 336  *      The API can access i2c slave and setting i2c slave device register.
 337  */
 338 rtk_api_ret_t rtk_i2c_data_write(rtk_uint8 deviceAddr, rtk_uint32 slaveRegAddr, rtk_uint32 regData)
 339 {
 340      rtk_uint32 retVal,counter;
 341      rtk_uint8 controlByte_W;
 342      rtk_uint8 slaveRegAddr_L, slaveRegAddr_H = 0x0, temp;
 343      rtk_uint8 regData_L, regData_H;
 344
 345   /* control byte :deviceAddress + W    */
 346     controlByte_W = (rtk_uint8)(deviceAddr<< 1) ;
 347
 348     slaveRegAddr_L = (rtk_uint8) (slaveRegAddr & 0x00FF) ;
 349     slaveRegAddr_H = (rtk_uint8) (slaveRegAddr >>8) ;
 350
 351     regData_H   = (rtk_uint8) (regData>> 8);
 352     regData_L   = (rtk_uint8) (regData & 0x00FF);
 353
 354     if( rtk_i2c_mode == I2C_70B_LSB_16BIT_MODE)
 355     {
 356         temp = slaveRegAddr_L ;
 357         slaveRegAddr_L = slaveRegAddr_H;
 358         slaveRegAddr_H = temp;
 359     }
 360
 361
 362   /*check bus state: idle*/
 363   for(counter = 3000; counter>0; counter--)
 364   {
 365     if ( (retVal = rtl8367c_setAsicI2C_checkBusIdle() ) == RT_ERR_OK)
 366         break;
 367   }
 368
 369   if( counter ==0 )
 370       return retVal; /*i2c is busy*/
 371
 372
 373    /*tx Start cmd*/
 374    if( (retVal = rtl8367c_setAsicI2CStartCmd() ) != RT_ERR_OK )
 375        return retVal ;
 376
 377
 378   /*tx control _W*/
 379    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(controlByte_W))!= RT_ERR_OK )
 380       return retVal ;
 381
 382
 383   /*check if RX ack from slave*/
 384    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 385         return retVal;
 386
 387
 388     /* tx slave buffer address low 8 bits */
 389    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(slaveRegAddr_L))!= RT_ERR_OK )
 390         return retVal;
 391
 392
 393    /*check if RX ack from slave*/
 394    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 395         return retVal;
 396
 397
 398    /* tx slave buffer address high 8 bits */
 399    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(slaveRegAddr_H))!= RT_ERR_OK )
 400         return retVal;
 401
 402
 403    /*check if RX ack from slave*/
 404    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 405         return retVal;
 406
 407
 408      /*tx Datavlue LSB*/
 409    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(regData_L))!= RT_ERR_OK )
 410         return retVal;
 411
 412
 413    /*check if RX ack from slave*/
 414    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 415         return retVal;
 416
 417
 418    /*tx Datavlue MSB*/
 419    if( (retVal = rtl8367c_setAsicI2CTxOneCharCmd(regData_H))!= RT_ERR_OK )
 420         return retVal;
 421
 422
 423    /*check if RX ack from slave*/
 424    if( (retVal = rtl8367c_setAsicI2CcheckRxAck()) != RT_ERR_OK )
 425         return retVal;
 426
 427
 428     /*tx Stop cmd */
 429     if( (retVal = rtl8367c_setAsicI2CStopCmd()) != RT_ERR_OK )
 430         return retVal;
 431
 432     return RT_ERR_OK;
 433 }
 434
 435
 436