drivers/i2c/omap24xx_i2c.c

   1 /*
   2  * Basic I2C functions
   3  *
   4  * Copyright (c) 2004 Texas Instruments
   5  *
   6  * This package is free software;  you can redistribute it and/or
   7  * modify it under the terms of the license found in the file
   8  * named COPYING that should have accompanied this file.
   9  *
  10  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  11  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  12  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  13  *
  14  * Author: Jian Zhang jzhang@ti.com, Texas Instruments
  15  *
  16  * Copyright (c) 2003 Wolfgang Denk, wd@denx.de
  17  * Rewritten to fit into the current U-Boot framework
  18  *
  19  * Adapted for OMAP2420 I2C, r-woodruff2@ti.com
  20  *
  21  */
  22
  23 #include <common.h>
  24
  25 #include <asm/arch/i2c.h>
  26 #include <asm/io.h>
  27
  28 static void wait_for_bb (void);
  29 static u16 wait_for_pin (void);
  30 static void flush_fifo(void);
  31
  32 void i2c_init (int speed, int slaveadd)
  33 {
  34         u16 scl;
  35
  36         writew(0x2, I2C_SYSC); /* for ES2 after soft reset */
  37         udelay(1000);
  38         writew(0x0, I2C_SYSC); /* will probably self clear but */
  39
  40         if (readw (I2C_CON) & I2C_CON_EN) {
  41                 writew (0, I2C_CON);
  42                 udelay (50000);
  43         }
  44
  45         /* 12MHz I2C module clock */
  46         writew (0, I2C_PSC);
  47         speed = speed/1000;                 /* 100 or 400 */
  48         scl = ((12000/(speed*2)) - 7);  /* use 7 when PSC = 0 */
  49         writew (scl, I2C_SCLL);
  50         writew (scl, I2C_SCLH);
  51         /* own address */
  52         writew (slaveadd, I2C_OA);
  53         writew (I2C_CON_EN, I2C_CON);
  54
  55         /* have to enable intrrupts or OMAP i2c module doesn't work */
  56         writew (I2C_IE_XRDY_IE | I2C_IE_RRDY_IE | I2C_IE_ARDY_IE |
  57                 I2C_IE_NACK_IE | I2C_IE_AL_IE, I2C_IE);
  58         udelay (1000);
  59         flush_fifo();
  60         writew (0xFFFF, I2C_STAT);
  61         writew (0, I2C_CNT);
  62 }
  63
  64 static int i2c_read_byte (u8 devaddr, u8 regoffset, u8 * value)
  65 {
  66         int i2c_error = 0;
  67         u16 status;
  68
  69         /* wait until bus not busy */
  70         wait_for_bb ();
  71
  72         /* one byte only */
  73         writew (1, I2C_CNT);
  74         /* set slave address */
  75         writew (devaddr, I2C_SA);
  76         /* no stop bit needed here */
  77         writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX, I2C_CON);
  78
  79         status = wait_for_pin ();
  80
  81         if (status & I2C_STAT_XRDY) {
  82                 /* Important: have to use byte access */
  83                 writeb (regoffset, I2C_DATA);
  84                 udelay (20000);
  85                 if (readw (I2C_STAT) & I2C_STAT_NACK) {
  86                         i2c_error = 1;
  87                 }
  88         } else {
  89                 i2c_error = 1;
  90         }
  91
  92         if (!i2c_error) {
  93                 /* free bus, otherwise we can't use a combined transction */
  94                 writew (0, I2C_CON);
  95                 while (readw (I2C_STAT) || (readw (I2C_CON) & I2C_CON_MST)) {
  96                         udelay (10000);
  97                         /* Have to clear pending interrupt to clear I2C_STAT */
  98                         writew (0xFFFF, I2C_STAT);
  99                 }
 100
 101                 wait_for_bb ();
 102                 /* set slave address */
 103                 writew (devaddr, I2C_SA);
 104                 /* read one byte from slave */
 105                 writew (1, I2C_CNT);
 106                 /* need stop bit here */
 107                 writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP,
 108                         I2C_CON);
 109
 110                 status = wait_for_pin ();
 111                 if (status & I2C_STAT_RRDY) {
 112 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
 113                         *value = readb (I2C_DATA);
 114 #else
 115                         *value = readw (I2C_DATA);
 116 #endif
 117                         udelay (20000);
 118                 } else {
 119                         i2c_error = 1;
 120                 }
 121
 122                 if (!i2c_error) {
 123                         writew (I2C_CON_EN, I2C_CON);
 124                         while (readw (I2C_STAT)
 125                                || (readw (I2C_CON) & I2C_CON_MST)) {
 126                                 udelay (10000);
 127                                 writew (0xFFFF, I2C_STAT);
 128                         }
 129                 }
 130         }
 131         flush_fifo();
 132         writew (0xFFFF, I2C_STAT);
 133         writew (0, I2C_CNT);
 134         return i2c_error;
 135 }
 136
 137 static int i2c_write_byte (u8 devaddr, u8 regoffset, u8 value)
 138 {
 139         int i2c_error = 0;
 140         u16 status, stat;
 141
 142         /* wait until bus not busy */
 143         wait_for_bb ();
 144
 145         /* two bytes */
 146         writew (2, I2C_CNT);
 147         /* set slave address */
 148         writew (devaddr, I2C_SA);
 149         /* stop bit needed here */
 150         writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_TRX |
 151                 I2C_CON_STP, I2C_CON);
 152
 153         /* wait until state change */
 154         status = wait_for_pin ();
 155
 156         if (status & I2C_STAT_XRDY) {
 157 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
 158                 /* send out 1 byte */
 159                 writeb (regoffset, I2C_DATA);
 160                 writew (I2C_STAT_XRDY, I2C_STAT);
 161
 162                 status = wait_for_pin ();
 163                 if ((status & I2C_STAT_XRDY)) {
 164                         /* send out next 1 byte */
 165                         writeb (value, I2C_DATA);
 166                         writew (I2C_STAT_XRDY, I2C_STAT);
 167                 } else {
 168                         i2c_error = 1;
 169                 }
 170 #else
 171                 /* send out two bytes */
 172                 writew ((value << 8) + regoffset, I2C_DATA);
 173 #endif
 174                 /* must have enough delay to allow BB bit to go low */
 175                 udelay (50000);
 176                 if (readw (I2C_STAT) & I2C_STAT_NACK) {
 177                         i2c_error = 1;
 178                 }
 179         } else {
 180                 i2c_error = 1;
 181         }
 182
 183         if (!i2c_error) {
 184                 int eout = 200;
 185
 186                 writew (I2C_CON_EN, I2C_CON);
 187                 while ((stat = readw (I2C_STAT)) || (readw (I2C_CON) & I2C_CON_MST)) {
 188                         udelay (1000);
 189                         /* have to read to clear intrrupt */
 190                         writew (0xFFFF, I2C_STAT);
 191                         if(--eout == 0) /* better leave with error than hang */
 192                                 break;
 193                 }
 194         }
 195         flush_fifo();
 196         writew (0xFFFF, I2C_STAT);
 197         writew (0, I2C_CNT);
 198         return i2c_error;
 199 }
 200
 201 static void flush_fifo(void)
 202 {       u16 stat;
 203
 204         /* note: if you try and read data when its not there or ready
 205          * you get a bus error
 206          */
 207         while(1){
 208                 stat = readw(I2C_STAT);
 209                 if(stat == I2C_STAT_RRDY){
 210 #if defined(CONFIG_OMAP243X) || defined(CONFIG_OMAP34XX)
 211                         readb(I2C_DATA);
 212 #else
 213                         readw(I2C_DATA);
 214 #endif
 215                         writew(I2C_STAT_RRDY,I2C_STAT);
 216                         udelay(1000);
 217                 }else
 218                         break;
 219         }
 220 }
 221
 222 int i2c_probe (uchar chip)
 223 {
 224         int res = 1; /* default = fail */
 225
 226         if (chip == readw (I2C_OA)) {
 227                 return res;
 228         }
 229
 230         /* wait until bus not busy */
 231         wait_for_bb ();
 232
 233         /* try to read one byte */
 234         writew (1, I2C_CNT);
 235         /* set slave address */
 236         writew (chip, I2C_SA);
 237         /* stop bit needed here */
 238         writew (I2C_CON_EN | I2C_CON_MST | I2C_CON_STT | I2C_CON_STP, I2C_CON);
 239         /* enough delay for the NACK bit set */
 240         udelay (50000);
 241
 242         if (!(readw (I2C_STAT) & I2C_STAT_NACK)) {
 243                 res = 0;      /* success case */
 244                 flush_fifo();
 245                 writew(0xFFFF, I2C_STAT);
 246         } else {
 247                 writew(0xFFFF, I2C_STAT);        /* failue, clear sources*/
 248                 writew (readw (I2C_CON) | I2C_CON_STP, I2C_CON); /* finish up xfer */
 249                 udelay(20000);
 250                 wait_for_bb ();
 251         }
 252         flush_fifo();
 253         writew (0, I2C_CNT); /* don't allow any more data in...we don't want it.*/
 254         writew(0xFFFF, I2C_STAT);
 255         return res;
 256 }
 257
 258 int i2c_read (uchar chip, uint addr, int alen, uchar * buffer, int len)
 259 {
 260         int i;
 261
 262         if (alen > 1) {
 263                 printf ("I2C read: addr len %d not supported\n", alen);
 264                 return 1;
 265         }
 266
 267         if (addr + len > 256) {
 268                 printf ("I2C read: address out of range\n");
 269                 return 1;
 270         }
 271
 272         for (i = 0; i < len; i++) {
 273                 if (i2c_read_byte (chip, addr + i, &buffer[i])) {
 274                         printf ("I2C read: I/O error\n");
 275                         i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 276                         return 1;
 277                 }
 278         }
 279
 280         return 0;
 281 }
 282
 283 int i2c_write (uchar chip, uint addr, int alen, uchar * buffer, int len)
 284 {
 285         int i;
 286
 287         if (alen > 1) {
 288                 printf ("I2C read: addr len %d not supported\n", alen);
 289                 return 1;
 290         }
 291
 292         if (addr + len > 256) {
 293                 printf ("I2C read: address out of range\n");
 294                 return 1;
 295         }
 296
 297         for (i = 0; i < len; i++) {
 298                 if (i2c_write_byte (chip, addr + i, buffer[i])) {
 299                         printf ("I2C read: I/O error\n");
 300                         i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 301                         return 1;
 302                 }
 303         }
 304
 305         return 0;
 306 }
 307
 308 static void wait_for_bb (void)
 309 {
 310         int timeout = 10;
 311         u16 stat;
 312
 313         writew(0xFFFF, I2C_STAT);        /* clear current interruts...*/
 314         while ((stat = readw (I2C_STAT) & I2C_STAT_BB) && timeout--) {
 315                 writew (stat, I2C_STAT);
 316                 udelay (50000);
 317         }
 318
 319         if (timeout <= 0) {
 320                 printf ("timed out in wait_for_bb: I2C_STAT=%x\n",
 321                         readw (I2C_STAT));
 322         }
 323         writew(0xFFFF, I2C_STAT);        /* clear delayed stuff*/
 324 }
 325
 326 static u16 wait_for_pin (void)
 327 {
 328         u16 status;
 329         int timeout = 10;
 330
 331         do {
 332                 udelay (1000);
 333                 status = readw (I2C_STAT);
 334         } while (  !(status &
 335                    (I2C_STAT_ROVR | I2C_STAT_XUDF | I2C_STAT_XRDY |
 336                     I2C_STAT_RRDY | I2C_STAT_ARDY | I2C_STAT_NACK |
 337                     I2C_STAT_AL)) && timeout--);
 338
 339         if (timeout <= 0) {
 340                 printf ("timed out in wait_for_pin: I2C_STAT=%x\n",
 341                         readw (I2C_STAT));
 342                         writew(0xFFFF, I2C_STAT);
 343 }
 344         return status;
 345 }