soft_i2c.c 9.71 KB
Newer Older
wdenk's avatar
wdenk committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * (C) Copyright 2001, 2002
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 *
 * This has been changed substantially by Gerald Van Baren, Custom IDEAS,
 * vanbaren@cideas.com.  It was heavily influenced by LiMon, written by
 * Neil Russell.
 */

#include <common.h>
#ifdef	CONFIG_MPC8260			/* only valid for MPC8260 */
#include <ioports.h>
31
#include <asm/io.h>
wdenk's avatar
wdenk committed
32
#endif
33
#ifdef	CONFIG_AT91RM9200		/* need this for the at91rm9200 */
34
35
36
#include <asm/io.h>
#include <asm/arch/hardware.h>
#endif
Wolfgang Denk's avatar
Wolfgang Denk committed
37
38
39
#ifdef	CONFIG_IXP425			/* only valid for IXP425 */
#include <asm/arch/ixp425.h>
#endif
Peter Pearse's avatar
Peter Pearse committed
40
41
42
#ifdef CONFIG_LPC2292
#include <asm/arch/hardware.h>
#endif
43
#if defined(CONFIG_MPC852T) || defined(CONFIG_MPC866)
44
45
#include <asm/io.h>
#endif
wdenk's avatar
wdenk committed
46
47
48
49
#include <i2c.h>

/* #define	DEBUG_I2C	*/

50
51
52
53
#ifdef DEBUG_I2C
DECLARE_GLOBAL_DATA_PTR;
#endif

wdenk's avatar
wdenk committed
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*-----------------------------------------------------------------------
 * Definitions
 */

#define RETRIES		0

#define I2C_ACK		0		/* PD_SDA level to ack a byte */
#define I2C_NOACK	1		/* PD_SDA level to noack a byte */


#ifdef DEBUG_I2C
#define PRINTD(fmt,args...)	do {	\
	if (gd->have_console)		\
		printf (fmt ,##args);	\
	} while (0)
#else
#define PRINTD(fmt,args...)
#endif

73
#if defined(CONFIG_I2C_MULTI_BUS)
74
static unsigned int i2c_bus_num __attribute__ ((section (".data"))) = 0;
75
76
#endif /* CONFIG_I2C_MULTI_BUS */

wdenk's avatar
wdenk committed
77
78
79
/*-----------------------------------------------------------------------
 * Local functions
 */
80
#if !defined(CONFIG_SYS_I2C_INIT_BOARD)
wdenk's avatar
wdenk committed
81
static void  send_reset	(void);
82
#endif
wdenk's avatar
wdenk committed
83
84
85
86
87
88
static void  send_start	(void);
static void  send_stop	(void);
static void  send_ack	(int);
static int   write_byte	(uchar byte);
static uchar read_byte	(int);

89
#if !defined(CONFIG_SYS_I2C_INIT_BOARD)
wdenk's avatar
wdenk committed
90
91
92
93
94
95
96
/*-----------------------------------------------------------------------
 * Send a reset sequence consisting of 9 clocks with the data signal high
 * to clock any confused device back into an idle state.  Also send a
 * <stop> at the end of the sequence for belts & suspenders.
 */
static void send_reset(void)
{
97
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
98
99
	int j;

wdenk's avatar
wdenk committed
100
	I2C_SCL(1);
wdenk's avatar
wdenk committed
101
	I2C_SDA(1);
wdenk's avatar
wdenk committed
102
103
104
105
#ifdef	I2C_INIT
	I2C_INIT;
#endif
	I2C_TRISTATE;
wdenk's avatar
wdenk committed
106
107
108
109
110
111
112
113
114
115
116
	for(j = 0; j < 9; j++) {
		I2C_SCL(0);
		I2C_DELAY;
		I2C_DELAY;
		I2C_SCL(1);
		I2C_DELAY;
		I2C_DELAY;
	}
	send_stop();
	I2C_TRISTATE;
}
117
#endif
wdenk's avatar
wdenk committed
118
119
120
121
122
123

/*-----------------------------------------------------------------------
 * START: High -> Low on SDA while SCL is High
 */
static void send_start(void)
{
124
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

	I2C_DELAY;
	I2C_SDA(1);
	I2C_ACTIVE;
	I2C_DELAY;
	I2C_SCL(1);
	I2C_DELAY;
	I2C_SDA(0);
	I2C_DELAY;
}

/*-----------------------------------------------------------------------
 * STOP: Low -> High on SDA while SCL is High
 */
static void send_stop(void)
{
141
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

	I2C_SCL(0);
	I2C_DELAY;
	I2C_SDA(0);
	I2C_ACTIVE;
	I2C_DELAY;
	I2C_SCL(1);
	I2C_DELAY;
	I2C_SDA(1);
	I2C_DELAY;
	I2C_TRISTATE;
}

/*-----------------------------------------------------------------------
 * ack should be I2C_ACK or I2C_NOACK
 */
static void send_ack(int ack)
{
160
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
161
162
163
164

	I2C_SCL(0);
	I2C_DELAY;
	I2C_ACTIVE;
165
	I2C_SDA(ack);
wdenk's avatar
wdenk committed
166
167
168
169
170
171
172
173
174
175
176
177
178
	I2C_DELAY;
	I2C_SCL(1);
	I2C_DELAY;
	I2C_DELAY;
	I2C_SCL(0);
	I2C_DELAY;
}

/*-----------------------------------------------------------------------
 * Send 8 bits and look for an acknowledgement.
 */
static int write_byte(uchar data)
{
179
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
	int j;
	int nack;

	I2C_ACTIVE;
	for(j = 0; j < 8; j++) {
		I2C_SCL(0);
		I2C_DELAY;
		I2C_SDA(data & 0x80);
		I2C_DELAY;
		I2C_SCL(1);
		I2C_DELAY;
		I2C_DELAY;

		data <<= 1;
	}

	/*
	 * Look for an <ACK>(negative logic) and return it.
	 */
	I2C_SCL(0);
	I2C_DELAY;
	I2C_SDA(1);
	I2C_TRISTATE;
	I2C_DELAY;
	I2C_SCL(1);
	I2C_DELAY;
	I2C_DELAY;
	nack = I2C_READ;
	I2C_SCL(0);
	I2C_DELAY;
	I2C_ACTIVE;

	return(nack);	/* not a nack is an ack */
}

215
216
217
218
219
220
221
222
223
224
225
#if defined(CONFIG_I2C_MULTI_BUS)
/*
 * Functions for multiple I2C bus handling
 */
unsigned int i2c_get_bus_num(void)
{
	return i2c_bus_num;
}

int i2c_set_bus_num(unsigned int bus)
{
226
#if defined(CONFIG_I2C_MUX)
227
	if (bus < CONFIG_SYS_MAX_I2C_BUS) {
228
229
230
231
232
233
234
235
236
237
238
		i2c_bus_num = bus;
	} else {
		int	ret;

		ret = i2x_mux_select_mux(bus);
		if (ret == 0)
			i2c_bus_num = bus;
		else
			return ret;
	}
#else
239
	if (bus >= CONFIG_SYS_MAX_I2C_BUS)
240
241
		return -1;
	i2c_bus_num = bus;
242
#endif
243
244
	return 0;
}
245
#endif
246

wdenk's avatar
wdenk committed
247
248
249
250
251
252
/*-----------------------------------------------------------------------
 * if ack == I2C_ACK, ACK the byte so can continue reading, else
 * send I2C_NOACK to end the read.
 */
static uchar read_byte(int ack)
{
253
	I2C_SOFT_DECLARATIONS	/* intentional without ';' */
wdenk's avatar
wdenk committed
254
255
256
257
258
259
260
	int  data;
	int  j;

	/*
	 * Read 8 bits, MSB first.
	 */
	I2C_TRISTATE;
261
	I2C_SDA(1);
wdenk's avatar
wdenk committed
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
	data = 0;
	for(j = 0; j < 8; j++) {
		I2C_SCL(0);
		I2C_DELAY;
		I2C_SCL(1);
		I2C_DELAY;
		data <<= 1;
		data |= I2C_READ;
		I2C_DELAY;
	}
	send_ack(ack);

	return(data);
}

/*=====================================================================*/
/*                         Public Functions                            */
/*=====================================================================*/

/*-----------------------------------------------------------------------
 * Initialization
 */
void i2c_init (int speed, int slaveaddr)
{
286
#if defined(CONFIG_SYS_I2C_INIT_BOARD)
287
288
289
290
291
	/* call board specific i2c bus reset routine before accessing the   */
	/* environment, which might be in a chip on that bus. For details   */
	/* about this problem see doc/I2C_Edge_Conditions.                  */
	i2c_init_board();
#else
wdenk's avatar
wdenk committed
292
	/*
wdenk's avatar
wdenk committed
293
294
295
296
	 * WARNING: Do NOT save speed in a static variable: if the
	 * I2C routines are called before RAM is initialized (to read
	 * the DIMM SPD, for instance), RAM won't be usable and your
	 * system will crash.
wdenk's avatar
wdenk committed
297
298
	 */
	send_reset ();
299
#endif
wdenk's avatar
wdenk committed
300
301
302
303
304
305
306
307
308
309
310
}

/*-----------------------------------------------------------------------
 * Probe to see if a chip is present.  Also good for checking for the
 * completion of EEPROM writes since the chip stops responding until
 * the write completes (typically 10mSec).
 */
int i2c_probe(uchar addr)
{
	int rc;

311
	/*
Wolfgang Denk's avatar
Wolfgang Denk committed
312
	 * perform 1 byte write transaction with just address byte
313
314
	 * (fake write)
	 */
wdenk's avatar
wdenk committed
315
	send_start();
316
	rc = write_byte ((addr << 1) | 0);
wdenk's avatar
wdenk committed
317
318
319
320
321
322
323
324
325
326
327
328
329
330
	send_stop();

	return (rc ? 1 : 0);
}

/*-----------------------------------------------------------------------
 * Read bytes
 */
int  i2c_read(uchar chip, uint addr, int alen, uchar *buffer, int len)
{
	int shift;
	PRINTD("i2c_read: chip %02X addr %02X alen %d buffer %p len %d\n",
		chip, addr, alen, buffer, len);

331
#ifdef CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW
wdenk's avatar
wdenk committed
332
333
334
335
336
337
338
339
340
341
342
	/*
	 * EEPROM chips that implement "address overflow" are ones
	 * like Catalyst 24WC04/08/16 which has 9/10/11 bits of
	 * address and the extra bits end up in the "chip address"
	 * bit slots. This makes a 24WC08 (1Kbyte) chip look like
	 * four 256 byte chips.
	 *
	 * Note that we consider the length of the address field to
	 * still be one byte because the extra address bits are
	 * hidden in the chip address.
	 */
343
	chip |= ((addr >> (alen * 8)) & CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW);
wdenk's avatar
wdenk committed
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369

	PRINTD("i2c_read: fix addr_overflow: chip %02X addr %02X\n",
		chip, addr);
#endif

	/*
	 * Do the addressing portion of a write cycle to set the
	 * chip's address pointer.  If the address length is zero,
	 * don't do the normal write cycle to set the address pointer,
	 * there is no address pointer in this chip.
	 */
	send_start();
	if(alen > 0) {
		if(write_byte(chip << 1)) {	/* write cycle */
			send_stop();
			PRINTD("i2c_read, no chip responded %02X\n", chip);
			return(1);
		}
		shift = (alen-1) * 8;
		while(alen-- > 0) {
			if(write_byte(addr >> shift)) {
				PRINTD("i2c_read, address not <ACK>ed\n");
				return(1);
			}
			shift -= 8;
		}
370
371
372
373
374
375
376
377
378
379

		/* Some I2C chips need a stop/start sequence here,
		 * other chips don't work with a full stop and need
		 * only a start.  Default behaviour is to send the
		 * stop/start sequence.
		 */
#ifdef CONFIG_SOFT_I2C_READ_REPEATED_START
		send_start();
#else
		send_stop();
wdenk's avatar
wdenk committed
380
		send_start();
381
#endif
wdenk's avatar
wdenk committed
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
	}
	/*
	 * Send the chip address again, this time for a read cycle.
	 * Then read the data.  On the last byte, we do a NACK instead
	 * of an ACK(len == 0) to terminate the read.
	 */
	write_byte((chip << 1) | 1);	/* read cycle */
	while(len-- > 0) {
		*buffer++ = read_byte(len == 0);
	}
	send_stop();
	return(0);
}

/*-----------------------------------------------------------------------
 * Write bytes
 */
int  i2c_write(uchar chip, uint addr, int alen, uchar *buffer, int len)
{
	int shift, failures = 0;

	PRINTD("i2c_write: chip %02X addr %02X alen %d buffer %p len %d\n",
		chip, addr, alen, buffer, len);

	send_start();
	if(write_byte(chip << 1)) {	/* write cycle */
		send_stop();
		PRINTD("i2c_write, no chip responded %02X\n", chip);
		return(1);
	}
	shift = (alen-1) * 8;
	while(alen-- > 0) {
		if(write_byte(addr >> shift)) {
			PRINTD("i2c_write, address not <ACK>ed\n");
			return(1);
		}
		shift -= 8;
	}

	while(len-- > 0) {
		if(write_byte(*buffer++)) {
			failures++;
		}
	}
	send_stop();
	return(failures);
}