Subversion Repositories openrisc

/*************************************************************
* I2C functions for the Herveille i2c controller            *
*                                                           *
* Provides functions to read from and write to the I2C bus. *
* Master and slave mode are both supported                  *
*                                                           *
* Julius Baxter, julius@opencores.org                       *
*                                                           *
************************************************************/
 
#include "board.h"
#include "cpu-utils.h"
#include "i2c_master_slave.h"
 
 
// Ensure board.h defines I2C_MASTER_SLAVE_NUM_CORES and 
// I2C_MASTER_SLAVE_BASE_ADDRESSES_CSV which should be the base address values
// separated with commas
#ifdef I2C_MASTER_SLAVE_NUM_CORES
 
const int I2C_MASTER_SLAVE_BASE_ADR[I2C_MASTER_SLAVE_NUM_CORES] = { 
	I2C_MASTER_SLAVE_BASE_ADDRESSES_CSV };
#else
 
const int I2C_MASTER_SLAVE_BASE_ADR[1] = {-1};
 
#endif
 
inline unsigned char i2c_master_slave_read_reg(int core, unsigned char addr)
{
	return REG8((I2C_MASTER_SLAVE_BASE_ADR[core] + addr));
}
 
inline void i2c_master_slave_write_reg(int core, unsigned char addr,
				       unsigned char data)
{
	REG8((I2C_MASTER_SLAVE_BASE_ADR[core] + addr)) = data;
}
 
int i2c_master_slave_wait_for_busy(int core)
{
	while (1) {
		// Check for busy flag in i2c status reg
		if (!
		    (i2c_master_slave_read_reg(core, I2C_MASTER_SLAVE_SR) &
		     I2C_MASTER_SLAVE_SR_BUSY))
			return 0;
	}
}
 
int i2c_master_slave_wait_for_transfer(int core)
{
	volatile unsigned char status;
	// Wait for ongoing transmission to finish
	while (1) {
		status = i2c_master_slave_read_reg(core, I2C_MASTER_SLAVE_SR);
		// If arbitration lost
		if ((status & I2C_MASTER_SLAVE_SR_ARB_LOST) ==
		    I2C_MASTER_SLAVE_SR_ARB_LOST)
			return 2;
		// If TIP bit = o , stop waiting
		else if (!(status & I2C_MASTER_SLAVE_SR_TRANSFER_IN_PRG))
			return 0;
	}
}
 
/***********************************************************
* i2c_master_slave_init_core                               *
*                                                          *
* Setup i2c core:                                          *
* Write prescaler register with parmeter passed, enable    *
* core in control register, optionally enable interrupts   *
************************************************************/
int i2c_master_slave_init_core(int core, unsigned short prescaler,
			       int interrupt_enable)
{
 
	// Setup I2C prescaler,
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_PRERlo,
				   prescaler & 0xff);
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_PRERhi,
				   (prescaler >> 8) & 0xff);
 
	// Enable I2C controller and optionally interrupts
	if (interrupt_enable)
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CTR,
					   I2C_MASTER_SLAVE_CTR_CORE_ENABLE |
					   I2C_MASTER_SLAVE_CTR_INTR_ENABLE);
	else
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CTR,
					   I2C_MASTER_SLAVE_CTR_CORE_ENABLE);
 
	return 0;
 
}
 
/***********************************************************
* i2c_master_slave_deact_core                              *
*                                                          *
* Deactivate i2c core:                                     *
* Clear core enable and interrupt enable bits              *
************************************************************/
int i2c_master_slave_deact_core(int core)
{
 
 
  i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CTR,
			     i2c_master_slave_read_reg(core,
						       I2C_MASTER_SLAVE_CTR) & 
			     ~(I2C_MASTER_SLAVE_CTR_CORE_ENABLE |
			       I2C_MASTER_SLAVE_CTR_INTR_ENABLE));
 
 
	return 0;
 
}
 
/***********************************************************
* i2c_master_slave_init_as_slave                           *
*                                                          *
* Setup i2c core to service slave accesses                 *
* OR in slave enable bit to control register               *
* Set slave address                                        *
************************************************************/
int i2c_master_slave_init_as_slave(int core, char addr)
{
 
	// Set slave enable bit
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CTR,
				   i2c_master_slave_read_reg(core,
							     I2C_MASTER_SLAVE_CTR)
				   | I2C_MASTER_SLAVE_CTR_SLAVE_ENABLE);
	// Set slave address
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_SLADR, addr);
 
	return 0;
 
}
 
/***********************************************************
* i2c_master_slave_deact_as_slave                          *
*                                                          *
* Disable slave mode for this I2C core                     *
* Deassert slave eanble bit in control register            *
************************************************************/
int i2c_master_slave_deact_as_slave(int core)
{
	// Clear slave enable bit
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CTR,
				   i2c_master_slave_read_reg(core,
							     I2C_MASTER_SLAVE_CTR)
				   & ~I2C_MASTER_SLAVE_CTR_SLAVE_ENABLE);
 
	return 0;
}
 
/***********************************************************
* i2c_master_slave_master_start                            *
*                                                          *
* Get the i2c bus.                                         *
************************************************************/
int i2c_master_slave_master_start(int core, unsigned char addr, int read)
{
 
	i2c_master_slave_wait_for_busy(core);
 
	// Set address in transfer register
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_TXR,
				   (addr << 1) | read);
 
	// Start and write the address
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
				   I2C_MASTER_SLAVE_CR_START |
				   I2C_MASTER_SLAVE_CR_WRITE);
 
	i2c_master_slave_wait_for_transfer(core);
 
	return 0;
}
 
/***********************************************************
* i2c_master_slave_master_write                            *
*                                                          *
* Send 1 byte of data					   *
************************************************************/
int i2c_master_slave_master_write(int core, unsigned char data,
				  int check_prev_ack, int stop)
{	
	if (i2c_master_slave_wait_for_transfer(core))
		return 1;
 
	// present data
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_TXR, data);
 
	if (!stop)
		// set command (write)
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
					   I2C_MASTER_SLAVE_CR_WRITE);
	else
		// set command (write) and stop
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
					   I2C_MASTER_SLAVE_CR_WRITE |
					   I2C_MASTER_SLAVE_CR_STOP);
 
	return i2c_master_slave_wait_for_transfer(core);
 
}
 
/***********************************************************
* i2c_master_slave_master_stop                             *
*                                                          *
* Send stop condition					   *
************************************************************/
int i2c_master_slave_master_stop(int core)
{
	unsigned char status;
	unsigned char ready = 0;
 
	// Make I2C controller wait at end of finished byte
	if (i2c_master_slave_wait_for_transfer(core))
		return 1;
 
	// Send stop condition
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
				   I2C_MASTER_SLAVE_CR_STOP);
 
	return 0;
}
 
/***********************************************************
* i2c_master_slave_master_read                             *
*                                                          *
* Read 1 byte of data    				   *
************************************************************/
int i2c_master_slave_master_read(int core, int check_prev_ack,
				 int stop, char *data)
{
 
	// Make I2C controller wait at end of finished byte
	if (i2c_master_slave_wait_for_transfer(core))
		return 1;
 
	if (stop)
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
					   I2C_MASTER_SLAVE_CR_READ |
					   // Final read, so send a NAK to slave
					   I2C_MASTER_SLAVE_CR_ACK |
					   I2C_MASTER_SLAVE_CR_STOP);
	else
		i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
					   I2C_MASTER_SLAVE_CR_READ);
 
	if (i2c_master_slave_wait_for_transfer(core))
		return 1;
 
	*data = i2c_master_slave_read_reg(core, I2C_MASTER_SLAVE_RXR);
 
	return i2c_master_slave_wait_for_transfer(core);
}
 
/***********************************************************
* i2c_master_slave_ack_interrupt                           *
*                                                          *
* Acknowledge interrupt has been serviced		   *
************************************************************/
int i2c_master_slave_ack_interrupt(int core)
{
 
	i2c_master_slave_write_reg(core, I2C_MASTER_SLAVE_CR,
				   I2C_MASTER_SLAVE_CR_IACK);
 
	return 0;
}