drivers/i2c/designware_i2c.c

   1 /*
   2  * (C) Copyright 2009
   3  * Vipin Kumar, ST Micoelectronics, vipin.kumar@st.com.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <common.h>
  25 #include <asm/io.h>
  26 #include <asm/arch/hardware.h>
  27 #include "designware_i2c.h"
  28
  29 #ifdef CONFIG_I2C_MULTI_BUS
  30 static unsigned int bus_initialized[CONFIG_SYS_I2C_BUS_MAX];
  31 static unsigned int current_bus = 0;
  32 #endif
  33
  34 static struct i2c_regs *i2c_regs_p =
  35     (struct i2c_regs *)CONFIG_SYS_I2C_BASE;
  36
  37 /*
  38  * set_speed - Set the i2c speed mode (standard, high, fast)
  39  * @i2c_spd:    required i2c speed mode
  40  *
  41  * Set the i2c speed mode (standard, high, fast)
  42  */
  43 static void set_speed(int i2c_spd)
  44 {
  45         unsigned int cntl;
  46         unsigned int hcnt, lcnt;
  47         unsigned int enbl;
  48
  49         /* to set speed cltr must be disabled */
  50         enbl = readl(&i2c_regs_p->ic_enable);
  51         enbl &= ~IC_ENABLE_0B;
  52         writel(enbl, &i2c_regs_p->ic_enable);
  53
  54         cntl = (readl(&i2c_regs_p->ic_con) & (~IC_CON_SPD_MSK));
  55
  56         switch (i2c_spd) {
  57         case IC_SPEED_MODE_MAX:
  58                 cntl |= IC_CON_SPD_HS;
  59                 hcnt = (IC_CLK * MIN_HS_SCL_HIGHTIME) / NANO_TO_MICRO;
  60                 writel(hcnt, &i2c_regs_p->ic_hs_scl_hcnt);
  61                 lcnt = (IC_CLK * MIN_HS_SCL_LOWTIME) / NANO_TO_MICRO;
  62                 writel(lcnt, &i2c_regs_p->ic_hs_scl_lcnt);
  63                 break;
  64
  65         case IC_SPEED_MODE_STANDARD:
  66                 cntl |= IC_CON_SPD_SS;
  67                 hcnt = (IC_CLK * MIN_SS_SCL_HIGHTIME) / NANO_TO_MICRO;
  68                 writel(hcnt, &i2c_regs_p->ic_ss_scl_hcnt);
  69                 lcnt = (IC_CLK * MIN_SS_SCL_LOWTIME) / NANO_TO_MICRO;
  70                 writel(lcnt, &i2c_regs_p->ic_ss_scl_lcnt);
  71                 break;
  72
  73         case IC_SPEED_MODE_FAST:
  74         default:
  75                 cntl |= IC_CON_SPD_FS;
  76                 hcnt = (IC_CLK * MIN_FS_SCL_HIGHTIME) / NANO_TO_MICRO;
  77                 writel(hcnt, &i2c_regs_p->ic_fs_scl_hcnt);
  78                 lcnt = (IC_CLK * MIN_FS_SCL_LOWTIME) / NANO_TO_MICRO;
  79                 writel(lcnt, &i2c_regs_p->ic_fs_scl_lcnt);
  80                 break;
  81         }
  82
  83         writel(cntl, &i2c_regs_p->ic_con);
  84
  85         /* Enable back i2c now speed set */
  86         enbl |= IC_ENABLE_0B;
  87         writel(enbl, &i2c_regs_p->ic_enable);
  88 }
  89
  90 /*
  91  * i2c_set_bus_speed - Set the i2c speed
  92  * @speed:      required i2c speed
  93  *
  94  * Set the i2c speed.
  95  */
  96 int i2c_set_bus_speed(int speed)
  97 {
  98         if (speed >= I2C_MAX_SPEED)
  99                 set_speed(IC_SPEED_MODE_MAX);
 100         else if (speed >= I2C_FAST_SPEED)
 101                 set_speed(IC_SPEED_MODE_FAST);
 102         else
 103                 set_speed(IC_SPEED_MODE_STANDARD);
 104
 105         return 0;
 106 }
 107
 108 /*
 109  * i2c_get_bus_speed - Gets the i2c speed
 110  *
 111  * Gets the i2c speed.
 112  */
 113 int i2c_get_bus_speed(void)
 114 {
 115         u32 cntl;
 116
 117         cntl = (readl(&i2c_regs_p->ic_con) & IC_CON_SPD_MSK);
 118
 119         if (cntl == IC_CON_SPD_HS)
 120                 return I2C_MAX_SPEED;
 121         else if (cntl == IC_CON_SPD_FS)
 122                 return I2C_FAST_SPEED;
 123         else if (cntl == IC_CON_SPD_SS)
 124                 return I2C_STANDARD_SPEED;
 125
 126         return 0;
 127 }
 128
 129 /*
 130  * i2c_init - Init function
 131  * @speed:      required i2c speed
 132  * @slaveadd:   slave address for the device
 133  *
 134  * Initialization function.
 135  */
 136 void i2c_init(int speed, int slaveadd)
 137 {
 138         unsigned int enbl;
 139
 140         /* Disable i2c */
 141         enbl = readl(&i2c_regs_p->ic_enable);
 142         enbl &= ~IC_ENABLE_0B;
 143         writel(enbl, &i2c_regs_p->ic_enable);
 144
 145         writel((IC_CON_SD | IC_CON_SPD_FS | IC_CON_MM), &i2c_regs_p->ic_con);
 146         writel(IC_RX_TL, &i2c_regs_p->ic_rx_tl);
 147         writel(IC_TX_TL, &i2c_regs_p->ic_tx_tl);
 148         i2c_set_bus_speed(speed);
 149         writel(IC_STOP_DET, &i2c_regs_p->ic_intr_mask);
 150         writel(slaveadd, &i2c_regs_p->ic_sar);
 151
 152         /* Enable i2c */
 153         enbl = readl(&i2c_regs_p->ic_enable);
 154         enbl |= IC_ENABLE_0B;
 155         writel(enbl, &i2c_regs_p->ic_enable);
 156
 157 #ifdef CONFIG_I2C_MULTI_BUS
 158         bus_initialized[current_bus] = 1;
 159 #endif
 160 }
 161
 162 /*
 163  * i2c_setaddress - Sets the target slave address
 164  * @i2c_addr:   target i2c address
 165  *
 166  * Sets the target slave address.
 167  */
 168 static void i2c_setaddress(unsigned int i2c_addr)
 169 {
 170         writel(i2c_addr, &i2c_regs_p->ic_tar);
 171 }
 172
 173 /*
 174  * i2c_flush_rxfifo - Flushes the i2c RX FIFO
 175  *
 176  * Flushes the i2c RX FIFO
 177  */
 178 static void i2c_flush_rxfifo(void)
 179 {
 180         while (readl(&i2c_regs_p->ic_status) & IC_STATUS_RFNE)
 181                 readl(&i2c_regs_p->ic_cmd_data);
 182 }
 183
 184 /*
 185  * i2c_wait_for_bb - Waits for bus busy
 186  *
 187  * Waits for bus busy
 188  */
 189 static int i2c_wait_for_bb(void)
 190 {
 191         unsigned long start_time_bb = get_timer(0);
 192
 193         while ((readl(&i2c_regs_p->ic_status) & IC_STATUS_MA) ||
 194                !(readl(&i2c_regs_p->ic_status) & IC_STATUS_TFE)) {
 195
 196                 /* Evaluate timeout */
 197                 if (get_timer(start_time_bb) > (unsigned long)(I2C_BYTE_TO_BB))
 198                         return 1;
 199         }
 200
 201         return 0;
 202 }
 203
 204 /* check parameters for i2c_read and i2c_write */
 205 static int check_params(uint addr, int alen, uchar *buffer, int len)
 206 {
 207         if (buffer == NULL) {
 208                 printf("Buffer is invalid\n");
 209                 return 1;
 210         }
 211
 212         if (alen > 1) {
 213                 printf("addr len %d not supported\n", alen);
 214                 return 1;
 215         }
 216
 217         if (addr + len > 256) {
 218                 printf("address out of range\n");
 219                 return 1;
 220         }
 221
 222         return 0;
 223 }
 224
 225 static int i2c_xfer_init(uchar chip, uint addr)
 226 {
 227         if (i2c_wait_for_bb())
 228                 return 1;
 229
 230         i2c_setaddress(chip);
 231         writel(addr, &i2c_regs_p->ic_cmd_data);
 232
 233         return 0;
 234 }
 235
 236 static int i2c_xfer_finish(void)
 237 {
 238         ulong start_stop_det = get_timer(0);
 239
 240         while (1) {
 241                 if ((readl(&i2c_regs_p->ic_raw_intr_stat) & IC_STOP_DET)) {
 242                         readl(&i2c_regs_p->ic_clr_stop_det);
 243                         break;
 244                 } else if (get_timer(start_stop_det) > I2C_STOPDET_TO) {
 245                         break;
 246                 }
 247         }
 248
 249         if (i2c_wait_for_bb()) {
 250                 printf("Timed out waiting for bus\n");
 251                 return 1;
 252         }
 253
 254         i2c_flush_rxfifo();
 255
 256         /* Wait for read/write operation to complete on actual memory */
 257         udelay(10000);
 258
 259         return 0;
 260 }
 261
 262 /*
 263  * i2c_read - Read from i2c memory
 264  * @chip:       target i2c address
 265  * @addr:       address to read from
 266  * @alen:
 267  * @buffer:     buffer for read data
 268  * @len:        no of bytes to be read
 269  *
 270  * Read from i2c memory.
 271  */
 272 int i2c_read(uchar chip, uint addr, int alen, uchar *buffer, int len)
 273 {
 274         unsigned long start_time_rx;
 275
 276         if (check_params(addr, alen, buffer, len))
 277                 return 1;
 278
 279         if (i2c_xfer_init(chip, addr))
 280                 return 1;
 281
 282         start_time_rx = get_timer(0);
 283         while (len) {
 284                 if (len == 1)
 285                         writel(IC_CMD | IC_STOP, &i2c_regs_p->ic_cmd_data);
 286                 else
 287                         writel(IC_CMD, &i2c_regs_p->ic_cmd_data);
 288
 289                 if (readl(&i2c_regs_p->ic_status) & IC_STATUS_RFNE) {
 290                         *buffer++ = (uchar)readl(&i2c_regs_p->ic_cmd_data);
 291                         len--;
 292                         start_time_rx = get_timer(0);
 293
 294                 } else if (get_timer(start_time_rx) > I2C_BYTE_TO) {
 295                                 return 1;
 296                 }
 297         }
 298
 299         return i2c_xfer_finish();
 300 }
 301
 302 /*
 303  * i2c_write - Write to i2c memory
 304  * @chip:       target i2c address
 305  * @addr:       address to read from
 306  * @alen:
 307  * @buffer:     buffer for read data
 308  * @len:        no of bytes to be read
 309  *
 310  * Write to i2c memory.
 311  */
 312 int i2c_write(uchar chip, uint addr, int alen, uchar *buffer, int len)
 313 {
 314         int nb = len;
 315         unsigned long start_time_tx;
 316
 317         if (check_params(addr, alen, buffer, len))
 318                 return 1;
 319
 320         if (i2c_xfer_init(chip, addr))
 321                 return 1;
 322
 323         start_time_tx = get_timer(0);
 324         while (len) {
 325                 if (readl(&i2c_regs_p->ic_status) & IC_STATUS_TFNF) {
 326                         if (--len == 0)
 327                                 writel(*buffer | IC_STOP, &i2c_regs_p->ic_cmd_data);
 328                         else
 329                                 writel(*buffer, &i2c_regs_p->ic_cmd_data);
 330                         buffer++;
 331                         start_time_tx = get_timer(0);
 332
 333                 } else if (get_timer(start_time_tx) > (nb * I2C_BYTE_TO)) {
 334                                 printf("Timed out. i2c write Failed\n");
 335                                 return 1;
 336                 }
 337         }
 338
 339         return i2c_xfer_finish();
 340 }
 341
 342 /*
 343  * i2c_probe - Probe the i2c chip
 344  */
 345 int i2c_probe(uchar chip)
 346 {
 347         u32 tmp;
 348         int ret;
 349
 350         /*
 351          * Try to read the first location of the chip.
 352          */
 353         ret = i2c_read(chip, 0, 1, (uchar *)&tmp, 1);
 354         if (ret)
 355                 i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 356
 357         return ret;
 358 }
 359
 360 #ifdef CONFIG_I2C_MULTI_BUS
 361 int i2c_set_bus_num(unsigned int bus)
 362 {
 363         switch (bus) {
 364         case 0:
 365                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE;
 366                 break;
 367 #ifdef CONFIG_SYS_I2C_BASE1
 368         case 1:
 369                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE1;
 370                 break;
 371 #endif
 372 #ifdef CONFIG_SYS_I2C_BASE2
 373         case 2:
 374                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE2;
 375                 break;
 376 #endif
 377 #ifdef CONFIG_SYS_I2C_BASE3
 378         case 3:
 379                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE3;
 380                 break;
 381 #endif
 382 #ifdef CONFIG_SYS_I2C_BASE4
 383         case 4:
 384                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE4;
 385                 break;
 386 #endif
 387 #ifdef CONFIG_SYS_I2C_BASE5
 388         case 5:
 389                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE5;
 390                 break;
 391 #endif
 392 #ifdef CONFIG_SYS_I2C_BASE6
 393         case 6:
 394                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE6;
 395                 break;
 396 #endif
 397 #ifdef CONFIG_SYS_I2C_BASE7
 398         case 7:
 399                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE7;
 400                 break;
 401 #endif
 402 #ifdef CONFIG_SYS_I2C_BASE8
 403         case 8:
 404                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE8;
 405                 break;
 406 #endif
 407 #ifdef CONFIG_SYS_I2C_BASE9
 408         case 9:
 409                 i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE9;
 410                 break;
 411 #endif
 412         default:
 413                 printf("Bad bus: %d\n", bus);
 414                 return -1;
 415         }
 416
 417         current_bus = bus;
 418
 419         if (!bus_initialized[current_bus])
 420                 i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 421
 422         return 0;
 423 }
 424
 425 int i2c_get_bus_num(void)
 426 {
 427         return current_bus;
 428 }
 429 #endif