src/hw/i2c/i2c.c

   1 /****************************************************************************
   2  * FILE PURPOSE: An i2c driver for the rom boot loader
   3  ****************************************************************************
   4  * FILE NAME: i2c.c
   5  *
   6  * DESCRIPTION: Provides an i2c driver for the rom boot loader. The driver
   7  *              is adapted from the csl polling driver in the 64x csl.
   8  *
   9  ****************************************************************************/
  10 #include "types.h"
  11 #include "i2c.h"
  12 #include "i2cloc.h"
  13 #include "target.h"
  14
  15 #define DEVICE_REG32_W(x,y)   *(volatile unsigned int *)(x)=(y)
  16 #define DEVICE_REG32_R(x)    (*(volatile unsigned int *)(x))
  17
  18  /**************************************************************************
  19   * Global variables
  20   *************************************************************************/
  21  UINT32 i2cCoreFreqMhz;
  22  UINT32 i2cBitPeriodCycles;
  23
  24
  25 /***********************************************************************************
  26  * FUNCTION PURPOSE: Provide an approximate delay
  27  ***********************************************************************************
  28  * DESCRIPTION: A delay in units of CPU cycles is executed
  29  ***********************************************************************************/
  30 static void chipDelay32 (uint32 del)
  31 {
  32     volatile unsigned int i;
  33
  34     for (i = 0; i < del/8; i++);
  35
  36 }
  37
  38
  39 /***************************************************************************
  40  * FUNCTION PURPOSE: Generate a delay
  41  ***************************************************************************
  42  * DESCRIPTION: Creates a delay specified in usec
  43  ***************************************************************************/
  44 void hw_i2c_delay_usec (UINT32 usec)
  45 {
  46   UINT32 delayCycles;
  47
  48   delayCycles = usec * i2cCoreFreqMhz;
  49
  50   chipDelay32 (delayCycles);
  51
  52 } /* hw_i2c_delay_usec */
  53
  54
  55  /***************************************************************************
  56   * FUNCTION PURPOSE: Initialize the I2C.
  57   ***************************************************************************
  58   * DESCRIPTION: Puts the I2C into reset, sets up the device and takes
  59   *              the device out of reset in slave receiver mode.
  60   **************************************************************************/
  61 void hwI2Cinit (UINT16 coreFreqMhz, UINT16 moduleDivisor, UINT16 clkFreqKhz, UINT16 ownAddr)
  62  {
  63    UINT32 psc;
  64    UINT32 clkx;
  65    UINT32 tmp;
  66    UINT32 moduleFreqMhzQ1;
  67    UINT32 trueModFreqHz;
  68    UINT32 trueModFreqkHz;
  69
  70    /* Put the i2c peripheral into reset */
  71    DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_RESET);
  72
  73    /* To determine the module prescaler Q31.1 format will be used. This is just
  74     * handled simply since the input module frequency is an integer it will just
  75     * be multiplied by two. Dividing two Q31.1 result in a Q30.0, or the divider *
  76     * Calculate module prescalars to get as close to target frequencies as possible */
  77    moduleFreqMhzQ1 = (coreFreqMhz << 1) / moduleDivisor;
  78    psc = moduleFreqMhzQ1 / I2C_TARGET_MODULE_FREQ_MHZ_Q1;
  79    if (psc > 0)
  80      psc = psc - 1;
  81    trueModFreqHz = ((UINT32)coreFreqMhz * (UINT32)1000000) / (moduleDivisor * (psc+1));
  82
  83    tmp = trueModFreqHz / (clkFreqKhz * 1000);
  84    if (tmp > 12)
  85      clkx = (tmp - 12) >> 1;
  86    else
  87      clkx = 0;
  88
  89    /* Store the core frequency for use in generating delay */
  90    i2cCoreFreqMhz = coreFreqMhz;
  91
  92    /* Calculate the number of micro seconds for each bit. */
  93    trueModFreqkHz = trueModFreqHz / 1000;  /* Prevent 32 bit integer overlflow */
  94    i2cBitPeriodCycles = (UINT32)coreFreqMhz * 1000 * (2 * clkx + 12) / trueModFreqkHz;
  95
  96    /* Initialize the registers */
  97    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_PSC, (UINT32)psc);
  98    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_OAR, (UINT32)ownAddr);
  99    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_IER, (UINT32)0);
 100    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_RESET);
 101    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_CLKL, clkx);
 102    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_CLKH, clkx);
 103    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_CNT, (UINT32)0);
 104    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_SAR, (UINT32)0x3ff);
 105    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_DXR, (UINT32)0);
 106    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_PFUNC, (UINT32)0);
 107
 108    /* Take the I2C out of reset in the slave receiver mode */
 109    DEVICE_REG32_W(DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 110
 111    /* Read the receive register to clear it */
 112    tmp = DEVICE_REG32_R(DEVICE_I2C_BASE + I2C_REG_DRR);
 113
 114
 115 } /* hwI2Cinit */
 116
 117
 118 /****************************************************************************
 119  * FUNCTION PURPOSE: Perform a master write
 120  ****************************************************************************
 121  * DESCRIPTION: Enters master transmitter mode, writes a specified number
 122  *              of bytes. The byte stream arrives packed in the 16 bit
 123  *              data stream, and are sent most significant byte first.
 124  ****************************************************************************/
 125 I2C_RET hwI2cMasterWrite (UINT16 eeprom_i2c_id, UINT8 *eData, UINT16 nbytes, UINT16 endBusState, BOOL busIsMine)
 126 {
 127   UINT32 timeoutCount;
 128   UINT32 polling;
 129   UINT32 value;
 130   UINT32 str;
 131   UINT16 i;
 132
 133   /* If the byte length is 0 there is nothing to do */
 134   if (nbytes == 0)
 135     return (I2C_RET_OK);
 136
 137   /* Check for the bus busy signal */
 138   if (busIsMine == FALSE)  {
 139     timeoutCount = 0;
 140     do  {
 141       polling = I2C_REG_STR_FIELD_BB(DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_STR));
 142
 143       if (polling != 0)  {
 144         hw_i2c_delay_usec (I2C_MASTER_TRANSMITTER_BUS_ACCESS_DELAY_US);
 145
 146         timeoutCount += 1;
 147         if (timeoutCount >= I2C_MAX_MASTER_TRANSMITTER_BUS_ACCESS_TIMEOUT)  {
 148
 149           /* Return to slave receiver, clear nack and bus busy */
 150           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 151           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 152           return (I2C_RET_IDLE_TIMEOUT);
 153         }
 154       } else  { /* The bus is free */
 155         timeoutCount = 0;
 156       }
 157     }
 158     while (timeoutCount != 0);
 159
 160   }
 161
 162   /* Enter master transmitter mode, set the slave address register */
 163   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_MSTXMT);
 164   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_SAR, (UINT32)eeprom_i2c_id);
 165
 166   /* Put the first byte into the transmit register, set the start bit */
 167   value = *eData & 0x00ff;
 168   eData = eData + 1;
 169   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_DXR, value);
 170
 171
 172   /* Some delay required */
 173   chipDelay32 (i2cBitPeriodCycles);
 174
 175   /* Set the start bit */
 176   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_MSTXMTSTRT);
 177
 178   for (i = 1; i < nbytes; i++)  {
 179     timeoutCount = 0;
 180
 181     do  {
 182       /* Read status */
 183       str = DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_STR);
 184
 185       /* On Nack return failure */
 186       if (I2C_REG_STR_FIELD_NACK(str) != 0)  {
 187
 188         /* Return to slave receiver, clear nack and bus busy */
 189         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 190         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 191         return (I2C_RET_NO_ACK);
 192       }
 193
 194       /* Check for transmit ready */
 195       if (I2C_REG_STR_FIELD_XRDY(str) != 0)  {
 196         timeoutCount = 0;
 197
 198         value = *eData & 0x00ff;
 199         eData =  eData + 1;
 200
 201         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_DXR, value);
 202
 203
 204       }  else  {   /* XRDY bit not set */
 205         chipDelay32 (i2cBitPeriodCycles);
 206         timeoutCount += 1;
 207         if (timeoutCount >= I2C_MAX_MASTER_TRANSMITTER_TIMEOUT)  {
 208           /* Return to slave receiver, clear nack and bus busy */
 209           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 210           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 211           return (I2C_RET_IDLE_TIMEOUT);
 212         }
 213       }
 214
 215     } while (timeoutCount != 0);
 216
 217   } /* end for loop */
 218
 219
 220   /* If releasing the bus, send a stop bit */
 221   if (endBusState == I2C_RELEASE_BUS)  {
 222
 223     /* Wait for the ardy bit to go high */
 224     timeoutCount = 0;
 225     do  {
 226       str = DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_STR);
 227       if (I2C_REG_STR_FIELD_ARDY(str) != 0)  {
 228         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_MSTXMTSTOP);
 229         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_CLR_BUSY);
 230         hw_i2c_delay_usec (10000);
 231         timeoutCount = 0;
 232
 233       } else  { /* Registers not ready for access */
 234         timeoutCount += 1;
 235
 236         if (timeoutCount >= I2C_MAX_MASTER_TRANSMITTER_ARDY_TIMEOUT)  {
 237            /* On timeout put the peripheral into reset, wait, then
 238             * take it out of reset */
 239            DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_RESET);
 240            hw_i2c_delay_usec (10000);
 241            DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 242            return (I2C_RET_IDLE_TIMEOUT);
 243          }
 244         chipDelay32 (i2cBitPeriodCycles);
 245       }
 246     } while (timeoutCount != 0);
 247
 248   } /* end bus release */
 249
 250   return (I2C_RET_OK);
 251
 252 } /* hwI2cMasterWrite */
 253
 254
 255
 256 /**************************************************************************
 257  * FUNCTION PURPOSE: Perform a master read from an I2C prom
 258  **************************************************************************
 259  * DESCRIPTION: Reads a fixed number of bytes from an I2C prom. The read
 260  *              consists of a master write of 2 bytes (forming a 16 bit address,
 261  *              msb transmitted first), followed by a master read of the
 262  *              input number of bytes. The bytes that are read are placed
 263  *              in p_packed_bytes in big endian format.
 264  **************************************************************************/
 265 I2C_RET hwI2cMasterRead (
 266   UINT32           byte_addr,
 267   UINT32           byte_len,
 268   UINT8           *p_packed_bytes,
 269   UINT16           eeprom_i2c_id,
 270   UINT16           address_delay)
 271 {
 272
 273   UINT32  str;
 274   UINT32  timeoutCount;
 275   UINT32  i;
 276   UINT8   eAddr[2];
 277   I2C_RET ret;
 278
 279   /* If the byte length is 0, there is nothing to do */
 280   if (byte_len == 0)
 281     return (I2C_RET_OK);
 282
 283   /* Write the byte address to the eeprom. Do not send a stop */
 284   eAddr[0] = (byte_addr >> 8) & 0xff;
 285   eAddr[1] = byte_addr & 0xff;
 286
 287   ret = hwI2cMasterWrite (eeprom_i2c_id, eAddr, 2, I2C_DO_NOT_RELEASE_BUS, FALSE);
 288   if (ret != I2C_RET_OK)
 289     return (ret);
 290
 291   /* Give the I2C prom some time to process the read command */
 292   chipDelay32 (((UINT32)address_delay)<<8);
 293
 294   /* Set the start bit, begin the master read */
 295   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_MSTRCV);
 296
 297   /* Read the requested number of bytes */
 298   for (i = 0; i < byte_len; i++)  {
 299     timeoutCount = 0;
 300
 301     do  {
 302       /* Read status */
 303       str = DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_STR);
 304
 305       /* On Nack return failure */
 306       if (I2C_REG_STR_FIELD_NACK(str) != 0)  {
 307
 308         /* Return to slave receiver, clear nack and bus busy */
 309         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 310         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 311         return (I2C_RET_NO_ACK);
 312       }
 313
 314       /* Check for receive byte ready */
 315       if (I2C_REG_STR_FIELD_RRDY(str) != 0)  {
 316         *p_packed_bytes = (UINT16) (DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_DRR) & 0x00ff);
 317         timeoutCount = 0;
 318         p_packed_bytes = p_packed_bytes + 1;
 319
 320
 321       }  else  {   /* RRDY bit not set */
 322         chipDelay32 (i2cBitPeriodCycles);
 323         timeoutCount += 1;
 324         if (timeoutCount >= I2C_MAX_MASTER_RECEIVE_TIMEOUT)  {
 325           /* Return to slave receiver, clear nack and bus busy */
 326           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 327           DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 328           return (I2C_RET_IDLE_TIMEOUT);
 329         }
 330       }
 331
 332     } while (timeoutCount != 0);
 333
 334   } /* end for loop */
 335
 336   /* The data block has been read. Send the stop bit */
 337   DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_MSTRCVSTOP);
 338
 339
 340   /* Wait for the rrdy and read the dummy byte */
 341   timeoutCount = 0;
 342   do  {
 343
 344     str = DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_STR);
 345
 346     /* Check for receive byte ready */
 347     if (I2C_REG_STR_FIELD_RRDY(str) != 0)  {
 348       eAddr[0] = (UINT16) (DEVICE_REG32_R (DEVICE_I2C_BASE + I2C_REG_DRR) & 0x00ff);
 349       timeoutCount = 0;
 350
 351     }  else  {  /* rrdy not set */
 352
 353       chipDelay32 (i2cBitPeriodCycles);
 354       timeoutCount += 1;
 355       if (timeoutCount >= I2C_MAX_MASTER_RECEIVE_TIMEOUT)  {
 356         /* Return to slave receiver, clear nack and bus busy */
 357         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_MDR, I2C_VAL_REG_MDR_SLVRCV);
 358         DEVICE_REG32_W (DEVICE_I2C_BASE + I2C_REG_STR, I2C_VAL_REG_STR_ON_FAIL);
 359         return (I2C_RET_IDLE_TIMEOUT);
 360       }
 361     }
 362
 363   } while (timeoutCount != 0);
 364
 365   return (I2C_RET_OK);
 366
 367 } /* hwI2cMasterRead */
 368