drivers/i2c/mv_i2c.c

   1 /*
   2  * (C) Copyright 2000
   3  * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
   4  *
   5  * (C) Copyright 2000 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   6  * Marius Groeger <mgroeger@sysgo.de>
   7  *
   8  * (C) Copyright 2003 Pengutronix e.K.
   9  * Robert Schwebel <r.schwebel@pengutronix.de>
  10  *
  11  * See file CREDITS for list of people who contributed to this
  12  * project.
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License as
  16  * published by the Free Software Foundation; either version 2 of
  17  * the License, or (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  27  * MA 02111-1307 USA
  28  *
  29  * Back ported to the 8xx platform (from the 8260 platform) by
  30  * Murray.Jensen@cmst.csiro.au, 27-Jan-01.
  31  */
  32
  33 #include <common.h>
  34 #include <asm/io.h>
  35
  36 #ifdef CONFIG_HARD_I2C
  37
  38 /*
  39  *      - CONFIG_SYS_I2C_SPEED
  40  *      - I2C_PXA_SLAVE_ADDR
  41  */
  42
  43 #include <asm/arch/hardware.h>
  44 #include <asm/arch/pxa-regs.h>
  45 #include <i2c.h>
  46
  47 #if (CONFIG_SYS_I2C_SPEED == 400000)
  48 #define I2C_ICR_INIT    (ICR_FM | ICR_BEIE | ICR_IRFIE | ICR_ITEIE | ICR_GCD \
  49                         | ICR_SCLE)
  50 #else
  51 #define I2C_ICR_INIT    (ICR_BEIE | ICR_IRFIE | ICR_ITEIE | ICR_GCD | ICR_SCLE)
  52 #endif
  53
  54 #define I2C_ISR_INIT            0x7FF
  55
  56 #ifdef DEBUG_I2C
  57 #define PRINTD(x) printf x
  58 #else
  59 #define PRINTD(x)
  60 #endif
  61
  62 /* Shall the current transfer have a start/stop condition? */
  63 #define I2C_COND_NORMAL         0
  64 #define I2C_COND_START          1
  65 #define I2C_COND_STOP           2
  66
  67 /* Shall the current transfer be ack/nacked or being waited for it? */
  68 #define I2C_ACKNAK_WAITACK      1
  69 #define I2C_ACKNAK_SENDACK      2
  70 #define I2C_ACKNAK_SENDNAK      4
  71
  72 /* Specify who shall transfer the data (master or slave) */
  73 #define I2C_READ                0
  74 #define I2C_WRITE               1
  75
  76 /* All transfers are described by this data structure */
  77 struct i2c_msg {
  78         u8 condition;
  79         u8 acknack;
  80         u8 direction;
  81         u8 data;
  82 };
  83
  84 /*
  85  * i2c_pxa_reset: - reset the host controller
  86  *
  87  */
  88 static void i2c_reset(void)
  89 {
  90         writel(readl(ICR) & ~ICR_IUE, ICR);     /* disable unit */
  91         writel(readl(ICR) | ICR_UR, ICR);       /* reset the unit */
  92         udelay(100);
  93         writel(readl(ICR) & ~ICR_IUE, ICR);     /* disable unit */
  94 #ifdef CONFIG_CPU_MONAHANS
  95         /* | CKENB_1_PWM1 | CKENB_0_PWM0); */
  96         writel(readl(CKENB) | (CKENB_4_I2C), CKENB);
  97 #else /* CONFIG_CPU_MONAHANS */
  98         /* set the global I2C clock on */
  99         writel(readl(CKEN) | CKEN14_I2C, CKEN);
 100 #endif
 101         writel(I2C_PXA_SLAVE_ADDR, ISAR);       /* set our slave address */
 102         writel(I2C_ICR_INIT, ICR);              /* set control reg values */
 103         writel(I2C_ISR_INIT, ISR);              /* set clear interrupt bits */
 104         writel(readl(ICR) | ICR_IUE, ICR);      /* enable unit */
 105         udelay(100);
 106 }
 107
 108 /*
 109  * i2c_isr_set_cleared: - wait until certain bits of the I2C status register
 110  *                        are set and cleared
 111  *
 112  * @return: 1 in case of success, 0 means timeout (no match within 10 ms).
 113  */
 114 static int i2c_isr_set_cleared(unsigned long set_mask,
 115                                unsigned long cleared_mask)
 116 {
 117         int timeout = 10000;
 118
 119         while (((ISR & set_mask) != set_mask) || ((ISR & cleared_mask) != 0)) {
 120                 udelay(10);
 121                 if (timeout-- < 0)
 122                         return 0;
 123         }
 124
 125         return 1;
 126 }
 127
 128 /*
 129  * i2c_transfer: - Transfer one byte over the i2c bus
 130  *
 131  * This function can tranfer a byte over the i2c bus in both directions.
 132  * It is used by the public API functions.
 133  *
 134  * @return:  0: transfer successful
 135  *          -1: message is empty
 136  *          -2: transmit timeout
 137  *          -3: ACK missing
 138  *          -4: receive timeout
 139  *          -5: illegal parameters
 140  *          -6: bus is busy and couldn't be aquired
 141  */
 142 int i2c_transfer(struct i2c_msg *msg)
 143 {
 144         int ret;
 145
 146         if (!msg)
 147                 goto transfer_error_msg_empty;
 148
 149         switch (msg->direction) {
 150         case I2C_WRITE:
 151                 /* check if bus is not busy */
 152                 if (!i2c_isr_set_cleared(0, ISR_IBB))
 153                         goto transfer_error_bus_busy;
 154
 155                 /* start transmission */
 156                 writel(readl(ICR) & ~ICR_START, ICR);
 157                 writel(readl(ICR) & ~ICR_STOP, ICR);
 158                 writel(msg->data, IDBR);
 159                 if (msg->condition == I2C_COND_START)
 160                         writel(readl(ICR) | ICR_START, ICR);
 161                 if (msg->condition == I2C_COND_STOP)
 162                         writel(readl(ICR) | ICR_STOP, ICR);
 163                 if (msg->acknack == I2C_ACKNAK_SENDNAK)
 164                         writel(readl(ICR) | ICR_ACKNAK, ICR);
 165                 if (msg->acknack == I2C_ACKNAK_SENDACK)
 166                         writel(readl(ICR) & ~ICR_ACKNAK, ICR);
 167                 writel(readl(ICR) & ~ICR_ALDIE, ICR);
 168                 writel(readl(ICR) | ICR_TB, ICR);
 169
 170                 /* transmit register empty? */
 171                 if (!i2c_isr_set_cleared(ISR_ITE, 0))
 172                         goto transfer_error_transmit_timeout;
 173
 174                 /* clear 'transmit empty' state */
 175                 writel(readl(ISR) | ISR_ITE, ISR);
 176
 177                 /* wait for ACK from slave */
 178                 if (msg->acknack == I2C_ACKNAK_WAITACK)
 179                         if (!i2c_isr_set_cleared(0, ISR_ACKNAK))
 180                                 goto transfer_error_ack_missing;
 181                 break;
 182
 183         case I2C_READ:
 184
 185                 /* check if bus is not busy */
 186                 if (!i2c_isr_set_cleared(0, ISR_IBB))
 187                         goto transfer_error_bus_busy;
 188
 189                 /* start receive */
 190                 writel(readl(ICR) & ~ICR_START, ICR);
 191                 writel(readl(ICR) & ~ICR_STOP, ICR);
 192                 if (msg->condition == I2C_COND_START)
 193                         writel(readl(ICR) | ICR_START, ICR);
 194                 if (msg->condition == I2C_COND_STOP)
 195                         writel(readl(ICR) | ICR_STOP, ICR);
 196                 if (msg->acknack == I2C_ACKNAK_SENDNAK)
 197                         writel(readl(ICR) | ICR_ACKNAK, ICR);
 198                 if (msg->acknack == I2C_ACKNAK_SENDACK)
 199                         writel(readl(ICR) & ~ICR_ACKNAK, ICR);
 200                 writel(readl(ICR) & ~ICR_ALDIE, ICR);
 201                 writel(readl(ICR) | ICR_TB, ICR);
 202
 203                 /* receive register full? */
 204                 if (!i2c_isr_set_cleared(ISR_IRF, 0))
 205                         goto transfer_error_receive_timeout;
 206
 207                 msg->data = readl(IDBR);
 208
 209                 /* clear 'receive empty' state */
 210                 writel(readl(ISR) | ISR_IRF, ISR);
 211
 212                 break;
 213         default:
 214                 goto transfer_error_illegal_param;
 215         }
 216
 217         return 0;
 218
 219 transfer_error_msg_empty:
 220                 PRINTD(("i2c_transfer: error: 'msg' is empty\n"));
 221                 ret = -1; goto i2c_transfer_finish;
 222
 223 transfer_error_transmit_timeout:
 224                 PRINTD(("i2c_transfer: error: transmit timeout\n"));
 225                 ret = -2; goto i2c_transfer_finish;
 226
 227 transfer_error_ack_missing:
 228                 PRINTD(("i2c_transfer: error: ACK missing\n"));
 229                 ret = -3; goto i2c_transfer_finish;
 230
 231 transfer_error_receive_timeout:
 232                 PRINTD(("i2c_transfer: error: receive timeout\n"));
 233                 ret = -4; goto i2c_transfer_finish;
 234
 235 transfer_error_illegal_param:
 236                 PRINTD(("i2c_transfer: error: illegal parameters\n"));
 237                 ret = -5; goto i2c_transfer_finish;
 238
 239 transfer_error_bus_busy:
 240                 PRINTD(("i2c_transfer: error: bus is busy\n"));
 241                 ret = -6; goto i2c_transfer_finish;
 242
 243 i2c_transfer_finish:
 244                 PRINTD(("i2c_transfer: ISR: 0x%04x\n", ISR));
 245                 i2c_reset();
 246                 return ret;
 247 }
 248
 249 /* ------------------------------------------------------------------------ */
 250 /* API Functions                                                            */
 251 /* ------------------------------------------------------------------------ */
 252 void i2c_init(int speed, int slaveaddr)
 253 {
 254 #ifdef CONFIG_SYS_I2C_INIT_BOARD
 255         /* call board specific i2c bus reset routine before accessing the   */
 256         /* environment, which might be in a chip on that bus. For details   */
 257         /* about this problem see doc/I2C_Edge_Conditions.                  */
 258         i2c_init_board();
 259 #endif
 260 }
 261
 262 /*
 263  * i2c_probe: - Test if a chip answers for a given i2c address
 264  *
 265  * @chip:       address of the chip which is searched for
 266  * @return:     0 if a chip was found, -1 otherwhise
 267  */
 268 int i2c_probe(uchar chip)
 269 {
 270         struct i2c_msg msg;
 271
 272         i2c_reset();
 273
 274         msg.condition = I2C_COND_START;
 275         msg.acknack   = I2C_ACKNAK_WAITACK;
 276         msg.direction = I2C_WRITE;
 277         msg.data      = (chip << 1) + 1;
 278         if (i2c_transfer(&msg))
 279                 return -1;
 280
 281         msg.condition = I2C_COND_STOP;
 282         msg.acknack   = I2C_ACKNAK_SENDNAK;
 283         msg.direction = I2C_READ;
 284         msg.data      = 0x00;
 285         if (i2c_transfer(&msg))
 286                 return -1;
 287
 288         return 0;
 289 }
 290
 291 /*
 292  * i2c_read: - Read multiple bytes from an i2c device
 293  *
 294  * The higher level routines take into account that this function is only
 295  * called with len < page length of the device (see configuration file)
 296  *
 297  * @chip:       address of the chip which is to be read
 298  * @addr:       i2c data address within the chip
 299  * @alen:       length of the i2c data address (1..2 bytes)
 300  * @buffer:     where to write the data
 301  * @len:        how much byte do we want to read
 302  * @return:     0 in case of success
 303  */
 304 int i2c_read(uchar chip, uint addr, int alen, uchar *buffer, int len)
 305 {
 306         struct i2c_msg msg;
 307         u8 addr_bytes[3]; /* lowest...highest byte of data address */
 308
 309         PRINTD(("i2c_read(chip=0x%02x, addr=0x%02x, alen=0x%02x, "
 310                 "len=0x%02x)\n", chip, addr, alen, len));
 311
 312         i2c_reset();
 313
 314         /* dummy chip address write */
 315         PRINTD(("i2c_read: dummy chip address write\n"));
 316         msg.condition = I2C_COND_START;
 317         msg.acknack   = I2C_ACKNAK_WAITACK;
 318         msg.direction = I2C_WRITE;
 319         msg.data = (chip << 1);
 320         msg.data &= 0xFE;
 321         if (i2c_transfer(&msg))
 322                 return -1;
 323
 324         /*
 325          * send memory address bytes;
 326          * alen defines how much bytes we have to send.
 327          */
 328         /*addr &= ((1 << CONFIG_SYS_EEPROM_PAGE_WRITE_BITS)-1); */
 329         addr_bytes[0] = (u8)((addr >>  0) & 0x000000FF);
 330         addr_bytes[1] = (u8)((addr >>  8) & 0x000000FF);
 331         addr_bytes[2] = (u8)((addr >> 16) & 0x000000FF);
 332
 333         while (--alen >= 0) {
 334                 PRINTD(("i2c_read: send memory word address byte %1d\n", alen));
 335                 msg.condition = I2C_COND_NORMAL;
 336                 msg.acknack   = I2C_ACKNAK_WAITACK;
 337                 msg.direction = I2C_WRITE;
 338                 msg.data      = addr_bytes[alen];
 339                 if (i2c_transfer(&msg))
 340                         return -1;
 341         }
 342
 343         /* start read sequence */
 344         PRINTD(("i2c_read: start read sequence\n"));
 345         msg.condition = I2C_COND_START;
 346         msg.acknack   = I2C_ACKNAK_WAITACK;
 347         msg.direction = I2C_WRITE;
 348         msg.data      = (chip << 1);
 349         msg.data     |= 0x01;
 350         if (i2c_transfer(&msg))
 351                 return -1;
 352
 353         /* read bytes; send NACK at last byte */
 354         while (len--) {
 355                 if (len == 0) {
 356                         msg.condition = I2C_COND_STOP;
 357                         msg.acknack   = I2C_ACKNAK_SENDNAK;
 358                 } else {
 359                         msg.condition = I2C_COND_NORMAL;
 360                         msg.acknack   = I2C_ACKNAK_SENDACK;
 361                 }
 362
 363                 msg.direction = I2C_READ;
 364                 msg.data      = 0x00;
 365                 if (i2c_transfer(&msg))
 366                         return -1;
 367
 368                 *buffer = msg.data;
 369                 PRINTD(("i2c_read: reading byte (0x%08x)=0x%02x\n",
 370                         (unsigned int)buffer, *buffer));
 371                 buffer++;
 372         }
 373
 374         i2c_reset();
 375
 376         return 0;
 377 }
 378
 379 /*
 380  * i2c_write: -  Write multiple bytes to an i2c device
 381  *
 382  * The higher level routines take into account that this function is only
 383  * called with len < page length of the device (see configuration file)
 384  *
 385  * @chip:       address of the chip which is to be written
 386  * @addr:       i2c data address within the chip
 387  * @alen:       length of the i2c data address (1..2 bytes)
 388  * @buffer:     where to find the data to be written
 389  * @len:        how much byte do we want to read
 390  * @return:     0 in case of success
 391  */
 392 int i2c_write(uchar chip, uint addr, int alen, uchar *buffer, int len)
 393 {
 394         struct i2c_msg msg;
 395         u8 addr_bytes[3]; /* lowest...highest byte of data address */
 396
 397         PRINTD(("i2c_write(chip=0x%02x, addr=0x%02x, alen=0x%02x, "
 398                 "len=0x%02x)\n", chip, addr, alen, len));
 399
 400         i2c_reset();
 401
 402         /* chip address write */
 403         PRINTD(("i2c_write: chip address write\n"));
 404         msg.condition = I2C_COND_START;
 405         msg.acknack   = I2C_ACKNAK_WAITACK;
 406         msg.direction = I2C_WRITE;
 407         msg.data = (chip << 1);
 408         msg.data &= 0xFE;
 409         if (i2c_transfer(&msg))
 410                 return -1;
 411
 412         /*
 413          * send memory address bytes;
 414          * alen defines how much bytes we have to send.
 415          */
 416         addr_bytes[0] = (u8)((addr >>  0) & 0x000000FF);
 417         addr_bytes[1] = (u8)((addr >>  8) & 0x000000FF);
 418         addr_bytes[2] = (u8)((addr >> 16) & 0x000000FF);
 419
 420         while (--alen >= 0) {
 421                 PRINTD(("i2c_write: send memory word address\n"));
 422                 msg.condition = I2C_COND_NORMAL;
 423                 msg.acknack   = I2C_ACKNAK_WAITACK;
 424                 msg.direction = I2C_WRITE;
 425                 msg.data      = addr_bytes[alen];
 426                 if (i2c_transfer(&msg))
 427                         return -1;
 428         }
 429
 430         /* write bytes; send NACK at last byte */
 431         while (len--) {
 432                 PRINTD(("i2c_write: writing byte (0x%08x)=0x%02x\n",
 433                         (unsigned int)buffer, *buffer));
 434
 435                 if (len == 0)
 436                         msg.condition = I2C_COND_STOP;
 437                 else
 438                         msg.condition = I2C_COND_NORMAL;
 439
 440                 msg.acknack   = I2C_ACKNAK_WAITACK;
 441                 msg.direction = I2C_WRITE;
 442                 msg.data      = *(buffer++);
 443
 444                 if (i2c_transfer(&msg))
 445                         return -1;
 446         }
 447
 448         i2c_reset();
 449
 450         return 0;
 451 }
 452 #endif  /* CONFIG_HARD_I2C */