541 lines
16 KiB
C
541 lines
16 KiB
C
/*
|
|
* Copyright (c) 2010-2012, Freescale Semiconductor, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* o Redistributions of source code must retain the above copyright notice, this list
|
|
* of conditions and the following disclaimer.
|
|
*
|
|
* o Redistributions in binary form must reproduce the above copyright notice, this
|
|
* list of conditions and the following disclaimer in the documentation and/or
|
|
* other materials provided with the distribution.
|
|
*
|
|
* o Neither the name of Freescale Semiconductor, Inc. nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*!
|
|
* @file imx_i2c.c
|
|
* @brief Main driver for the I2C controller. It initializes the controller
|
|
* and handles the master mode.
|
|
*
|
|
* @ingroup diag_i2c
|
|
*/
|
|
|
|
#include "sdk.h"
|
|
#include "imx_i2c.h"
|
|
#include "imx_i2c_internal.h"
|
|
#include "registers/regsi2c.h"
|
|
#include "ccm_pll.h"
|
|
#include "interrupt.h"
|
|
|
|
//! Set this macro to 1 to enable tracing of data send and receive.
|
|
#define TRACE_I2C 0
|
|
|
|
//! @brief Get the irq id of I2C by instance number.
|
|
//! @param x I2C instance number, from 1 through 3.
|
|
#define I2C_IRQS(x) ( (x) == HW_I2C1 ? IMX_INT_I2C1 : (x) == HW_I2C2 ? IMX_INT_I2C2 : (x) == HW_I2C3 ? IMX_INT_I2C3 : 0xFFFFFFFF)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Constants
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static const uint16_t i2c_freq_div[50][2] = {
|
|
{ 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 },
|
|
{ 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 },
|
|
{ 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 },
|
|
{ 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B },
|
|
{ 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A },
|
|
{ 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 },
|
|
{ 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 },
|
|
{ 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 },
|
|
{ 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 },
|
|
{ 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B },
|
|
{ 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E },
|
|
{ 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
|
|
{ 3072, 0x1E }, { 3840, 0x1F }
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Prototypes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static inline int is_bus_free(unsigned int instance);
|
|
static int wait_till_busy(uint32_t instance);
|
|
static inline void imx_send_stop(unsigned int instance);
|
|
static int wait_op_done(uint32_t instance, int is_tx);
|
|
static int tx_byte(uint8_t * data, uint32_t instance);
|
|
static int rx_bytes(uint8_t * data, uint32_t instance, int sz);
|
|
static void set_i2c_clock(uint32_t instance, uint32_t baud);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Code
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
unsigned i2c_get_request_instance(const imx_i2c_request_t * rq)
|
|
{
|
|
// First see if there device info is set.
|
|
if (rq->device)
|
|
{
|
|
// Use the instance number in the device info.
|
|
return rq->device->port;
|
|
}
|
|
|
|
// Check if the ctl_addr is within the range of instances.
|
|
if (rq->ctl_addr >= 1 && rq->ctl_addr <= HW_I2C_INSTANCE_COUNT)
|
|
{
|
|
// Valid instance number, so use it directly.
|
|
return rq->ctl_addr;
|
|
}
|
|
else
|
|
{
|
|
// Not a valid instance, so treat it as a base address.
|
|
return REGS_I2C_INSTANCE(rq->ctl_addr);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Loop status register for IBB to go 0.
|
|
*
|
|
* The loop also breaks on max number of iterations.
|
|
*
|
|
* @param instance Instance number of the I2C module.
|
|
*
|
|
* @return 0 if successful; -1 otherwise
|
|
*/
|
|
static inline int is_bus_free(unsigned int instance)
|
|
{
|
|
int i = WAIT_RXAK_LOOPS;
|
|
|
|
while (HW_I2C_I2SR(instance).B.IBB && (--i > 0));
|
|
|
|
if (i <= 0) {
|
|
debug_printf("Error: I2C Bus not free!\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* @brief Loop status register for IBB to go 1.
|
|
*
|
|
* It breaks the loop if there's an arbitration lost occurred or the maximum
|
|
* number of iterations has been reached.
|
|
*
|
|
* @param instance Instance number of the I2C module.
|
|
*
|
|
* @return 0 if successful; -1 otherwise
|
|
*/
|
|
static int wait_till_busy(uint32_t instance)
|
|
{
|
|
int i = WAIT_BUSY_LOOPS;
|
|
|
|
while (!HW_I2C_I2SR(instance).B.IBB && (--i > 0)) {
|
|
if (HW_I2C_I2SR(instance).B.IAL) {
|
|
debug_printf("Error: arbitration lost!\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (i <= 0) {
|
|
debug_printf("I2C Error: timeout in %s; %d\n", __FUNCTION__, __LINE__);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* Generates a STOP signal, called by rx and tx routines
|
|
*
|
|
* @param instance Instance number of the I2C module.
|
|
*
|
|
* @return none
|
|
*/
|
|
static inline void imx_send_stop(unsigned int instance)
|
|
{
|
|
HW_I2C_I2CR(instance).B.MSTA = 0;
|
|
}
|
|
|
|
/*!
|
|
* @brief Wait for operation done.
|
|
*
|
|
* This function loops until we get an interrupt. On timeout it returns -1.
|
|
* It reports arbitration lost if IAL bit of I2SR register is set
|
|
* Clears the interrupt
|
|
* If operation is transfer byte function will make sure we received an ack
|
|
*
|
|
* @param instance Instance number of the I2C module.
|
|
* @param is_tx Pass 1 for transfering, 0 for receiving
|
|
*
|
|
* @return 0 if successful; negative integer otherwise
|
|
*/
|
|
static int wait_op_done(uint32_t instance, int is_tx)
|
|
{
|
|
hw_i2c_i2sr_t v;
|
|
int i = WAIT_RXAK_LOOPS;
|
|
|
|
// Loop until we get an interrupt
|
|
do {
|
|
v.U = HW_I2C_I2SR_RD(instance);
|
|
} while (!v.B.IIF && (--i > 0));
|
|
|
|
// If timeout error occurred return error
|
|
if (i <= 0) {
|
|
debug_printf("I2C Error: timeout unexpected\n");
|
|
return -1;
|
|
}
|
|
|
|
// Clear the interrupts
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
|
|
// Check for arbitration lost
|
|
if (v.B.IAL) {
|
|
debug_printf("Error %d: Arbitration lost\n", __LINE__);
|
|
return ERR_ARB_LOST;
|
|
}
|
|
|
|
// Check for ACK received in transmit mode
|
|
if (is_tx) {
|
|
if (v.B.RXAK) {
|
|
// No ACK received, generate STOP by clearing MSTA bit
|
|
debug_printf("Error %d: no ack received\n", __LINE__);
|
|
|
|
// Generate a STOP signal
|
|
imx_send_stop(instance);
|
|
return ERR_NO_ACK;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* @brief Implements a loop to send a byte to I2C slave.
|
|
*
|
|
* For master transmit. Always expect a RXAK signal to be set!
|
|
*
|
|
* @param data return buffer for data
|
|
* @param instance Instance number of the I2C module.
|
|
*
|
|
* @return 0 if successful; -1 otherwise
|
|
*/
|
|
static int tx_byte(uint8_t * data, uint32_t instance)
|
|
{
|
|
#if TRACE_I2C
|
|
debug_printf("%s(data=0x%02x, instance=%d)\n", __FUNCTION__, *data, instance);
|
|
#endif // TRACE_I2C
|
|
|
|
// clear both IAL and IIF bits
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
|
|
// write to data register
|
|
HW_I2C_I2DR_WR(instance, *data);
|
|
|
|
// wait for transfer of byte to complete
|
|
return wait_op_done(instance, 1);
|
|
}
|
|
|
|
/*!
|
|
* @brief Implements a loop to receive bytes from I2C slave.
|
|
*
|
|
* For master receive.
|
|
*
|
|
* @param data return buffer for data
|
|
* @param instance Instance number of the I2C module.
|
|
* @param sz number of bytes to receive
|
|
*
|
|
* @return 0 if successful; -1 otherwise
|
|
*/
|
|
static int rx_bytes(uint8_t * data, uint32_t instance, int sz)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; sz > 0; sz--, i++) {
|
|
if (wait_op_done(instance, 0) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// the next two if-statements setup for the next read control register value
|
|
if (sz == 1) {
|
|
// last byte --> generate STOP
|
|
// generate STOP by clearing MSTA bit
|
|
imx_send_stop(instance);
|
|
}
|
|
|
|
if (sz == 2) {
|
|
// 2nd last byte --> set TXAK bit to NOT generate ACK
|
|
HW_I2C_I2CR(instance).B.TXAK = 1;
|
|
}
|
|
|
|
// read the true data
|
|
data[i] = HW_I2C_I2DR_RD(instance);
|
|
#if TRACE_I2C
|
|
|
|
debug_printf("OK 0x%02x\n", data[i]);
|
|
#endif // TRACE_I2C
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void set_i2c_clock(uint32_t instance, uint32_t baud)
|
|
{
|
|
// Adjust the divider to get the closest SCL frequency to baud rate
|
|
uint32_t src_clk = get_main_clock(IPG_PER_CLK);
|
|
uint32_t divider = src_clk / baud;
|
|
uint8_t index = 0;
|
|
|
|
if (divider < i2c_freq_div[0][0])
|
|
{
|
|
divider = i2c_freq_div[0][0];
|
|
index = 0;
|
|
debug_printf("Warning :can't find a smaller divider than %d.\n", divider);
|
|
debug_printf("SCL frequency is set at %d - expected was %d.\n", src_clk/divider, baud);
|
|
}
|
|
else if (divider > i2c_freq_div[49][0])
|
|
{
|
|
divider = i2c_freq_div[49][0];
|
|
index = 49;
|
|
debug_printf("Warning: can't find a bigger divider than %d.\n", divider);
|
|
debug_printf("SCL frequency is set at %d - expected was %d.\n", src_clk/divider, baud);
|
|
}
|
|
else
|
|
{
|
|
for (index = 0; i2c_freq_div[index][0] < divider; index++);
|
|
divider = i2c_freq_div[index][0];
|
|
}
|
|
|
|
HW_I2C_IFDR_WR(instance, BF_I2C_IFDR_IC(i2c_freq_div[index][1]));
|
|
}
|
|
|
|
int i2c_xfer(const imx_i2c_request_t *rq, int dir)
|
|
{
|
|
uint32_t reg;
|
|
uint32_t ret = 0;
|
|
uint16_t i2cr;
|
|
uint8_t i;
|
|
uint8_t data;
|
|
uint32_t instance = i2c_get_request_instance(rq);
|
|
uint8_t address = (rq->device ? rq->device->address : rq->dev_addr) << 1;
|
|
|
|
if (rq->buffer_sz == 0 || rq->buffer == NULL) {
|
|
debug_printf("Invalid register address size=%x, buffer size=%x, buffer=%x\n",
|
|
rq->reg_addr_sz, rq->buffer_sz, (unsigned int)rq->buffer);
|
|
return ERR_INVALID_REQUEST;
|
|
}
|
|
|
|
// clear the status register
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
|
|
// enable the I2C controller
|
|
HW_I2C_I2CR_WR(instance, BM_I2C_I2CR_IEN);
|
|
|
|
// Check if bus is free, if not return error
|
|
if (is_bus_free(instance) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// If the request has device info attached and it has a non-zero bit rate, then
|
|
// change the clock to the specified rate.
|
|
if (rq->device && rq->device->freq)
|
|
{
|
|
set_i2c_clock(instance, rq->device->freq);
|
|
}
|
|
|
|
// Step 1: Select master mode, assert START signal and also indicate TX mode
|
|
HW_I2C_I2CR_WR(instance, BM_I2C_I2CR_IEN | BM_I2C_I2CR_MSTA | BM_I2C_I2CR_MTX);
|
|
|
|
// make sure bus is busy after the START signal
|
|
if (wait_till_busy(instance) != 0) {
|
|
debug_printf("1\n");
|
|
return -1;
|
|
}
|
|
|
|
// Step 2: send slave address + read/write at the LSB
|
|
data = address | I2C_WRITE;
|
|
|
|
if ((ret = tx_byte(&data, instance)) != 0) {
|
|
debug_printf("START TX ERR %d\n", ret);
|
|
|
|
if (ret == ERR_NO_ACK) {
|
|
return ERR_NO_ACK_ON_START;
|
|
} else {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// Step 3: send I2C device register address
|
|
if (rq->reg_addr_sz > 4) {
|
|
debug_printf("Warning register address size %d should less than 4\n", rq->reg_addr_sz);
|
|
return ERR_INVALID_REQUEST;
|
|
}
|
|
|
|
reg = rq->reg_addr;
|
|
|
|
for (i = 0; i < rq->reg_addr_sz; i++, reg >>= 8) {
|
|
data = reg & 0xFF;
|
|
|
|
#if TRACE_I2C
|
|
debug_printf("sending I2C=%d device register: data=0x%x, byte %d\n", instance, data, i);
|
|
#endif // TRACE_I2C
|
|
|
|
if (tx_byte(&data, instance) != 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Step 4: read/write data
|
|
if (dir == I2C_READ) {
|
|
// do repeat-start
|
|
HW_I2C_I2CR(instance).B.RSTA = 1;
|
|
|
|
// make sure bus is busy after the REPEATED START signal
|
|
if (wait_till_busy(instance) != 0) {
|
|
return ERR_TX;
|
|
}
|
|
|
|
// send slave address again, but indicate read operation
|
|
data = address | I2C_READ;
|
|
|
|
if (tx_byte(&data, instance) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// change to receive mode
|
|
i2cr = HW_I2C_I2CR_RD(instance) & ~BM_I2C_I2CR_MTX;
|
|
|
|
// if only one byte to read, make sure don't send ack
|
|
if (rq->buffer_sz == 1) {
|
|
i2cr |= BM_I2C_I2CR_TXAK;
|
|
}
|
|
HW_I2C_I2CR_WR(instance, i2cr);
|
|
|
|
// dummy read
|
|
data = HW_I2C_I2DR_RD(instance);
|
|
|
|
// now reading ...
|
|
if (rx_bytes(rq->buffer, instance, rq->buffer_sz) != 0) {
|
|
return -1;
|
|
}
|
|
} else {
|
|
// I2C_WRITE
|
|
for (i = 0; i < rq->buffer_sz; i++) {
|
|
// send device register value
|
|
data = rq->buffer[i];
|
|
|
|
if ((ret = tx_byte(&data, instance)) != 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// generate STOP by clearing MSTA bit
|
|
imx_send_stop(instance);
|
|
|
|
// Check if bus is free, if not return error
|
|
if (is_bus_free(instance) != 0) {
|
|
debug_printf("WARNING: bus is not free\n");
|
|
}
|
|
|
|
// disable the controller
|
|
HW_I2C_I2CR_WR(instance, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int i2c_read(const imx_i2c_request_t *rq)
|
|
{
|
|
return i2c_xfer(rq, I2C_READ);
|
|
}
|
|
|
|
int i2c_write(const imx_i2c_request_t *rq)
|
|
{
|
|
return i2c_xfer(rq, I2C_WRITE);
|
|
}
|
|
|
|
void i2c_setup_interrupt(uint32_t instance, void (*irq_subroutine)(void), bool state)
|
|
{
|
|
uint32_t irq_id = I2C_IRQS(instance);
|
|
|
|
if (state) {
|
|
// register the IRQ sub-routine
|
|
register_interrupt_routine(irq_id, irq_subroutine);
|
|
|
|
// enable the IRQ at the ARM core level
|
|
enable_interrupt(irq_id, CPU_0, 0);
|
|
|
|
// clear the status register
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
|
|
// and enable the interrupts in the I2C controller
|
|
HW_I2C_I2CR(instance).B.IIEN = 1;
|
|
} else {
|
|
// disable the IRQ at the ARM core level
|
|
disable_interrupt(irq_id, CPU_0);
|
|
|
|
// and disable the interrupts in the I2C controller
|
|
HW_I2C_I2CR(instance).B.IIEN = 0;
|
|
|
|
// clear the status register
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
}
|
|
}
|
|
|
|
int i2c_init(uint32_t base, uint32_t baud)
|
|
{
|
|
int instance;
|
|
|
|
// Accept either an instance or base address for the base param.
|
|
if (base >= 1 && base <= HW_I2C_INSTANCE_COUNT)
|
|
{
|
|
instance = base;
|
|
}
|
|
else
|
|
{
|
|
instance = REGS_I2C_INSTANCE(base);
|
|
}
|
|
|
|
// enable the source clocks to the I2C port
|
|
clock_gating_config(REGS_I2C_BASE(instance), CLOCK_ON);
|
|
|
|
// Set iomux configuration
|
|
i2c_iomux_config(instance);
|
|
|
|
// reset I2C
|
|
HW_I2C_I2CR_WR(instance, 0);
|
|
|
|
// Set clock.
|
|
set_i2c_clock(instance, baud);
|
|
|
|
// set an I2C slave address
|
|
HW_I2C_IADR_WR(instance, IMX6_DEFAULT_SLAVE_ID);
|
|
|
|
// clear the status register
|
|
HW_I2C_I2SR_WR(instance, 0);
|
|
|
|
// enable the I2C controller
|
|
HW_I2C_I2CR_WR(instance, BM_I2C_I2CR_IEN);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// EOF
|
|
////////////////////////////////////////////////////////////////////////////////
|