libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/allwinner/libraries/sunxi-hal/hal/source/twi/hal_twi.c

2211 lines
59 KiB
C
Raw Blame History

#include <hal_log.h>
#include <stdlib.h>
#include <hal_clk.h>
#include <hal_reset.h>
#include <hal_gpio.h>
#include <sunxi_hal_twi.h>
#include <hal_dma.h>
#include <hal_cache.h>
#include <sunxi_hal_regulator.h>
#include <interrupt.h>
#ifdef CONFIG_RTTKERNEL
#include <hal_cfg.h>
#include <script.h>
#endif
static const uint32_t hal_twi_address[] =
{
SUNXI_TWI0_PBASE,
SUNXI_TWI1_PBASE,
SUNXI_TWI2_PBASE,
SUNXI_TWI3_PBASE,
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
SUNXI_S_TWI0_PBASE,
#endif
};
static const uint32_t hal_twi_irq_num[] =
{
SUNXI_IRQ_TWI0,
SUNXI_IRQ_TWI1,
SUNXI_IRQ_TWI2,
SUNXI_IRQ_TWI3,
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
SUNXI_IRQ_S_TWI0,
#endif
};
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
static const hal_clk_id_t hal_twi_pclk[] =
{
HAL_CLK_BUS_APB2,
HAL_CLK_BUS_APB2,
HAL_CLK_BUS_APB2,
HAL_CLK_BUS_APB2,
HAL_CLK_BUS_APB2,
};
static const hal_clk_id_t hal_twi_mclk[] =
{
HAL_CLK_PERIPH_TWI0,
HAL_CLK_PERIPH_TWI1,
HAL_CLK_PERIPH_TWI2,
HAL_CLK_PERIPH_TWI3,
HAL_CLK_PERIPH_TWI4,
};
#endif
static const enum REGULATOR_TYPE_ENUM twi_regulator_type = AXP2101_REGULATOR;
static const enum REGULATOR_ID_ENUM twi_regulator_id[] =
{
AXP2101_ID_ALDO2,
AXP2101_ID_ALDO2,
AXP2101_ID_MAX,
AXP2101_ID_MAX,
AXP2101_ID_MAX,
};
static const int twi_vol[] =
{
3300000,
3300000,
-1,
-1,
-1,
};
static hal_twi_t hal_twi[TWI_MASTER_MAX];
/* set twi clock
*
* clk_n: clock divider factor n
* clk_m: clock divider factor m
*/
static void twi_clk_write_reg(hal_twi_t *twi, unsigned int reg_clk,
unsigned int clk_m, unsigned int clk_n,
unsigned int mask_clk_m, unsigned int mask_clk_n)
{
const unsigned long base_addr = twi->base_addr;
unsigned int reg_val = readl(base_addr + reg_clk);
if (reg_clk == TWI_DRIVER_BUSC)
{
reg_val &= ~(mask_clk_m | mask_clk_n);
reg_val |= ((clk_m | (clk_n << 4)) << 8);
writel(reg_val, base_addr + reg_clk);
}
else
{
reg_val &= ~(mask_clk_m | mask_clk_n);
reg_val |= ((clk_m << 3) | clk_n);
writel(reg_val, base_addr + reg_clk);
}
}
/*
* Fin is APB CLOCK INPUT;
* Fsample = F0 = Fin/2^CLK_N;
* F1 = F0/(CLK_M+1);
* Foscl = F1/10 = Fin/(2^CLK_N * (CLK_M+1)*10);
* Foscl is clock SCL;100KHz or 400KHz
*
* clk_in: apb clk clock
* sclk_req: freqence to set in HZ
*/
static int twi_set_clock(hal_twi_t *twi, unsigned int reg_clk,
unsigned int clk_in, unsigned int sclk_req,
unsigned int mask_clk_m, unsigned int mask_clk_n)
{
unsigned int clk_m = 0;
unsigned int clk_n = 0;
unsigned int _2_pow_clk_n = 1;
unsigned int src_clk = clk_in / 10;
unsigned int divider = src_clk / sclk_req; /* 400khz or 100khz */
unsigned int sclk_real = 0; /* the real clock frequency */
if (divider == 0)
{
clk_m = 1;
goto set_clk;
}
/*
* search clk_n and clk_m,from large to small value so
* that can quickly find suitable m & n.
*/
while (clk_n < 8) /* 3bits max value is 8 */
{
/* (m+1)*2^n = divider -->m = divider/2^n -1 */
clk_m = (divider / _2_pow_clk_n) - 1;
/* clk_m = (divider >> (_2_pow_clk_n>>1))-1 */
while (clk_m < 16) /* 4bits max value is 16 */
{
/* src_clk/((m+1)*2^n) */
sclk_real = src_clk / (clk_m + 1) / _2_pow_clk_n;
if (sclk_real <= sclk_req)
{
goto set_clk;
}
else
{
clk_m++;
}
}
clk_n++;
_2_pow_clk_n *= 2; /* mutilple by 2 */
}
set_clk:
twi_clk_write_reg(twi, reg_clk, clk_m, clk_n, mask_clk_m, mask_clk_n);
return 0;
}
/*************************************** TWI ENGINE XFER REG CONTROL begin****************************/
/* clear the interrupt flag */
static inline void twi_clear_irq_flag(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
/* start and stop bit should be 0 */
reg_val |= TWI_CTL_INTFLG;
reg_val &= ~(TWI_CTL_STA | TWI_CTL_STP);
writel(reg_val, base_addr + TWI_CTL_REG);
/* read two more times to make sure that */
/* interrupt flag does really be cleared */
{
unsigned int temp;
temp = readl(base_addr + TWI_CTL_REG);
temp |= readl(base_addr + TWI_CTL_REG);
}
}
/* get data first, then clear flag */
static inline void twi_get_byte(const unsigned long base_addr, unsigned char *buffer)
{
*buffer = (unsigned char)(TWI_DATA_MASK & readl(base_addr + TWI_DATA_REG));
twi_clear_irq_flag(base_addr);
}
/* only get data, we will clear the flag when stop */
static inline void twi_get_last_byte(const unsigned long base_addr, unsigned char *buffer)
{
*buffer = (unsigned char)(TWI_DATA_MASK &
readl(base_addr + TWI_DATA_REG));
}
/* write data and clear irq flag to trigger send flow */
static inline void twi_put_byte(const unsigned long base_addr, const unsigned char *buffer)
{
writel((unsigned int)*buffer, base_addr + TWI_DATA_REG);
twi_clear_irq_flag(base_addr);
}
static inline void twi_enable_irq(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
/*
* 1 when enable irq for next operation, set intflag to 0 to prevent
* to clear it by a mistake (intflag bit is write-1-to-clear bit)
* 2 Similarly, mask START bit and STOP bit to prevent to set it
* twice by a mistake (START bit and STOP bit are self-clear-to-0 bits)
*/
reg_val |= TWI_CTL_INTEN;
reg_val &= ~(TWI_CTL_STA | TWI_CTL_STP | TWI_CTL_INTFLG);
writel(reg_val, base_addr + TWI_CTL_REG);
}
static inline void twi_disable_irq(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val &= ~TWI_CTL_INTEN;
reg_val &= ~(TWI_CTL_STA | TWI_CTL_STP | TWI_CTL_INTFLG);
writel(reg_val, base_addr + TWI_CTL_REG);
}
static inline void twi_disable(const unsigned long base_addr, unsigned int reg, unsigned int mask)
{
unsigned int reg_val = readl(base_addr + reg);
reg_val &= ~mask;
writel(reg_val, base_addr + reg);
TWI_INFO("offset: 0x%x value: 0x%lx", reg, readl(base_addr + reg));
}
static inline void twi_enable(const unsigned long base_addr, unsigned int reg, unsigned int mask)
{
unsigned int reg_val = readl(base_addr + reg);
reg_val |= mask;
writel(reg_val, base_addr + reg);
TWI_INFO("offset: 0x%x value: 0x%lx", reg,
readl(base_addr + reg));
}
/* trigger start signal, the start bit will be cleared automatically */
static inline void twi_set_start(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val |= TWI_CTL_STA;
reg_val &= ~TWI_CTL_INTFLG;
writel(reg_val, base_addr + TWI_CTL_REG);
}
/* get start bit status, poll if start signal is sent */
static inline unsigned int twi_get_start(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val >>= 5;
return reg_val & 1;
}
/* trigger stop signal, the stop bit will be cleared automatically */
static inline void twi_set_stop(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val |= TWI_CTL_STP;
reg_val &= ~TWI_CTL_INTFLG;
writel(reg_val, base_addr + TWI_CTL_REG);
}
/* get stop bit status, poll if stop signal is sent */
static inline unsigned int twi_get_stop(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val >>= 4;
return reg_val & 1;
}
static inline void twi_disable_ack(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val &= ~TWI_CTL_ACK;
reg_val &= ~TWI_CTL_INTFLG;
writel(reg_val, base_addr + TWI_CTL_REG);
}
/* when sending ack or nack, it will send ack automatically */
static inline void twi_enable_ack(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
reg_val |= TWI_CTL_ACK;
reg_val &= ~TWI_CTL_INTFLG;
writel(reg_val, base_addr + TWI_CTL_REG);
}
/* get the interrupt flag */
static inline unsigned int twi_query_irq_flag(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
return (reg_val & TWI_CTL_INTFLG);/* 0x 0000_1000 */
}
/* get interrupt status */
static inline unsigned int twi_query_irq_status(const unsigned long base_addr)
{
unsigned int reg_val = readl(base_addr + TWI_STAT_REG);
return (reg_val & TWI_STAT_MASK);
}
/* Enhanced Feature Register */
static inline void twi_set_efr(const unsigned long base_addr, unsigned int efr)
{
unsigned int reg_val = readl(base_addr + TWI_EFR_REG);
reg_val &= ~TWI_EFR_MASK;
efr &= TWI_EFR_MASK;
reg_val |= efr;
writel(reg_val, base_addr + TWI_EFR_REG);
}
/* function */
static int twi_start(const unsigned long base_addr, int port)
{
unsigned int timeout = 0xff;
twi_set_start(base_addr);
while ((twi_get_start(base_addr) == 1) && (--timeout))
;
if (timeout == 0)
{
TWI_ERR("[twi%d] START can't sendout!", port);
return SUNXI_TWI_FAIL;
}
return SUNXI_TWI_OK;
}
static int twi_restart(const unsigned long base_addr, int port)
{
unsigned int timeout = 0xff;
twi_set_start(base_addr);
twi_clear_irq_flag(base_addr);
while ((twi_get_start(base_addr) == 1) && (--timeout))
;
if (timeout == 0)
{
TWI_ERR("[twi%d] Restart can't sendout!", port);
return SUNXI_TWI_FAIL;
}
return SUNXI_TWI_OK;
}
static int twi_stop(const unsigned long base_addr, int port)
{
unsigned int timeout = 0xff;
twi_set_stop(base_addr);
//unsigned int reg_val = readl(base_addr + TWI_CTL_REG);
twi_clear_irq_flag(base_addr);
twi_get_stop(base_addr);/* it must delay 1 nop to check stop bit */
while ((twi_get_stop(base_addr) == 1) && (--timeout))
;
if (timeout == 0)
{
TWI_ERR("[twi%d] STOP can't sendout!", port);
return SUNXI_TWI_TFAIL;
}
//twi_clear_irq_flag(base_addr);
timeout = 0xff;
while ((readl(base_addr + TWI_STAT_REG) != TWI_STAT_IDLE)
&& (--timeout))
;
if (timeout == 0)
{
TWI_ERR("[twi%d] twi state(0x%0lx) isn't idle(0xf8)",
port, readl(base_addr + TWI_STAT_REG));
return SUNXI_TWI_TFAIL;
}
timeout = 0xff;
while ((readl(base_addr + TWI_LCR_REG) != TWI_LCR_IDLE_STATUS
&& readl(base_addr + TWI_LCR_REG) != TWI_LCR_NORM_STATUS)
&& (--timeout))
;
if (timeout == 0)
{
TWI_ERR("[twi%d] twi lcr(0x%0lx) isn't idle(0x3a)",
port, readl(base_addr + TWI_LCR_REG));
return SUNXI_TWI_TFAIL;
}
//twi_clear_irq_flag(base_addr);
TWI_INFO("twi stop end");
return SUNXI_TWI_OK;
}
/* get SDA state */
static unsigned int twi_get_sda(const unsigned long base_addr)
{
unsigned int status = 0;
status = TWI_LCR_SDA_STATE_MASK & readl(base_addr + TWI_LCR_REG);
status >>= 4;
return (status & 0x1);
}
/* set SCL level(high/low), only when SCL enable */
static void twi_set_scl(const unsigned long base_addr, unsigned int hi_lo)
{
unsigned int reg_val = readl(base_addr + TWI_LCR_REG);
reg_val &= ~TWI_LCR_SCL_CTL;
hi_lo &= 0x01;
reg_val |= (hi_lo << 3);
writel(reg_val, base_addr + TWI_LCR_REG);
}
/* enable SDA or SCL */
static void twi_enable_lcr(const unsigned long base_addr, unsigned int sda_scl)
{
unsigned int reg_val = readl(base_addr + TWI_LCR_REG);
sda_scl &= 0x01;
if (sda_scl)
{
reg_val |= TWI_LCR_SCL_EN; /* enable scl line control */
}
else
{
reg_val |= TWI_LCR_SDA_EN; /* enable sda line control */
}
writel(reg_val, base_addr + TWI_LCR_REG);
}
/* disable SDA or SCL */
static void twi_disable_lcr(const unsigned long base_addr, unsigned int sda_scl)
{
unsigned int reg_val = readl(base_addr + TWI_LCR_REG);
sda_scl &= 0x01;
if (sda_scl)
{
reg_val &= ~TWI_LCR_SCL_EN; /* disable scl line control */
}
else
{
reg_val &= ~TWI_LCR_SDA_EN; /* disable sda line control */
}
writel(reg_val, base_addr + TWI_LCR_REG);
}
/* send 9 clock to release sda */
static int twi_send_clk_9pulse(const unsigned long base_addr, int port)
{
int twi_scl = 1;
int low = 0;
int high = 1;
int cycle = 0;
int num = 0;
unsigned char status;
/* enable scl control */
twi_enable_lcr(base_addr, twi_scl);
while (cycle < 9)
{
if (twi_get_sda(base_addr)
&& twi_get_sda(base_addr)
&& twi_get_sda(base_addr))
{
break;
}
/* twi_scl -> low */
twi_set_scl(base_addr, low);
for (num = 1000; num > 0; num--);
/* twi_scl -> high */
twi_set_scl(base_addr, high);
for (num = 1000; num > 0; num--);
cycle++;
}
if (twi_get_sda(base_addr))
{
twi_disable_lcr(base_addr, twi_scl);
status = SUNXI_TWI_OK;
}
else
{
TWI_ERR("[twi%d] SDA is still Stuck Low, failed.", port);
twi_disable_lcr(base_addr, twi_scl);
status = SUNXI_TWI_FAIL;
}
return status;
}
/*************************************** TWI DRV XFER REG CONTROL begin****************************/
#if 0
/* set twi clock
*
* clk_n: clock divider factor n
* clk_m: clock divider factor m
*/
static void twi_clk_write_reg(const uint32_t base_addr, uint32_t sclk_freq,
uint8_t clk_m, uint8_t clk_n)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_BUSC);
#if defined(CONFIG_ARCH_SUN50IW10)
uint32_t duty;
#endif
TWI_INFO("reg_clk = 0x%x, clk_m = %u, clk_n = %u,"
"mask_clk_m = %x, mask_clk_n = %x",
reg_clk, clk_m, clk_n, mask_clk_m, mask_clk_n);
reg_val &= ~(TWI_DRV_CLK_M | TWI_DRV_CLK_N);
reg_val |= ((clk_m | (clk_n << 4)) << 8);
#if defined(CONFIG_ARCH_SUN50IW10)
duty = TWI_DRV_CLK_DUTY;
if (sclk_freq > STANDDARD_FREQ)
{
reg_val |= duty;
}
else
{
reg_val &= ~duty;
}
#endif
writel(reg_val, base_addr + TWI_DRIVER_BUSC);
}
/*
* Fin is APB CLOCK INPUT;
* Fsample = F0 = Fin/2^CLK_N;
* F1 = F0/(CLK_M+1);
* Foscl = F1/10 = Fin/(2^CLK_N * (CLK_M+1)*10);
* Foscl is clock SCL;100KHz or 400KHz
*
* clk_in: apb clk clock
* sclk_freq: freqence to set in HZ
*/
static int32_t twi_set_clock(twi_port_t twi_port,
uint32_t clk_in, uint32_t sclk_freq)
{
const uint32_t base_addr = g_twi_regbase[twi->port];
uint8_t clk_m = 0, clk_n = 0, _2_pow_clk_n = 1;
uint32_t src_clk = clk_in / 10;
uint32_t divider = src_clk / sclk_freq; /* 400khz or 100khz */
uint32_t sclk_real = 0; /* the real clock frequency */
if (divider == 0)
{
clk_m = 1;
goto set_clk;
}
/*
* search clk_n and clk_m,from large to small value so
* that can quickly find suitable m & n.
*/
while (clk_n < 8) /* 3bits max value is 8 */
{
/* (m+1)*2^n = divider -->m = divider/2^n -1 */
clk_m = (divider / _2_pow_clk_n) - 1;
/* clk_m = (divider >> (_2_pow_clk_n>>1))-1 */
while (clk_m < 16) /* 4bits max value is 16 */
{
/* src_clk/((m+1)*2^n) */
sclk_real = src_clk / (clk_m + 1) / _2_pow_clk_n;
if (sclk_real <= sclk_freq)
{
goto set_clk;
}
else
{
clk_m++;
}
}
clk_n++;
_2_pow_clk_n *= 2; /* mutilple by 2 */
}
set_clk:
twi_clk_write_reg(base_addr, sclk_freq, clk_m, clk_n);
return 0;
}
#endif
static uint32_t twi_drv_query_irq_status(const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_INTC);
return (reg_val & TWI_DRV_STAT_MASK);
}
static void twi_drv_clear_irq_flag(uint32_t pending_bit, const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_INTC);
pending_bit &= TWI_DRV_STAT_MASK;
reg_val |= pending_bit;
writel(reg_val, base_addr + TWI_DRIVER_INTC);
}
static void twi_clear_pending(const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_INTC);
reg_val |= TWI_DRV_STAT_MASK;
writel(reg_val, base_addr + TWI_DRIVER_INTC);
}
/* start TWI transfer */
static void twi_start_xfer(const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_CTRL);
reg_val |= START_TRAN;
writel(reg_val, base_addr + TWI_DRIVER_CTRL);
}
/*
* send DMA RX Req when the data byte number in RECV_FIFO reaches RX_TRIG
* or Read Packet Tansmission completed with RECV_FIFO not empty
*/
static void twi_set_rx_trig_level(uint32_t val, const unsigned long base_addr)
{
uint32_t mask = TRIG_MASK;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_DMAC);
val = (val & mask) << 16;
reg_val &= ~(mask << 16);
reg_val |= val;
writel(reg_val, base_addr + TWI_DRIVER_DMAC);
}
/* bytes be send as slave device reg address */
static void twi_set_packet_addr_byte(uint32_t val, const unsigned long base_addr)
{
uint32_t mask = ADDR_BYTE;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_FMT);
reg_val &= ~mask;
val = (val << 16) & mask;
reg_val |= val;
writel(reg_val, base_addr + TWI_DRIVER_FMT);
}
/* bytes be send/received as data */
static void twi_set_packet_data_byte(uint32_t val, const unsigned long base_addr)
{
uint32_t mask = DATA_BYTE;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_FMT);
reg_val &= ~mask;
val &= mask;
reg_val |= val;
writel(reg_val, base_addr + TWI_DRIVER_FMT);
}
#if 0
/* interval between each packet in 32*Fscl cycles */
static void twi_set_packet_interval(uint32_t val, const uint32_t base_addr)
{
uint32_t mask = INTERVAL_MASK;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_CFG);
reg_val &= ~mask;
val <<= 16;
val &= mask;
reg_val |= val;
writel(reg_val, base_addr + TWI_DRIVER_CFG);
}
#endif
/* FIFO data be transmitted as PACKET_CNT packets in current format */
static void twi_set_packet_cnt(uint32_t val, const unsigned long base_addr)
{
uint32_t mask = PACKET_MASK;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_CFG);
reg_val &= ~mask;
val &= mask;
reg_val |= val;
writel(reg_val, base_addr + TWI_DRIVER_CFG);
}
/* do not send slave_id +W */
static void twi_enable_read_tran_mode(const unsigned long base_addr)
{
uint32_t mask = READ_TRAN;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_CTRL);
reg_val |= mask;
writel(reg_val, base_addr + TWI_DRIVER_CTRL);
}
/* send slave_id + W */
static void twi_disable_read_tran_mode(const unsigned long base_addr)
{
uint32_t mask = READ_TRAN;
uint32_t reg_val = readl(base_addr + TWI_DRIVER_CTRL);
reg_val &= ~mask;
writel(reg_val, base_addr + TWI_DRIVER_CTRL);
}
static inline void twi_soft_reset(const unsigned long base_addr, unsigned int reg, unsigned int mask)
{
unsigned int reg_val = readl(base_addr + reg);
reg_val |= mask;
writel(reg_val, base_addr + reg);
}
static void twi_enable_tran_irq(uint32_t bitmap, const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_INTC);
reg_val |= bitmap;
reg_val &= ~TWI_DRV_STAT_MASK;
writel(reg_val, base_addr + TWI_DRIVER_INTC);
}
static void twi_disable_tran_irq(uint32_t bitmap, const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_INTC);
reg_val &= ~bitmap;
reg_val &= ~TWI_DRV_STAT_MASK;
writel(reg_val, base_addr + TWI_DRIVER_INTC);
}
static void twi_enable_dma_irq(uint32_t bitmap, const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_DMAC);
bitmap &= TWI_DRQEN_MASK;
reg_val |= bitmap;
writel(reg_val, base_addr + TWI_DRIVER_DMAC);
}
static void twi_disable_dma_irq(uint32_t bitmap, const unsigned long base_addr)
{
uint32_t reg_val = readl(base_addr + TWI_DRIVER_DMAC);
bitmap &= TWI_DRQEN_MASK;
reg_val &= ~bitmap;
writel(reg_val, base_addr + TWI_DRIVER_DMAC);
}
static void twi_slave_addr(const unsigned long base_addr, twi_msg_t *msgs)
{
uint32_t val = 0, cmd = 0;
/* read, default value is write */
if (msgs->flags & TWI_M_RD)
{
cmd = SLV_RD_CMD;
}
if (msgs->flags & TWI_M_TEN)
{
/* SLV_ID | CMD | SLV_ID_X */
val = ((0x78 | ((msgs->addr >> 8) & 0x03)) << 9) | cmd
| (msgs->addr & 0xff);
}
else
{
val = ((msgs->addr & 0x7f) << 9) | cmd;
}
writel(val, base_addr + TWI_DRIVER_SLV);
}
/* the number of data in SEND_FIFO */
static int32_t twi_query_txfifo(const unsigned long base_addr)
{
uint32_t reg_val;
reg_val = readl(base_addr + TWI_DRIVER_FIFOC) & SEND_FIFO_CONT;
return reg_val;
}
/* the number of data in RECV_FIFO */
static int32_t twi_query_rxfifo(const unsigned long base_addr)
{
uint32_t reg_val;
reg_val = readl(base_addr + TWI_DRIVER_FIFOC) & RECV_FIFO_CONT;
reg_val >>= 16;
return reg_val;
}
static void twi_clear_txfifo(const unsigned long base_addr)
{
uint32_t reg_val;
reg_val = readl(base_addr + TWI_DRIVER_FIFOC);
reg_val |= SEND_FIFO_CLEAR;
writel(reg_val, base_addr + TWI_DRIVER_FIFOC);
}
static void twi_clear_rxfifo(const unsigned long base_addr)
{
uint32_t reg_val;
reg_val = readl(base_addr + TWI_DRIVER_FIFOC);
reg_val |= RECV_FIFO_CLEAR;
writel(reg_val, base_addr + TWI_DRIVER_FIFOC);
}
static int twi_send_msgs(hal_twi_t *twi, twi_msg_t *msgs)
{
uint16_t i;
uint8_t time = 0xff;
TWI_INFO("twi[%d] msgs->len = %d", twi->port, msgs->len);
for (i = 0; i < msgs->len; i++)
{
while ((twi_query_txfifo(twi->base_addr) >= MAX_FIFO) && time--)
;
if (time)
{
hal_writeb(msgs->buf[i], twi->base_addr + TWI_DRIVER_SENDF);
}
else
{
TWI_ERR("[twi%d] SEND FIFO overflow. timeout", twi->port);
return SUNXI_TWI_FAIL;
}
}
return SUNXI_TWI_OK;
}
static uint32_t twi_recv_msgs(hal_twi_t *twi, twi_msg_t *msgs)
{
uint16_t i;
uint8_t time = 0xff;
TWI_INFO("twi[%d] msgs->len = %d", twi->port, msgs->len);
for (i = 0; i < msgs->len; i++)
{
while (!twi_query_rxfifo(twi->base_addr) && time--)
;
if (time)
{
msgs->buf[i] = hal_readb(twi->base_addr + TWI_DRIVER_RECVF);
}
else
{
return 0;
}
}
return msgs->len;
}
/************************ TWI DRV XFER REG CONTROL end*************************/
static void twi_dma_callback(void *para)
{
hal_twi_t *twi = (hal_twi_t *)para;
int hal_sem_ret;
hal_sem_ret = hal_sem_post(twi->dma_complete);
if (hal_sem_ret != 0)
{
TWI_ERR("[twi%d] twi dma driver xfer timeout (dev addr:0x%x)\n", twi->port, twi->msgs->addr);
return;
}
}
static int twi_dma_xfer(hal_twi_t *twi, char *buf, int len, enum dma_transfer_direction dir)
{
struct sunxi_dma_chan *dma_chan = twi->dma_chan;
struct dma_slave_config slave_config;
int hal_sem_ret;
hal_dcache_clean((unsigned long)buf, len);
hal_dma_callback_install(dma_chan, twi_dma_callback, twi);
if (dir == DMA_MEM_TO_DEV)
{
slave_config.direction = DMA_MEM_TO_DEV;
slave_config.src_addr = (unsigned long)buf;
slave_config.dst_addr = twi->base_addr + TWI_DRIVER_SENDF;
slave_config.slave_id = sunxi_slave_id(DRQDST_TWI0_TX + twi->port, DRQSRC_SDRAM);
}
else
{
slave_config.direction = DMA_DEV_TO_MEM;
slave_config.src_addr = twi->base_addr + TWI_DRIVER_RECVF;
slave_config.dst_addr = (unsigned long)buf;
slave_config.slave_id = sunxi_slave_id(DRQDST_SDRAM, DRQSRC_TWI0_RX + twi->port);
}
slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
slave_config.src_maxburst = DMA_SLAVE_BURST_16;
slave_config.dst_maxburst = DMA_SLAVE_BURST_16;
hal_dma_slave_config(dma_chan, &slave_config);
if (dir == DMA_MEM_TO_DEV)
{
hal_dma_prep_device(dma_chan, slave_config.dst_addr, slave_config.src_addr, len, DMA_MEM_TO_DEV);
}
else
{
hal_dma_prep_device(dma_chan, slave_config.dst_addr, slave_config.src_addr, len, DMA_DEV_TO_MEM);
}
//hal_dma_cyclic_callback_install(dma_chan, twi_dma_callback, twi);
hal_dma_start(dma_chan);
hal_sem_ret = hal_sem_timedwait(twi->dma_complete, twi->timeout * 100);
if (hal_sem_ret != 0)
{
TWI_ERR("[twi%d] twi dma driver xfer timeout (dev addr:0x%x)\n", twi->port, twi->msgs->addr);
return -1;
}
TWI_INFO("[twi%d] twi driver dma xfer success.\n", twi->port);
TWI_ERR("[twi%d] twi driver dma xfer success.\n", twi->port);
return 0;
}
static int twi_write(hal_twi_t *twi, twi_msg_t *msgs)
{
twi->msgs = msgs;
twi_slave_addr(twi->base_addr, msgs);
if (msgs->len == 1)
{
twi_set_packet_addr_byte(0, twi->base_addr);
twi_set_packet_data_byte(msgs->len, twi->base_addr);
}
else
{
twi_set_packet_addr_byte(1, twi->base_addr);
twi_set_packet_data_byte(msgs->len - 1, twi->base_addr);
}
twi_set_packet_cnt(1, twi->base_addr);
twi_clear_pending(twi->base_addr);
twi_enable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT, twi->base_addr);
twi_start_xfer(twi->base_addr);
return twi_send_msgs(twi, msgs);
}
static int32_t twi_dma_write(hal_twi_t *twi, twi_msg_t *msgs)
{
int32_t ret = 0;
const uint32_t base_addr = twi->base_addr;
twi->msgs = msgs;
twi_slave_addr(base_addr, msgs);
twi_set_packet_addr_byte(1, base_addr);
twi_set_packet_data_byte(msgs->len - 1, base_addr);
twi_set_packet_cnt(1, base_addr);
twi_clear_pending(base_addr);
twi_enable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT, base_addr);
twi_enable_dma_irq(DMA_TX, base_addr);
twi_start_xfer(base_addr);
ret = twi_dma_xfer(twi, msgs->buf, msgs->len, DMA_MEM_TO_DEV);
return ret;
}
static int twi_read(hal_twi_t *twi, twi_msg_t *msgs, int32_t num)
{
twi_msg_t *wmsgs = NULL, *rmsgs = NULL;
if (num == 1)
{
wmsgs = NULL;
rmsgs = msgs;
}
else if (num == 2)
{
wmsgs = msgs;
rmsgs = msgs + 1;
}
else
{
TWI_ERR("msg num err");
return -1;
}
TWI_INFO("rmsgs->len : %d", rmsgs->len);
twi->msgs = rmsgs;
twi_slave_addr(twi->base_addr, rmsgs);
twi_set_packet_cnt(1, twi->base_addr);
twi_set_packet_data_byte(rmsgs->len, twi->base_addr);
if (rmsgs->len > MAX_FIFO)
{
twi_set_rx_trig_level(MAX_FIFO, twi->base_addr);
}
else
{
twi_set_rx_trig_level(rmsgs->len, twi->base_addr);
}
if (twi_query_rxfifo(twi->base_addr))
{
twi_clear_rxfifo(twi->base_addr);
}
twi_clear_pending(twi->base_addr);
twi_enable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT, twi->base_addr);
twi_start_xfer(twi->base_addr);
if (wmsgs)
{
return twi_send_msgs(twi, wmsgs);
}
return 0;
}
static int32_t twi_dma_read(hal_twi_t *twi, twi_msg_t *msgs, int32_t num)
{
int32_t ret = 0;
twi_msg_t *wmsgs, *rmsgs;
const uint32_t base_addr = twi->base_addr;
if (num == 1)
{
wmsgs = NULL;
rmsgs = msgs;
}
else if (num == 2)
{
wmsgs = msgs;
rmsgs = msgs + 1;
}
twi->msgs = rmsgs;
twi_slave_addr(base_addr, rmsgs);
twi_set_packet_data_byte(rmsgs->len, base_addr);
twi_set_packet_cnt(1, base_addr);
twi_set_rx_trig_level(MAX_FIFO / 2, base_addr);
if (twi_query_rxfifo(base_addr))
{
twi_clear_rxfifo(base_addr);
}
twi_clear_pending(base_addr);
twi_enable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT, base_addr);
twi_enable_dma_irq(DMA_RX, base_addr);
twi_start_xfer(base_addr);
if (wmsgs)
{
twi_send_msgs(twi, wmsgs);
}
ret = twi_dma_xfer(twi, rmsgs->buf, rmsgs->len, DMA_DEV_TO_MEM);
return ret;
}
/*************************************** TWI DRV XFER REG CONTROL end****************************/
static int hal_twi_drv_complete(hal_twi_t *twi)
{
int hal_sem_ret;
hal_sem_ret = hal_sem_timedwait(twi->hal_sem, twi->timeout * 100);
if (hal_sem_ret < 0)
{
TWI_ERR("[twi%d] twi driver xfer timeout (dev addr:0x%x)", twi->port, twi->msgs->addr);
//dump_reg(twi, 0x200, 0x20);
twi_disable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT
| RX_REQ_INT | TX_REQ_INT, twi->base_addr);
twi_disable_dma_irq(DMA_TX | DMA_RX, twi->base_addr);
return SUNXI_TWI_FAIL;
}
else if (twi->result == RESULT_ERR)
{
TWI_ERR("[twi%d]twi drv xfer incomplete xfer"
"(status: 0x%lx, dev addr: 0x%x)",
twi->port, twi->msgs_idx, twi->msgs->addr);
twi_disable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT
| RX_REQ_INT | TX_REQ_INT, twi->base_addr);
twi_disable_dma_irq(DMA_TX | DMA_RX, twi->base_addr);
return SUNXI_TWI_FAIL;
}
TWI_INFO("twi drv xfer complete");
// twin_lock_irqsave(&twi->lock, flags);
twi->result = RESULT_COMPLETE;
// twin_unlock_irqrestore(&twi->lock, flags);
return SUNXI_TWI_OK;
}
static int hal_twi_engine_complete(hal_twi_t *twi, int code)
{
int ret = SUNXI_TWI_OK;
int hal_sem_ret;
twi->msgs = NULL;
twi->msgs_num = 0;
twi->msgs_ptr = 0;
twi->status = TWI_XFER_IDLE;
/* twi->msgs_idx store the information */
if (code == SUNXI_TWI_FAIL)
{
TWI_ERR("[twi%d] Maybe Logic Error, debug it!", twi->port);
twi->msgs_idx = code;
ret = SUNXI_TWI_FAIL;
twi->result = RESULT_ERR;
}
else if (code != SUNXI_TWI_OK)
{
twi->msgs_idx = code;
ret = SUNXI_TWI_FAIL;
twi->result = RESULT_ERR;
}
hal_sem_ret = hal_sem_post(twi->hal_sem);
if (hal_sem_ret != 0)
{
ret = SUNXI_TWI_FAIL;
TWI_ERR(" evdev give hal_semaphore err");
}
TWI_INFO("code=%d, complete", twi->msgs_idx);
return ret;
}
/*
****************************************************************************
*
* FunctionName: hal_i2c_addr_byte
*
* Description:
* 7bits addr: 7-1bits addr+0 bit r/w
* 10bits addr: 1111_11xx_xxxx_xxxx-->1111_0xx_rw,xxxx_xxxx
* send the 7 bits addr,or the first part of 10 bits addr
* Parameters:
*
*
* Return value:
* ??
* Notes:
*
****************************************************************************
*/
static void hal_twi_addr_byte(hal_twi_t *twi)
{
unsigned char addr = 0;
unsigned char tmp = 0;
if (twi->msgs[twi->msgs_idx].flags & TWI_M_TEN)
{
/* 0111_10xx,ten bits address--9:8bits */
tmp = 0x78 | (((twi->msgs[twi->msgs_idx].addr) >> 8) & 0x03);
addr = tmp << 1; /*1111_0xx0*/
/* how about the second part of ten bits addr? */
/* Answer: deal at twi_core_process() */
}
else
{
addr = (twi->msgs[twi->msgs_idx].addr & 0x7f) << 1;
}/* 7-1bits addr, xxxx_xxx0 */
/* read, default value is write */
if (twi->msgs[twi->msgs_idx].flags & TWI_M_RD)
{
addr |= 1;
}
if (twi->msgs[twi->msgs_idx].flags & TWI_M_TEN)
{
TWI_INFO("[twi%d] first part of 10bits = 0x%x",
twi->port, addr);
}
else
{
TWI_INFO("[twi%d] 7bits+r/w = 0x%x", twi->port, addr);
}
/* send 7bits+r/w or the first part of 10bits */
twi_put_byte(twi->base_addr, &addr);
}
static int hal_twi_core_process(hal_twi_t *twi)
{
const uint32_t base_addr = twi->base_addr;
int ret = SUNXI_TWI_OK;
int err_code = 0;
unsigned char state = 0;
unsigned char tmp = 0;
state = twi_query_irq_status(base_addr);
//twin_lock_irqsave(&twi->lock, flags);
TWI_INFO("[twi%d][slave address = (0x%x), state = (0x%x)]",
twi->port, twi->msgs->addr, state);
if (twi->msgs == NULL)
{
TWI_ERR("[twi%d] twi message is NULL, err_code = 0xfe",
twi->port);
err_code = 0xfe;
goto msg_null;
}
switch (state)
{
case 0xf8:
/* On reset or stop the bus is idle, use only at poll method */
err_code = 0xf8;
goto err_out;
case 0x08: /* A START condition has been transmitted */
case 0x10: /* A repeated start condition has been transmitted */
hal_twi_addr_byte(twi);/* send slave address */
break;
case 0xd8: /* second addr has transmitted, ACK not received! */
case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */
err_code = 0x20;
goto err_out;
case 0x18: /* SLA+W has been transmitted; ACK has been received */
/* if any, send second part of 10 bits addr */
if (twi->msgs[twi->msgs_idx].flags & TWI_M_TEN)
{
/* the remaining 8 bits of address */
tmp = twi->msgs[twi->msgs_idx].addr & 0xff;
twi_put_byte(base_addr, &tmp); /* case 0xd0: */
break;
}
goto send_data;
/* for 7 bit addr, then directly send data byte--case 0xd0: */
case 0xd0: /* second addr has transmitted,ACK received! */
case 0x28: /* Data byte in DATA REG has been transmitted; */
/* ACK has been received */
/* after send register address then START send write data */
send_data:
if (twi->msgs_ptr < twi->msgs[twi->msgs_idx].len)
{
twi_put_byte(base_addr,
&(twi->msgs[twi->msgs_idx].buf[twi->msgs_ptr]));
twi->msgs_ptr++;
break;
}
twi->msgs_idx++; /* the other msg */
twi->msgs_ptr = 0;
if (twi->msgs_idx == twi->msgs_num)
{
err_code = SUNXI_TWI_OK;/* Success,wakeup */
goto ok_out;
}
else if (twi->msgs_idx < twi->msgs_num)
{
/* for restart pattern, read spec, two msgs */
ret = twi_restart(base_addr, twi->port);
if (ret == SUNXI_TWI_FAIL)
{
TWI_ERR("[twi%d] twi restart fail", twi->port);
err_code = SUNXI_TWI_FAIL;
goto err_out;/* START can't sendout */
}
}
else
{
err_code = SUNXI_TWI_FAIL;
goto err_out;
}
break;
case 0x30: /* Data byte in TWIDAT has been transmitted; */
/* NOT ACK has been received */
err_code = 0x30; /*err,wakeup the thread*/
goto err_out;
case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */
err_code = 0x38; /*err,wakeup the thread*/
goto err_out;
case 0x40: /* SLA+R has been transmitted; ACK has been received */
/* with Restart,needn't to send second part of 10 bits addr */
/* refer-"TWI-SPEC v2.1" */
/* enable A_ACK need it(receive data len) more than 1. */
if (twi->msgs[twi->msgs_idx].len > 1)
{
/* send register addr complete,then enable the A_ACK */
/* and get ready for receiving data */
twi_enable_ack(base_addr);
twi_clear_irq_flag(base_addr);/* jump to case 0x50 */
}
else if (twi->msgs[twi->msgs_idx].len == 1)
{
twi_clear_irq_flag(base_addr);/* jump to case 0x58 */
}
break;
case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */
err_code = 0x48; /*err,wakeup the thread*/
goto err_out;
case 0x50: /* Data bytes has been received; ACK has been transmitted */
/* receive first data byte */
if (twi->msgs_ptr < twi->msgs[twi->msgs_idx].len)
{
/* more than 2 bytes, the last byte need not to send ACK */
if ((twi->msgs_ptr + 2) == twi->msgs[twi->msgs_idx].len)
/* last byte no ACK */
{
twi_disable_ack(base_addr);
}
/* get data then clear flag,then next data coming */
twi_get_byte(base_addr,
&twi->msgs[twi->msgs_idx].buf[twi->msgs_ptr]);
twi->msgs_ptr++;
break;
}
/* err process, the last byte should be @case 0x58 */
err_code = SUNXI_TWI_FAIL;/* err, wakeup */
goto err_out;
case 0x58:
/* Data byte has been received; NOT ACK has been transmitted */
/* received the last byte */
if (twi->msgs_ptr == twi->msgs[twi->msgs_idx].len - 1)
{
twi_get_last_byte(base_addr,
&twi->msgs[twi->msgs_idx].buf[twi->msgs_ptr]);
twi->msgs_idx++;
twi->msgs_ptr = 0;
if (twi->msgs_idx == twi->msgs_num)
{
/* succeed,wakeup the thread */
err_code = SUNXI_TWI_OK;
goto ok_out;
}
else if (twi->msgs_idx < twi->msgs_num)
{
/* repeat start */
ret = twi_restart(base_addr, twi->port);
if (ret == SUNXI_TWI_FAIL) /* START fail */
{
TWI_ERR("[twi%d] twi restart fail", twi->port);
err_code = SUNXI_TWI_FAIL;
goto err_out;
}
break;
}
}
else
{
err_code = 0x58;
goto err_out;
}
break;
case 0x00: /* Bus error during master or slave mode due to illegal level condition */
err_code = 0xff;
goto err_out;
default:
err_code = state;
goto err_out;
}
//twin_unlock_irqrestore(&twi->lock, flags);
return ret;
ok_out:
err_out:
if (twi_stop(base_addr, twi->port) == SUNXI_TWI_FAIL)
{
TWI_ERR("[twi%d] STOP failed!", twi->port);
}
msg_null:
ret = hal_twi_engine_complete(twi, err_code);/* wake up */
//twin_unlock_irqrestore(&twi->lock, flags);
return ret;
}
static int hal_twi_drv_core_process(hal_twi_t *twi)
{
int ret = SUNXI_TWI_OK;
uint32_t status, code = 0;
int hal_sem_ret, taskwoken = 0;
// twin_lock_irqsave(&twi->lock, flags);
status = twi_drv_query_irq_status(twi->base_addr);
twi_drv_clear_irq_flag(status, twi->base_addr);
if (status & TRAN_COM_PD)
{
TWI_INFO("twi drv complete");
twi_disable_tran_irq(TRAN_COM_INT, twi->base_addr);
twi->result = RESULT_COMPLETE;
if ((status & RX_REQ_PD) && (twi->msgs->len < DMA_THRESHOLD))
{
twi_recv_msgs(twi, twi->msgs);
}
goto ok_out;
}
if (status & TRAN_ERR_PD)
{
TWI_ERR("twi drv error");
twi_disable_tran_irq(TRAN_ERR_INT, twi->base_addr);
code = readl(twi->base_addr + TWI_DRIVER_CTRL);
code = (code & TWI_DRV_STA) >> 16;
TWI_ERR("err code : %0lx", code);
switch (code)
{
case 0x00:
TWI_ERR("[twi%d] bus error", twi->port);
break;
case 0x01:
TWI_ERR("[twi%d] Timeout when sending 9th SCL clk", twi->port);
break;
case 0x20:
TWI_ERR("[twi%d] Address + Write bit transmitted,"
"ACK not received", twi->port);
break;
case 0x30:
TWI_ERR("[twi%d] Data byte transmitted in master mode,"
"ACK not received", twi->port);
break;
case 0x38:
TWI_ERR("[twi%d] Arbitration lost in address"
"or data byte", twi->port);
break;
case 0x48:
TWI_ERR("[twi%d] Address + Read bit transmitted,"
"ACK not received", twi->port);
break;
case 0x58:
TWI_ERR("[twi%d] Data byte received in master mode,"
"ACK not received", twi->port);
break;
default:
TWI_ERR("[twi%d] unknown error", twi->port);
break;
}
goto err_out;
}
err_out:
twi->msgs_idx = code;
twi->result = RESULT_ERR;
TWI_ERR("packet transmission failed , status : 0x%0lx", code);
ok_out:
//wake up
hal_sem_ret = hal_sem_post(twi->hal_sem);
if (hal_sem_ret != 0)
{
ret = SUNXI_TWI_FAIL;
TWI_ERR(" evdev give hal_semaphore err");
}
return ret;
// twin_unlock_irqrestore(&twi->lock, flags);
}
static irqreturn_t hal_twi_handler(int irq, void *dev)
{
hal_twi_t *twi = (hal_twi_t *)dev;
if (twi->twi_drv_used)
{
hal_twi_drv_core_process(twi);
}
else
{
if (!twi_query_irq_flag(twi->base_addr))
{
TWI_ERR("unknown interrupt!");
return 0;
}
/* disable irq */
twi_disable_irq(twi->base_addr);
/* twi core process */
hal_twi_core_process(twi);
/*
* enable irq only when twi is transferring,
* otherwise disable irq
*/
if (twi->status != TWI_XFER_IDLE)
{
twi_enable_irq(twi->base_addr);
}
}
return 0;
}
/**
* twi_do_xfer - twi driver transmission control
*/
static int hal_twi_drv_do_xfer(hal_twi_t *twi, struct twi_msg *msgs, int num)
{
// uint64_t flags = 0;
int ret = -1;
// twin_lock_irqsave(&twi->lock, flags);
// twi->result = 0;
// twin_unlock_irqrestore(&twi->lock, flags);
twi_clear_pending(twi->base_addr);
twi_disable_tran_irq(TRAN_COM_INT | TRAN_ERR_INT
| RX_REQ_INT | TX_REQ_INT, twi->base_addr);
twi_disable_dma_irq(DMA_TX | DMA_RX, twi->base_addr);
if (twi_query_txfifo(twi->base_addr))
{
twi_clear_txfifo(twi->base_addr);
}
if (num == 1)
{
if (msgs->flags & TWI_M_RD)
{
TWI_INFO("1 msgs read ");
/* 1 msgs read */
twi_enable_read_tran_mode(twi->base_addr);
twi_set_packet_addr_byte(0, twi->base_addr);
if (twi->dma_chan && (msgs->len >= DMA_THRESHOLD))
{
TWI_INFO("twi[%d] master dma read", twi->port);
ret = twi_dma_read(twi, msgs, num);
}
else
{
TWI_INFO("twi[%d] master cpu read", twi->port);
ret = twi_read(twi, msgs, num);
}
}
else
{
/* 1 msgs write */
twi_disable_read_tran_mode(twi->base_addr);
if (twi->dma_chan && (msgs->len >= DMA_THRESHOLD))
{
TWI_INFO("twi[%d] master dma write\n", twi->port);
ret = twi_dma_write(twi, msgs);
}
else
{
TWI_INFO("twi[%d] master cpu write\n", twi->port);
ret = twi_write(twi, msgs);
}
}
}
else if ((num == 2) && ((msgs + 1)->flags & TWI_M_RD))
{
/* 2 msgs read */
TWI_INFO("2 msgs read");
twi_disable_read_tran_mode(twi->base_addr);
twi_set_packet_addr_byte(msgs->len, twi->base_addr);
if (twi->dma_chan && ((msgs + 1)->len >= DMA_THRESHOLD))
{
TWI_INFO("twi[%d] master dma read\n", twi->port);
ret = twi_dma_read(twi, msgs, num);
}
else
{
TWI_INFO("twi[%d] master cpu read\n", twi->port);
ret = twi_read(twi, msgs, num);
}
}
if (ret)
{
return ret;
}
return hal_twi_drv_complete(twi);
}
static int hal_twi_engine_do_xfer(hal_twi_t *twi, twi_msg_t *msgs, int num)
{
int ret;
const uint32_t base_addr = twi->base_addr;
int hal_sem_ret;
twi_soft_reset(base_addr, TWI_SRST_REG, TWI_SRST_SRST);
//udelay(100);
/* test the bus is free,already protect by the hal_semaphore at DEV layer */
while (twi_query_irq_status(base_addr) != TWI_STAT_IDLE &&
twi_query_irq_status(base_addr) != TWI_STAT_BUS_ERR &&
twi_query_irq_status(base_addr) != TWI_STAT_ARBLOST_SLAR_ACK)
{
TWI_ERR("[twi%d] bus is busy, status = %x",
twi->port, twi_query_irq_status(base_addr));
if (twi_send_clk_9pulse(base_addr, twi->port) != SUNXI_TWI_OK)
{
ret = SUNXI_TWI_RETRY;
goto out;
}
else
{
break;
}
}
/* may conflict with xfer_complete */
//twin_lock_irqsave(&twi->lock, flags);
twi->msgs = msgs;
twi->msgs_num = num;
twi->msgs_ptr = 0;
twi->msgs_idx = 0;
twi_enable_irq(base_addr); /* enable irq */
twi_disable_ack(base_addr); /* disabe ACK */
/* set the special function register,default:0. */
twi_set_efr(base_addr, 0);
//twin_unlock_irqrestore(&twi->lock, flags);
/* START signal, needn't clear int flag */
twi->status = TWI_XFER_START;
ret = twi_start(base_addr, twi->port);
if (ret == SUNXI_TWI_FAIL)
{
TWI_ERR("[twi%d] twi start fail", twi->port);
twi_soft_reset(base_addr, TWI_SRST_REG, TWI_SRST_SRST);
twi_disable_irq(base_addr); /* disable irq */
ret = SUNXI_TWI_RETRY;
goto out;
}
twi->status = TWI_XFER_RUNNING;
/* sleep and wait,do the transfer at interrupt handler,timeout = 5*HZ */
hal_sem_ret = hal_sem_timedwait(twi->hal_sem, twi->timeout * 100);
/* return code,if(msgs_idx == num) succeed */
ret = twi->msgs_idx;
if (hal_sem_ret != 0)
{
TWI_ERR("[twi%d] xfer timeout (dev addr:0x%x)",
twi->port, msgs->addr);
//twin_lock_irqsave(&twi->lock, flags);
twi->msgs = NULL;
//twin_unlock_irqrestore(&twi->lock, flags);
ret = SUNXI_TWI_FAIL;
}
else if (ret != num)
{
TWI_ERR("[twi%d] incomplete xfer (status: 0x%x, dev addr: 0x%x)",
twi->port, ret, msgs->addr);
ret = SUNXI_TWI_FAIL;
}
TWI_INFO("hal_twi_engine_do_xfer end");
out:
return ret;
}
twi_status_t hal_twi_xfer(twi_port_t port, twi_msg_t *msgs, int32_t num)
{
hal_twi_t *twi = &hal_twi[port];
int ret;
if ((msgs == NULL) || (num <= 0))
{
TWI_ERR("[twi%d] invalid argument", port);
return TWI_STATUS_INVALID_PARAMETER;
}
if (twi->twi_drv_used)
{
TWI_INFO("[twi%d] twi driver xfer", twi->port);
ret = hal_twi_drv_do_xfer(twi, msgs, num);
if (ret < 0)
{
return TWI_STATUS_ERROR;
}
}
else
{
TWI_INFO("[twi%d] twi engine xfer", twi->port);
ret = hal_twi_engine_do_xfer(twi, msgs, num);
if (ret < 0)
{
return TWI_STATUS_ERROR;
}
}
return ret == num ? TWI_STATUS_OK : TWI_STATUS_ERROR;
}
static twi_status_t hal_twi_sys_pinctrl_init(hal_twi_t *twi)
{
#ifdef CONFIG_RTTKERNEL
user_gpio_set_t gpio_cfg[2] = {0};
int count, i;
char twi_name[16];
int ret = TWI_STATUS_OK;
sprintf(twi_name, "twi%d", twi->port);
count = Hal_Cfg_GetGPIOSecKeyCount(twi_name);
if (!count)
{
TWI_ERR("[twi%d] not support in sys_config\n", twi->port);
return TWI_STATUS_ERROR;
}
Hal_Cfg_GetGPIOSecData(twi_name, gpio_cfg, count);
for (i = 0; i < count; i++) {
twi->pin[i] = (gpio_cfg[i].port - 1) * 32 + gpio_cfg[i].port_num;
twi->pinmux = gpio_cfg[i].mul_sel;
ret = hal_gpio_pinmux_set_function(twi->pin[i], twi->pinmux);
if (ret){
TWI_ERR("[twi%d] PIN%u set function failed! return %d\n",
twi->port, twi->pin[i], ret);
return TWI_STATUS_ERROR;
}
ret = hal_gpio_set_driving_level(twi->pin[i], gpio_cfg[i].drv_level);
if (ret) {
TWI_ERR("[twi%d] PIN%u set driving level failed! return %d\n",
twi->port, gpio_cfg[i].drv_level, ret);
return TWI_STATUS_ERROR;
}
if (gpio_cfg[i].pull)
if (hal_gpio_set_pull(twi->pin[i], gpio_cfg[i].pull))
return TWI_STATUS_ERROR;
}
return TWI_STATUS_OK;
#endif
TWI_ERR("twi[%d] not support sys_config format \n", twi->port);
return TWI_STATUS_ERROR;
}
static twi_status_t hal_twi_pinctrl_init(hal_twi_t *twi)
{
uint8_t i;
switch (twi->port)
{
case TWI_MASTER_0:
twi->pin[0] = TWI0_SCK;
twi->pin[1] = TWI0_SDA;
twi->pinmux = TWI0_PIN_MUXSEL;
break;
case TWI_MASTER_1:
twi->pin[0] = TWI1_SCK;
twi->pin[1] = TWI1_SDA;
twi->pinmux = TWI1_PIN_MUXSEL;
break;
case TWI_MASTER_2:
twi->pin[0] = TWI2_SCK;
twi->pin[1] = TWI2_SDA;
twi->pinmux = TWI2_PIN_MUXSEL;
break;
case TWI_MASTER_3:
twi->pin[0] = TWI3_SCK;
twi->pin[1] = TWI3_SDA;
twi->pinmux = TWI3_PIN_MUXSEL;
break;
case S_TWI_MASTER_0:
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
twi->pin[0] = S_TWI0_SCK;
twi->pin[1] = S_TWI0_SDA;
twi->pinmux = S_TWI0_PIN_MUXSEL;
#endif
break;
}
for (i = 0; i < TWI_PIN_NUM; i++)
{
if (hal_gpio_pinmux_set_function(twi->pin[i], twi->pinmux))
{
TWI_ERR("[twi%d] PIN set function failed!", twi->port);
return TWI_STATUS_ERROR;
}
if (hal_gpio_set_driving_level(twi->pin[i], TWI_DRIVE_STATE))
{
TWI_ERR("[twi%d] PIN set driving failed!", twi->port);
return TWI_STATUS_ERROR;
}
if (hal_gpio_set_pull(twi->pin[i], TWI_PULL_STATE))
{
TWI_ERR("[twi%d] PIN set driving failed!", twi->port);
return TWI_STATUS_ERROR;
}
}
return TWI_STATUS_OK;
}
static twi_status_t hal_twi_pinctrl_exit(hal_twi_t *twi)
{
uint8_t i;
for (i = 0; i < TWI_PIN_NUM; i++)
{
if (hal_gpio_pinmux_set_function(twi->pin[i], TWI_DISABLE_PIN_MUXSEL))
{
TWI_ERR("[twi%d] PIN exit function failed!", twi->port);
return TWI_STATUS_ERROR;
}
}
return TWI_STATUS_OK;
}
static twi_status_t hal_twi_regulator_init(hal_twi_t *twi)
{
enum REGULATOR_TYPE_ENUM regulator_type = twi_regulator_type;
enum REGULATOR_ID_ENUM regulator_id = twi_regulator_id[twi->port];
int tar_vol = twi_vol[twi->port];
int ret;
/*
if (regulator_id == AXP2101_ID_MAX)
{
TWI_INFO("[twi%d] needn't to set regulator", twi->port);
return TWI_STATUS_OK;
}
hal_regulator_get(REGULATOR_GET(regulator_type, regulator_id), &twi->regulator);
ret = hal_regulator_set_voltage(&twi->regulator, tar_vol);
if (ret)
{
TWI_ERR("twi%d set voltage failed", twi->port);
return TWI_STATUS_ERROR;
}
ret = hal_regulator_enable(&twi->regulator);
if (ret)
{
TWI_ERR("twi%d enabled regulator failed", twi->port);
return TWI_STATUS_ERROR;
}
*/
return TWI_STATUS_OK;
}
static twi_status_t hal_twi_regulator_exit(hal_twi_t *twi)
{
int ret;
enum REGULATOR_ID_ENUM regulator_id = twi_regulator_id[twi->port];
if (regulator_id == AXP2101_ID_MAX)
{
TWI_INFO("[twi%d] needn't to exit regulator", twi->port);
return TWI_STATUS_OK;
}
ret = hal_regulator_disable(&twi->regulator);
if (ret)
{
TWI_ERR("twi%d disable regulator failed\n", twi->port);
return TWI_STATUS_ERROR;
}
return TWI_STATUS_OK;
}
static twi_status_t hal_twi_clk_init(hal_twi_t *twi)
{
unsigned long rate;
/*
if (hal_clk_set_parent(twi->mclk, twi->pclk)) {
TWI_ERR("[twi%d] clk set parent failed!",twi->port);
return TWI_STATUS_ERROR;
}
*/
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
rate = hal_clk_get_rate(twi->pclk);
if (hal_clock_enable(twi->mclk))
{
TWI_ERR("[twi%d] clk enable mclk failed!", twi->port);
return TWI_STATUS_ERROR;
}
#else
rate =24000000;
hal_clk_type_t clk_type = HAL_SUNXI_CCU;
hal_clk_id_t twi_clk_id;
hal_clk_t clk;
hal_reset_type_t reset_type = HAL_SUNXI_RESET;
hal_reset_id_t twi_reset_id;
struct reset_control *reset;
switch (twi->port)
{
case 0:
twi_clk_id = SUNXI_CLK_TWI(0);
twi_reset_id = SUNXI_CLK_RST_TWI(0);
break;
case 1:
twi_clk_id = SUNXI_CLK_TWI(1);
twi_reset_id = SUNXI_CLK_RST_TWI(1);
break;
case 2:
twi_clk_id = SUNXI_CLK_TWI(2);
twi_reset_id = SUNXI_CLK_RST_TWI(2);
break;
case 3:
twi_clk_id = SUNXI_CLK_TWI(3);
twi_reset_id = SUNXI_CLK_RST_TWI(3);
break;
default:
TWI_ERR("twi%d is invalid\n", twi->port);
return TWI_STATUS_ERROR;
}
reset = hal_reset_control_get(reset_type, twi_reset_id);
if (!reset)
{
TWI_ERR("twi reset control get error");
return TWI_STATUS_ERROR;
}
hal_reset_control_deassert(reset);
hal_reset_control_put(reset);
clk = hal_clock_get(clk_type, twi_clk_id);
if (!clk)
{
TWI_ERR("twi clock get error ");
return TWI_STATUS_ERROR;
}
hal_clock_enable(clk);
#endif
if (twi->twi_drv_used)
{
twi_set_clock(twi, TWI_DRIVER_BUSC, 24000000, twi->freq,
TWI_DRV_CLK_M, TWI_DRV_CLK_N);
twi_enable(twi->base_addr, TWI_DRIVER_CTRL, TWI_DRV_EN);
}
else
{
twi_set_clock(twi, TWI_CLK_REG, rate, twi->freq,
TWI_CLK_DIV_M, TWI_CLK_DIV_N);
twi_enable(twi->base_addr, TWI_CTL_REG, TWI_CTL_BUSEN);
}
return TWI_STATUS_OK;
}
static void hal_twi_clk_exit(hal_twi_t *twi)
{
/* disable twi bus */
twi_disable(twi->base_addr, TWI_DRIVER_CTRL, TWI_DRV_EN);
//hal_clock_disable(twi->mclk);
}
twi_status_t hal_twi_init(twi_port_t port)
{
int ret;
unsigned long rate;
hal_twi_t *twi = &hal_twi[port];
if (twi->already_init) //if twi has been inited, return ok
{
return TWI_STATUS_OK;
}
twi->port = port;
twi->base_addr = hal_twi_address[twi->port];
twi->irqnum = hal_twi_irq_num[twi->port];
#if !(defined(CONFIG_ARCH_SUN8IW20) || defined(CONFIG_SOC_SUN20IW1))
twi->pclk = hal_twi_pclk[port];
twi->mclk = hal_twi_mclk[port];
#endif
twi->freq = TWI_FREQUENCY_400K;
#if 1
twi->twi_drv_used = ENGINE_XFER;
#else
twi->twi_drv_used = TWI_DRV_XFER;
#endif
twi->status = TWI_XFER_IDLE;
twi->timeout = 5;
twi->flags = 0;
twi->hal_sem = hal_sem_create(0);
if (twi->hal_sem == NULL)
{
TWI_ERR("[twi%d] creating hal semaphore failed.", port);
goto errsem;
}
if (twi->twi_drv_used)
{
twi->dma_complete = hal_sem_create(0);
if (twi->dma_complete == NULL)
{
TWI_ERR("[twi%d] creating dma semaphore failed.\n", port);
goto errsem_dma;
}
}
#if !(defined(CONFIG_ARCH_SUN8IW18P1) || defined(CONFIG_SOC_SUN20IW1))
if (hal_twi_regulator_init(twi))
{
TWI_ERR("[twi%d] regulator init error", port);
goto errregu;
}
#endif
if (hal_twi_clk_init(twi))
{
TWI_ERR("[twi%d] clk init error", port);
goto errclk;
}
if (hal_twi_sys_pinctrl_init(twi)) {
if (hal_twi_pinctrl_init(twi)) {
TWI_ERR("[twi%d] pinctrl init error", port);
goto errpin;
}
}
if (request_irq(twi->irqnum, hal_twi_handler, 0, "twi-ctl", twi) < 0)
{
TWI_ERR("[twi%d] request irq error", twi->port);
goto errirq;
}
enable_irq(twi->irqnum);
if (twi->twi_drv_used)
{
hal_dma_chan_request(&twi->dma_chan);
}
twi->already_init++;
return TWI_STATUS_OK;
errirq:
free_irq(twi->irqnum, twi);
errpin:
hal_twi_pinctrl_exit(twi);
errclk:
hal_twi_clk_exit(twi);
#if !(defined(CONFIG_ARCH_SUN8IW18P1) || defined(CONFIG_SOC_SUN20IW1))
errregu:
hal_twi_regulator_exit(twi);
#endif
errsem_dma:
if (twi->twi_drv_used)
{
hal_sem_delete(twi->dma_complete);
}
errsem:
hal_sem_delete(twi->hal_sem);
return TWI_STATUS_ERROR;
}
twi_status_t hal_twi_uninit(twi_port_t port)
{
hal_twi_t *twi = &hal_twi[port];
if (twi->already_init > 0)
{
twi->already_init--;
if (twi->already_init == 0)
{
disable_irq(twi->irqnum);
free_irq(twi->irqnum, twi);
hal_twi_pinctrl_exit(twi);
if (twi->twi_drv_used)
{
hal_dma_chan_free(twi->dma_chan);
}
hal_twi_clk_exit(twi);
#if !defined(CONFIG_ARCH_SUN8IW18P1)
hal_twi_regulator_exit(twi);
#endif
hal_sem_delete(twi->hal_sem);
}
}
return TWI_STATUS_OK;
}
twi_status_t hal_twi_write(twi_port_t port, unsigned long pos, const void *buf, uint32_t size)
{
twi_msg_t msg;
uint8_t num = 1, i = 0;
uint8_t *msg_buf;
uint8_t *buf1 = (uint8_t *)buf;
hal_twi_t *twi = &hal_twi[port];
msg_buf = (uint8_t *)malloc(sizeof(uint8_t) * (size + 1));
if (!msg_buf)
{
return TWI_STATUS_ERROR;
}
memset(msg_buf, 0x00, sizeof(uint8_t) * (size + 1));
msg_buf[0] = (int8_t)pos;
for (i = 0; i < size; i++)
{
msg_buf[i + 1] = buf1[i];
}
msg.addr = twi->slave_addr;
msg.flags = twi->flags & TWI_M_TEN;
msg.flags &= ~(TWI_M_RD);
msg.len = (size + 1);
msg.buf = msg_buf;
return hal_twi_xfer(port, &msg, num);
}
twi_status_t hal_twi_read(twi_port_t port, unsigned long pos, void *buf, uint32_t size)
{
twi_msg_t msg[2];
uint8_t num = 2, index = 0;
hal_twi_t *twi = &hal_twi[port];
index = (uint8_t)pos;
msg[0].addr = twi->slave_addr;
msg[0].flags = twi->flags & TWI_M_TEN;
msg[0].flags &= ~(TWI_M_RD);
msg[0].len = 1;
msg[0].buf = &index;
msg[1].addr = twi->slave_addr;
msg[1].flags = twi->flags & TWI_M_TEN;
msg[1].flags |= TWI_M_RD;
msg[1].len = size;
msg[1].buf = buf;
return hal_twi_xfer(port, msg, num);
}
twi_status_t hal_twi_control(twi_port_t port, hal_twi_transfer_cmd_t cmd, void *args)
{
hal_twi_t *twi = &hal_twi[port];
twi_msg_t *msg;
uint16_t *arg;
switch (cmd)
{
case I2C_SLAVE:
case I2C_SLAVE_FORCE:
arg = (uint16_t *)args;
if (*arg > 0x7ff)
{
return TWI_STATUS_INVALID_PARAMETER;
}
else if (twi->status != TWI_XFER_IDLE)
{
return TWI_STATUS_ERROR_BUSY;
}
twi->slave_addr = *arg;
return TWI_STATUS_OK;
case I2C_TENBIT:
arg = (uint16_t *)args;
if (*arg)
{
twi->flags |= TWI_M_TEN;
}
else
{
twi->flags &= ~TWI_M_TEN;
}
return TWI_STATUS_OK;
case I2C_RDWR:
msg = (twi_msg_t *)args;
return hal_twi_xfer(port, msg, 1);
default:
return TWI_STATUS_INVALID_PARAMETER;
}
}
View Git Blame Copy Permalink