drivers/staging/sm750fb/ddk750_hwi2c.c

   1 #define USE_HW_I2C
   2 #ifdef USE_HW_I2C
   3 #include "ddk750_help.h"
   4 #include "ddk750_reg.h"
   5 #include "ddk750_hwi2c.h"
   6 #include "ddk750_power.h"
   7
   8 #define MAX_HWI2C_FIFO                  16
   9 #define HWI2C_WAIT_TIMEOUT              0xF0000
  10
  11 int sm750_hw_i2c_init(
  12 unsigned char bus_speed_mode
  13 )
  14 {
  15         unsigned int value;
  16
  17         /* Enable GPIO 30 & 31 as IIC clock & data */
  18         value = PEEK32(GPIO_MUX);
  19
  20         value = FIELD_SET(value, GPIO_MUX, 30, I2C) |
  21                           FIELD_SET(0, GPIO_MUX, 31, I2C);
  22         POKE32(GPIO_MUX, value);
  23
  24         /* Enable Hardware I2C power.
  25          TODO: Check if we need to enable GPIO power?
  26          */
  27         enableI2C(1);
  28
  29         /* Enable the I2C Controller and set the bus speed mode */
  30         value = PEEK32(I2C_CTRL);
  31         if (bus_speed_mode == 0)
  32                 value = FIELD_SET(value, I2C_CTRL, MODE, STANDARD);
  33         else
  34                 value = FIELD_SET(value, I2C_CTRL, MODE, FAST);
  35         value = FIELD_SET(value, I2C_CTRL, EN, ENABLE);
  36         POKE32(I2C_CTRL, value);
  37
  38         return 0;
  39 }
  40
  41 void sm750_hw_i2c_close(void)
  42 {
  43         unsigned int value;
  44
  45         /* Disable I2C controller */
  46         value = PEEK32(I2C_CTRL);
  47         value = FIELD_SET(value, I2C_CTRL, EN, DISABLE);
  48         POKE32(I2C_CTRL, value);
  49
  50         /* Disable I2C Power */
  51         enableI2C(0);
  52
  53         /* Set GPIO 30 & 31 back as GPIO pins */
  54         value = PEEK32(GPIO_MUX);
  55         value = FIELD_SET(value, GPIO_MUX, 30, GPIO);
  56         value = FIELD_SET(value, GPIO_MUX, 31, GPIO);
  57         POKE32(GPIO_MUX, value);
  58 }
  59
  60 static long hw_i2c_wait_tx_done(void)
  61 {
  62         unsigned int timeout;
  63
  64         /* Wait until the transfer is completed. */
  65         timeout = HWI2C_WAIT_TIMEOUT;
  66         while ((FIELD_GET(PEEK32(I2C_STATUS), I2C_STATUS, TX) != I2C_STATUS_TX_COMPLETED) &&
  67                (timeout != 0))
  68                 timeout--;
  69
  70         if (timeout == 0)
  71                 return (-1);
  72
  73         return 0;
  74 }
  75
  76 /*
  77  *  This function writes data to the i2c slave device registers.
  78  *
  79  *  Parameters:
  80  *      addr            - i2c Slave device address
  81  *      length          - Total number of bytes to be written to the device
  82  *      buf             - The buffer that contains the data to be written to the
  83  *                     i2c device.
  84  *
  85  *  Return Value:
  86  *      Total number of bytes those are actually written.
  87  */
  88 static unsigned int hw_i2c_write_data(
  89         unsigned char addr,
  90         unsigned int length,
  91         unsigned char *buf
  92 )
  93 {
  94         unsigned char count, i;
  95         unsigned int total_bytes = 0;
  96
  97         /* Set the Device Address */
  98         POKE32(I2C_SLAVE_ADDRESS, addr & ~0x01);
  99
 100         /* Write data.
 101          * Note:
 102          *      Only 16 byte can be accessed per i2c start instruction.
 103          */
 104         do {
 105                 /* Reset I2C by writing 0 to I2C_RESET register to clear the previous status. */
 106                 POKE32(I2C_RESET, 0);
 107
 108                 /* Set the number of bytes to be written */
 109                 if (length < MAX_HWI2C_FIFO)
 110                         count = length - 1;
 111                 else
 112                         count = MAX_HWI2C_FIFO - 1;
 113                 POKE32(I2C_BYTE_COUNT, count);
 114
 115                 /* Move the data to the I2C data register */
 116                 for (i = 0; i <= count; i++)
 117                         POKE32(I2C_DATA0 + i, *buf++);
 118
 119                 /* Start the I2C */
 120                 POKE32(I2C_CTRL, FIELD_SET(PEEK32(I2C_CTRL), I2C_CTRL, CTRL, START));
 121
 122                 /* Wait until the transfer is completed. */
 123                 if (hw_i2c_wait_tx_done() != 0)
 124                         break;
 125
 126                 /* Substract length */
 127                 length -= (count + 1);
 128
 129                 /* Total byte written */
 130                 total_bytes += (count + 1);
 131
 132         } while (length > 0);
 133
 134         return total_bytes;
 135 }
 136
 137 /*
 138  *  This function reads data from the slave device and stores them
 139  *  in the given buffer
 140  *
 141  *  Parameters:
 142  *      addr            - i2c Slave device address
 143  *      length          - Total number of bytes to be read
 144  *      buf             - Pointer to a buffer to be filled with the data read
 145  *                     from the slave device. It has to be the same size as the
 146  *                     length to make sure that it can keep all the data read.
 147  *
 148  *  Return Value:
 149  *      Total number of actual bytes read from the slave device
 150  */
 151 static unsigned int hw_i2c_read_data(
 152         unsigned char addr,
 153         unsigned int length,
 154         unsigned char *buf
 155 )
 156 {
 157         unsigned char count, i;
 158         unsigned int total_bytes = 0;
 159
 160         /* Set the Device Address */
 161         POKE32(I2C_SLAVE_ADDRESS, addr | 0x01);
 162
 163         /* Read data and save them to the buffer.
 164          * Note:
 165          *      Only 16 byte can be accessed per i2c start instruction.
 166          */
 167         do {
 168                 /* Reset I2C by writing 0 to I2C_RESET register to clear all the status. */
 169                 POKE32(I2C_RESET, 0);
 170
 171                 /* Set the number of bytes to be read */
 172                 if (length <= MAX_HWI2C_FIFO)
 173                         count = length - 1;
 174                 else
 175                         count = MAX_HWI2C_FIFO - 1;
 176                 POKE32(I2C_BYTE_COUNT, count);
 177
 178                 /* Start the I2C */
 179                 POKE32(I2C_CTRL, FIELD_SET(PEEK32(I2C_CTRL), I2C_CTRL, CTRL, START));
 180
 181                 /* Wait until transaction done. */
 182                 if (hw_i2c_wait_tx_done() != 0)
 183                         break;
 184
 185                 /* Save the data to the given buffer */
 186                 for (i = 0; i <= count; i++)
 187                         *buf++ = PEEK32(I2C_DATA0 + i);
 188
 189                 /* Substract length by 16 */
 190                 length -= (count + 1);
 191
 192                 /* Number of bytes read. */
 193                 total_bytes += (count + 1);
 194
 195         } while (length > 0);
 196
 197         return total_bytes;
 198 }
 199
 200 /*
 201  *  This function reads the slave device's register
 202  *
 203  *  Parameters:
 204  *      deviceAddress   - i2c Slave device address which register
 205  *                        to be read from
 206  *      registerIndex   - Slave device's register to be read
 207  *
 208  *  Return Value:
 209  *      Register value
 210  */
 211 unsigned char sm750_hw_i2c_read_reg(
 212         unsigned char addr,
 213         unsigned char reg
 214 )
 215 {
 216         unsigned char value = (0xFF);
 217
 218         if (hw_i2c_write_data(addr, 1, &reg) == 1)
 219                 hw_i2c_read_data(addr, 1, &value);
 220
 221         return value;
 222 }
 223
 224 /*
 225  *  This function writes a value to the slave device's register
 226  *
 227  *  Parameters:
 228  *      deviceAddress   - i2c Slave device address which register
 229  *                        to be written
 230  *      registerIndex   - Slave device's register to be written
 231  *      data            - Data to be written to the register
 232  *
 233  *  Result:
 234  *          0   - Success
 235  *         -1   - Fail
 236  */
 237 int sm750_hw_i2c_write_reg(
 238         unsigned char addr,
 239         unsigned char reg,
 240         unsigned char data
 241 )
 242 {
 243         unsigned char value[2];
 244
 245         value[0] = reg;
 246         value[1] = data;
 247         if (hw_i2c_write_data(addr, 2, value) == 2)
 248                 return 0;
 249
 250         return (-1);
 251 }
 252
 253 #endif