cpu/mpc83xx/i2c.c

   1 /*
   2  * (C) Copyright 2003,Motorola Inc.
   3  * Xianghua Xiao <x.xiao@motorola.com>
   4  * Adapted for Motorola 85xx chip.
   5  *
   6  * (C) Copyright 2003
   7  * Gleb Natapov <gnatapov@mrv.com>
   8  * Some bits are taken from linux driver writen by adrian@humboldt.co.uk
   9  *
  10  * Hardware I2C driver for MPC107 PCI bridge.
  11  *
  12  * See file CREDITS for list of people who contributed to this
  13  * project.
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License as
  17  * published by the Free Software Foundation; either version 2 of
  18  * the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  * MA 02111-1307 USA
  29  *
  30  * Change log:
  31  *
  32  * 20050101: Eran Liberty (liberty@freescale.com)
  33  *           Initial file creating (porting from 85XX & 8260)
  34  */
  35
  36 #include <common.h>
  37 #include <command.h>
  38 #include <asm/io.h>
  39
  40 #ifdef CONFIG_HARD_I2C
  41 #include <i2c.h>
  42 #include <asm/i2c.h>
  43
  44 #ifdef CONFIG_MPC8349ADS
  45 i2c_t * mpc8349_i2c = (i2c_t*)(CFG_IMMRBAR + CFG_I2C_OFFSET);
  46 #endif
  47
  48 void
  49 i2c_init(int speed, int slaveadd)
  50 {
  51         /* stop I2C controller */
  52         writeb(0x00 , &I2C->cr);
  53
  54         /* set clock */
  55         writeb(0x3f, &I2C->fdr);
  56
  57         /* set default filter */
  58         writeb(0x10,&I2C->dfsrr);
  59
  60         /* write slave address */
  61         writeb(slaveadd, &I2C->adr);
  62
  63         /* clear status register */
  64         writeb(0x00, &I2C->sr);
  65
  66         /* start I2C controller */
  67         writeb(I2C_CR_MEN, &I2C->cr);
  68 }
  69
  70 static __inline__ int
  71 i2c_wait4bus (void)
  72 {
  73         ulong timeval = get_timer (0);
  74         while (readb(&I2C->sr) & I2C_SR_MBB) {
  75                 if (get_timer (timeval) > I2C_TIMEOUT) {
  76                         return -1;
  77                 }
  78         }
  79         return 0;
  80 }
  81
  82 static __inline__ int
  83 i2c_wait (int write)
  84 {
  85         u32 csr;
  86         ulong timeval = get_timer(0);
  87         do {
  88                 csr = readb(&I2C->sr);
  89
  90                 if (!(csr & I2C_SR_MIF))
  91                         continue;
  92
  93                 writeb(0x0, &I2C->sr);
  94
  95                 if (csr & I2C_SR_MAL) {
  96                         debug("i2c_wait: MAL\n");
  97                         return -1;
  98                 }
  99
 100                 if (!(csr & I2C_SR_MCF))        {
 101                         debug("i2c_wait: unfinished\n");
 102                         return -1;
 103                 }
 104
 105                 if (write == I2C_WRITE && (csr & I2C_SR_RXAK)) {
 106                         debug("i2c_wait: No RXACK\n");
 107                         return -1;
 108                 }
 109
 110                 return 0;
 111         } while (get_timer (timeval) < I2C_TIMEOUT);
 112         debug("i2c_wait: timed out\n");
 113 }
 114
 115 static __inline__ int
 116 i2c_write_addr (u8 dev, u8 dir, int rsta)
 117 {
 118         writeb(I2C_CR_MEN | I2C_CR_MSTA | I2C_CR_MTX |
 119                (rsta?I2C_CR_RSTA:0),
 120                &I2C->cr);
 121
 122         writeb((dev << 1) | dir, &I2C->dr);
 123
 124         if (i2c_wait (I2C_WRITE) < 0)
 125                 return 0;
 126         return 1;
 127 }
 128
 129 static __inline__ int
 130 __i2c_write (u8 *data, int length)
 131 {
 132         int i;
 133
 134         writeb(I2C_CR_MEN | I2C_CR_MSTA | I2C_CR_MTX,
 135                &I2C->cr);
 136
 137         for (i=0; i < length; i++) {
 138                 writeb(data[i], &I2C->dr);
 139
 140                 if (i2c_wait (I2C_WRITE) < 0)
 141                         break;
 142         }
 143         return i;
 144 }
 145
 146 static __inline__ int
 147 __i2c_read (u8 *data, int length)
 148 {
 149         int i;
 150
 151         writeb(I2C_CR_MEN | I2C_CR_MSTA |
 152                ((length == 1) ? I2C_CR_TXAK : 0),
 153                &I2C->cr);
 154
 155         /* dummy read */
 156         readb(&I2C->dr);
 157
 158         for (i=0; i < length; i++) {
 159                 if (i2c_wait (I2C_READ) < 0)
 160                         break;
 161
 162                 /* Generate ack on last next to last byte */
 163                 if (i == length - 2)
 164                         writeb(I2C_CR_MEN | I2C_CR_MSTA |
 165                                I2C_CR_TXAK,
 166                                &I2C->cr);
 167
 168                 /* Generate stop on last byte */
 169                 if (i == length - 1)
 170                         writeb(I2C_CR_MEN | I2C_CR_TXAK, &I2C->cr);
 171
 172                 data[i] = readb(&I2C->dr);
 173         }
 174         return i;
 175 }
 176
 177 int
 178 i2c_read (u8 dev, uint addr, int alen, u8 *data, int length)
 179 {
 180         int i = 0;
 181         u8 *a = (u8*)&addr;
 182
 183         if (i2c_wait4bus () < 0)
 184                 goto exit;
 185
 186         if (i2c_write_addr (dev, I2C_WRITE, 0) == 0)
 187                 goto exit;
 188
 189         if (__i2c_write (&a[4 - alen], alen) != alen)
 190                 goto exit;
 191
 192         if (i2c_write_addr (dev, I2C_READ, 1) == 0)
 193                 goto exit;
 194
 195         i = __i2c_read (data, length);
 196
 197  exit:
 198         writeb(I2C_CR_MEN, &I2C->cr);
 199         return !(i == length);
 200 }
 201
 202 int
 203 i2c_write (u8 dev, uint addr, int alen, u8 *data, int length)
 204 {
 205         int i = 0;
 206         u8 *a = (u8*)&addr;
 207
 208         if (i2c_wait4bus () < 0)
 209                 goto exit;
 210
 211         if (i2c_write_addr (dev, I2C_WRITE, 0) == 0)
 212                 goto exit;
 213
 214         if (__i2c_write (&a[4 - alen], alen) != alen)
 215                 goto exit;
 216
 217         i = __i2c_write (data, length);
 218
 219  exit:
 220         writeb(I2C_CR_MEN, &I2C->cr);
 221         return !(i == length);
 222 }
 223
 224 int i2c_probe (uchar chip)
 225 {
 226         int tmp;
 227
 228         /*
 229          * Try to read the first location of the chip.  The underlying
 230          * driver doesn't appear to support sending just the chip address
 231          * and looking for an <ACK> back.
 232          */
 233         udelay(10000);
 234         return i2c_read (chip, 0, 1, (char *)&tmp, 1);
 235 }
 236
 237 uchar i2c_reg_read (uchar i2c_addr, uchar reg)
 238 {
 239         char buf[1];
 240
 241         i2c_read (i2c_addr, reg, 1, buf, 1);
 242
 243         return (buf[0]);
 244 }
 245
 246 void i2c_reg_write (uchar i2c_addr, uchar reg, uchar val)
 247 {
 248         i2c_write (i2c_addr, reg, 1, &val, 1);
 249 }
 250
 251 #endif /* CONFIG_HARD_I2C */