[people/ms/u-boot.git] / drivers / i2c / designware_i2c.c

/*
 * (C) Copyright 2009
 * Vipin Kumar, ST Micoelectronics, vipin.kumar@st.com.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <asm/io.h>
#include <asm/arch/hardware.h>
#include "designware_i2c.h"

#ifdef CONFIG_I2C_MULTI_BUS
static unsigned int bus_initialized[CONFIG_SYS_I2C_BUS_MAX];
static unsigned int current_bus = 0;
#endif

static struct i2c_regs *i2c_regs_p =
    (struct i2c_regs *)CONFIG_SYS_I2C_BASE;

/*
 * set_speed - Set the i2c speed mode (standard, high, fast)
 * @i2c_spd:	required i2c speed mode
 *
 * Set the i2c speed mode (standard, high, fast)
 */
static void set_speed(int i2c_spd)
{
	unsigned int cntl;
	unsigned int hcnt, lcnt;
	unsigned int enbl;

	/* to set speed cltr must be disabled */
	enbl = readl(&i2c_regs_p->ic_enable);
	enbl &= ~IC_ENABLE_0B;
	writel(enbl, &i2c_regs_p->ic_enable);

	cntl = (readl(&i2c_regs_p->ic_con) & (~IC_CON_SPD_MSK));

	switch (i2c_spd) {
	case IC_SPEED_MODE_MAX:
		cntl |= IC_CON_SPD_HS;
		hcnt = (IC_CLK * MIN_HS_SCL_HIGHTIME) / NANO_TO_MICRO;
		writel(hcnt, &i2c_regs_p->ic_hs_scl_hcnt);
		lcnt = (IC_CLK * MIN_HS_SCL_LOWTIME) / NANO_TO_MICRO;
		writel(lcnt, &i2c_regs_p->ic_hs_scl_lcnt);
		break;

	case IC_SPEED_MODE_STANDARD:
		cntl |= IC_CON_SPD_SS;
		hcnt = (IC_CLK * MIN_SS_SCL_HIGHTIME) / NANO_TO_MICRO;
		writel(hcnt, &i2c_regs_p->ic_ss_scl_hcnt);
		lcnt = (IC_CLK * MIN_SS_SCL_LOWTIME) / NANO_TO_MICRO;
		writel(lcnt, &i2c_regs_p->ic_ss_scl_lcnt);
		break;

	case IC_SPEED_MODE_FAST:
	default:
		cntl |= IC_CON_SPD_FS;
		hcnt = (IC_CLK * MIN_FS_SCL_HIGHTIME) / NANO_TO_MICRO;
		writel(hcnt, &i2c_regs_p->ic_fs_scl_hcnt);
		lcnt = (IC_CLK * MIN_FS_SCL_LOWTIME) / NANO_TO_MICRO;
		writel(lcnt, &i2c_regs_p->ic_fs_scl_lcnt);
		break;
	}

	writel(cntl, &i2c_regs_p->ic_con);

	/* Enable back i2c now speed set */
	enbl |= IC_ENABLE_0B;
	writel(enbl, &i2c_regs_p->ic_enable);
}

/*
 * i2c_set_bus_speed - Set the i2c speed
 * @speed:	required i2c speed
 *
 * Set the i2c speed.
 */
int i2c_set_bus_speed(int speed)
{
	if (speed >= I2C_MAX_SPEED)
		set_speed(IC_SPEED_MODE_MAX);
	else if (speed >= I2C_FAST_SPEED)
		set_speed(IC_SPEED_MODE_FAST);
	else
		set_speed(IC_SPEED_MODE_STANDARD);

	return 0;
}

/*
 * i2c_get_bus_speed - Gets the i2c speed
 *
 * Gets the i2c speed.
 */
int i2c_get_bus_speed(void)
{
	u32 cntl;

	cntl = (readl(&i2c_regs_p->ic_con) & IC_CON_SPD_MSK);

	if (cntl == IC_CON_SPD_HS)
		return I2C_MAX_SPEED;
	else if (cntl == IC_CON_SPD_FS)
		return I2C_FAST_SPEED;
	else if (cntl == IC_CON_SPD_SS)
		return I2C_STANDARD_SPEED;

	return 0;
}

/*
 * i2c_init - Init function
 * @speed:	required i2c speed
 * @slaveadd:	slave address for the device
 *
 * Initialization function.
 */
void i2c_init(int speed, int slaveadd)
{
	unsigned int enbl;

	/* Disable i2c */
	enbl = readl(&i2c_regs_p->ic_enable);
	enbl &= ~IC_ENABLE_0B;
	writel(enbl, &i2c_regs_p->ic_enable);

	writel((IC_CON_SD | IC_CON_SPD_FS | IC_CON_MM), &i2c_regs_p->ic_con);
	writel(IC_RX_TL, &i2c_regs_p->ic_rx_tl);
	writel(IC_TX_TL, &i2c_regs_p->ic_tx_tl);
	i2c_set_bus_speed(speed);
	writel(IC_STOP_DET, &i2c_regs_p->ic_intr_mask);
	writel(slaveadd, &i2c_regs_p->ic_sar);

	/* Enable i2c */
	enbl = readl(&i2c_regs_p->ic_enable);
	enbl |= IC_ENABLE_0B;
	writel(enbl, &i2c_regs_p->ic_enable);

#ifdef CONFIG_I2C_MULTI_BUS
	bus_initialized[current_bus] = 1;
#endif
}

/*
 * i2c_setaddress - Sets the target slave address
 * @i2c_addr:	target i2c address
 *
 * Sets the target slave address.
 */
static void i2c_setaddress(unsigned int i2c_addr)
{
	writel(i2c_addr, &i2c_regs_p->ic_tar);
}

/*
 * i2c_flush_rxfifo - Flushes the i2c RX FIFO
 *
 * Flushes the i2c RX FIFO
 */
static void i2c_flush_rxfifo(void)
{
	while (readl(&i2c_regs_p->ic_status) & IC_STATUS_RFNE)
		readl(&i2c_regs_p->ic_cmd_data);
}

/*
 * i2c_wait_for_bb - Waits for bus busy
 *
 * Waits for bus busy
 */
static int i2c_wait_for_bb(void)
{
	unsigned long start_time_bb = get_timer(0);

	while ((readl(&i2c_regs_p->ic_status) & IC_STATUS_MA) ||
	       !(readl(&i2c_regs_p->ic_status) & IC_STATUS_TFE)) {

		/* Evaluate timeout */
		if (get_timer(start_time_bb) > (unsigned long)(I2C_BYTE_TO_BB))
			return 1;
	}

	return 0;
}

/* check parameters for i2c_read and i2c_write */
static int check_params(uint addr, int alen, uchar *buffer, int len)
{
	if (buffer == NULL) {
		printf("Buffer is invalid\n");
		return 1;
	}

	if (alen > 1) {
		printf("addr len %d not supported\n", alen);
		return 1;
	}

	if (addr + len > 256) {
		printf("address out of range\n");
		return 1;
	}

	return 0;
}

static int i2c_xfer_init(uchar chip, uint addr)
{
	if (i2c_wait_for_bb())
		return 1;

	i2c_setaddress(chip);
	writel(addr, &i2c_regs_p->ic_cmd_data);

	return 0;
}

static int i2c_xfer_finish(void)
{
	ulong start_stop_det = get_timer(0);

	while (1) {
		if ((readl(&i2c_regs_p->ic_raw_intr_stat) & IC_STOP_DET)) {
			readl(&i2c_regs_p->ic_clr_stop_det);
			break;
		} else if (get_timer(start_stop_det) > I2C_STOPDET_TO) {
			break;
		}
	}

	if (i2c_wait_for_bb()) {
		printf("Timed out waiting for bus\n");
		return 1;
	}

	i2c_flush_rxfifo();

	/* Wait for read/write operation to complete on actual memory */
	udelay(10000);

	return 0;
}

/*
 * i2c_read - Read from i2c memory
 * @chip:	target i2c address
 * @addr:	address to read from
 * @alen:
 * @buffer:	buffer for read data
 * @len:	no of bytes to be read
 *
 * Read from i2c memory.
 */
int i2c_read(uchar chip, uint addr, int alen, uchar *buffer, int len)
{
	unsigned long start_time_rx;

	if (check_params(addr, alen, buffer, len))
		return 1;

	if (i2c_xfer_init(chip, addr))
		return 1;

	start_time_rx = get_timer(0);
	while (len) {
		if (len == 1)
			writel(IC_CMD | IC_STOP, &i2c_regs_p->ic_cmd_data);
		else
			writel(IC_CMD, &i2c_regs_p->ic_cmd_data);

		if (readl(&i2c_regs_p->ic_status) & IC_STATUS_RFNE) {
			*buffer++ = (uchar)readl(&i2c_regs_p->ic_cmd_data);
			len--;
			start_time_rx = get_timer(0);

		} else if (get_timer(start_time_rx) > I2C_BYTE_TO) {
				return 1;
		}
	}

	return i2c_xfer_finish();
}

/*
 * i2c_write - Write to i2c memory
 * @chip:	target i2c address
 * @addr:	address to read from
 * @alen:
 * @buffer:	buffer for read data
 * @len:	no of bytes to be read
 *
 * Write to i2c memory.
 */
int i2c_write(uchar chip, uint addr, int alen, uchar *buffer, int len)
{
	int nb = len;
	unsigned long start_time_tx;

	if (check_params(addr, alen, buffer, len))
		return 1;

	if (i2c_xfer_init(chip, addr))
		return 1;

	start_time_tx = get_timer(0);
	while (len) {
		if (readl(&i2c_regs_p->ic_status) & IC_STATUS_TFNF) {
			if (--len == 0)
				writel(*buffer | IC_STOP, &i2c_regs_p->ic_cmd_data);
			else
				writel(*buffer, &i2c_regs_p->ic_cmd_data);
			buffer++;
			start_time_tx = get_timer(0);

		} else if (get_timer(start_time_tx) > (nb * I2C_BYTE_TO)) {
				printf("Timed out. i2c write Failed\n");
				return 1;
		}
	}

	return i2c_xfer_finish();
}

/*
 * i2c_probe - Probe the i2c chip
 */
int i2c_probe(uchar chip)
{
	u32 tmp;
	int ret;

	/*
	 * Try to read the first location of the chip.
	 */
	ret = i2c_read(chip, 0, 1, (uchar *)&tmp, 1);
	if (ret)
		i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);

	return ret;
}

#ifdef CONFIG_I2C_MULTI_BUS
int i2c_set_bus_num(unsigned int bus)
{
	switch (bus) {
	case 0:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE;
		break;
#ifdef CONFIG_SYS_I2C_BASE1
	case 1:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE1;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE2
	case 2:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE2;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE3
	case 3:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE3;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE4
	case 4:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE4;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE5
	case 5:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE5;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE6
	case 6:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE6;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE7
	case 7:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE7;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE8
	case 8:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE8;
		break;
#endif
#ifdef CONFIG_SYS_I2C_BASE9
	case 9:
		i2c_regs_p = (void *)CONFIG_SYS_I2C_BASE9;
		break;
#endif
	default:
		printf("Bad bus: %d\n", bus);
		return -1;
	}

	current_bus = bus;

	if (!bus_initialized[current_bus])
		i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);

	return 0;
}

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