// SPDX-License-Identifier: GPL-2.0
|
/*
|
* Copyright (c) 2007 by Silicon Motion, Inc. (SMI)
|
*
|
* swi2c.c --- SM750/SM718 DDK
|
* This file contains the source code for I2C using software
|
* implementation.
|
*/
|
|
#include "ddk750_chip.h"
|
#include "ddk750_reg.h"
|
#include "ddk750_swi2c.h"
|
#include "ddk750_power.h"
|
|
/*
|
* I2C Software Master Driver:
|
* ===========================
|
* Each i2c cycle is split into 4 sections. Each of these section marks
|
* a point in time where the SCL or SDA may be changed.
|
*
|
* 1 Cycle == | Section I. | Section 2. | Section 3. | Section 4. |
|
* +-------------+-------------+-------------+-------------+
|
* | SCL set LOW |SCL no change| SCL set HIGH|SCL no change|
|
*
|
* ____________ _____________
|
* SCL == XXXX _____________ ____________ /
|
*
|
* I.e. the SCL may only be changed in section 1. and section 3. while
|
* the SDA may only be changed in section 2. and section 4. The table
|
* below gives the changes for these 2 lines in the varios sections.
|
*
|
* Section changes Table:
|
* ======================
|
* blank = no change, L = set bit LOW, H = set bit HIGH
|
*
|
* | 1.| 2.| 3.| 4.|
|
* ---------------+---+---+---+---+
|
* Tx Start SDA | | H | | L |
|
* SCL | L | | H | |
|
* ---------------+---+---+---+---+
|
* Tx Stop SDA | | L | | H |
|
* SCL | L | | H | |
|
* ---------------+---+---+---+---+
|
* Tx bit H SDA | | H | | |
|
* SCL | L | | H | |
|
* ---------------+---+---+---+---+
|
* Tx bit L SDA | | L | | |
|
* SCL | L | | H | |
|
* ---------------+---+---+---+---+
|
*
|
*/
|
|
/* GPIO pins used for this I2C. It ranges from 0 to 63. */
|
static unsigned char sw_i2c_clk_gpio = DEFAULT_I2C_SCL;
|
static unsigned char sw_i2c_data_gpio = DEFAULT_I2C_SDA;
|
|
/*
|
* Below is the variable declaration for the GPIO pin register usage
|
* for the i2c Clock and i2c Data.
|
*
|
* Note:
|
* Notice that the GPIO usage for the i2c clock and i2c Data are
|
* separated. This is to make this code flexible enough when
|
* two separate GPIO pins for the clock and data are located
|
* in two different GPIO register set (worst case).
|
*/
|
|
/* i2c Clock GPIO Register usage */
|
static unsigned long sw_i2c_clk_gpio_mux_reg = GPIO_MUX;
|
static unsigned long sw_i2c_clk_gpio_data_reg = GPIO_DATA;
|
static unsigned long sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION;
|
|
/* i2c Data GPIO Register usage */
|
static unsigned long sw_i2c_data_gpio_mux_reg = GPIO_MUX;
|
static unsigned long sw_i2c_data_gpio_data_reg = GPIO_DATA;
|
static unsigned long sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION;
|
|
/*
|
* This function puts a delay between command
|
*/
|
static void sw_i2c_wait(void)
|
{
|
/* find a bug:
|
* peekIO method works well before suspend/resume
|
* but after suspend, peekIO(0x3ce,0x61) & 0x10
|
* always be non-zero,which makes the while loop
|
* never finish.
|
* use non-ultimate for loop below is safe
|
*/
|
|
/* Change wait algorithm to use PCI bus clock,
|
* it's more reliable than counter loop ..
|
* write 0x61 to 0x3ce and read from 0x3cf
|
*/
|
int i, tmp;
|
|
for (i = 0; i < 600; i++) {
|
tmp = i;
|
tmp += i;
|
}
|
}
|
|
/*
|
* This function set/reset the SCL GPIO pin
|
*
|
* Parameters:
|
* value - Bit value to set to the SCL or SDA (0 = low, 1 = high)
|
*
|
* Notes:
|
* When setting SCL to high, just set the GPIO as input where the pull up
|
* resistor will pull the signal up. Do not use software to pull up the
|
* signal because the i2c will fail when other device try to drive the
|
* signal due to SM50x will drive the signal to always high.
|
*/
|
static void sw_i2c_scl(unsigned char value)
|
{
|
unsigned long gpio_data;
|
unsigned long gpio_dir;
|
|
gpio_dir = peek32(sw_i2c_clk_gpio_data_dir_reg);
|
if (value) { /* High */
|
/*
|
* Set direction as input. This will automatically
|
* pull the signal up.
|
*/
|
gpio_dir &= ~(1 << sw_i2c_clk_gpio);
|
poke32(sw_i2c_clk_gpio_data_dir_reg, gpio_dir);
|
} else { /* Low */
|
/* Set the signal down */
|
gpio_data = peek32(sw_i2c_clk_gpio_data_reg);
|
gpio_data &= ~(1 << sw_i2c_clk_gpio);
|
poke32(sw_i2c_clk_gpio_data_reg, gpio_data);
|
|
/* Set direction as output */
|
gpio_dir |= (1 << sw_i2c_clk_gpio);
|
poke32(sw_i2c_clk_gpio_data_dir_reg, gpio_dir);
|
}
|
}
|
|
/*
|
* This function set/reset the SDA GPIO pin
|
*
|
* Parameters:
|
* value - Bit value to set to the SCL or SDA (0 = low, 1 = high)
|
*
|
* Notes:
|
* When setting SCL to high, just set the GPIO as input where the pull up
|
* resistor will pull the signal up. Do not use software to pull up the
|
* signal because the i2c will fail when other device try to drive the
|
* signal due to SM50x will drive the signal to always high.
|
*/
|
static void sw_i2c_sda(unsigned char value)
|
{
|
unsigned long gpio_data;
|
unsigned long gpio_dir;
|
|
gpio_dir = peek32(sw_i2c_data_gpio_data_dir_reg);
|
if (value) { /* High */
|
/*
|
* Set direction as input. This will automatically
|
* pull the signal up.
|
*/
|
gpio_dir &= ~(1 << sw_i2c_data_gpio);
|
poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir);
|
} else { /* Low */
|
/* Set the signal down */
|
gpio_data = peek32(sw_i2c_data_gpio_data_reg);
|
gpio_data &= ~(1 << sw_i2c_data_gpio);
|
poke32(sw_i2c_data_gpio_data_reg, gpio_data);
|
|
/* Set direction as output */
|
gpio_dir |= (1 << sw_i2c_data_gpio);
|
poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir);
|
}
|
}
|
|
/*
|
* This function read the data from the SDA GPIO pin
|
*
|
* Return Value:
|
* The SDA data bit sent by the Slave
|
*/
|
static unsigned char sw_i2c_read_sda(void)
|
{
|
unsigned long gpio_dir;
|
unsigned long gpio_data;
|
unsigned long dir_mask = 1 << sw_i2c_data_gpio;
|
|
/* Make sure that the direction is input (High) */
|
gpio_dir = peek32(sw_i2c_data_gpio_data_dir_reg);
|
if ((gpio_dir & dir_mask) != ~dir_mask) {
|
gpio_dir &= ~(1 << sw_i2c_data_gpio);
|
poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir);
|
}
|
|
/* Now read the SDA line */
|
gpio_data = peek32(sw_i2c_data_gpio_data_reg);
|
if (gpio_data & (1 << sw_i2c_data_gpio))
|
return 1;
|
else
|
return 0;
|
}
|
|
/*
|
* This function sends ACK signal
|
*/
|
static void sw_i2c_ack(void)
|
{
|
return; /* Single byte read is ok without it. */
|
}
|
|
/*
|
* This function sends the start command to the slave device
|
*/
|
static void sw_i2c_start(void)
|
{
|
/* Start I2C */
|
sw_i2c_sda(1);
|
sw_i2c_scl(1);
|
sw_i2c_sda(0);
|
}
|
|
/*
|
* This function sends the stop command to the slave device
|
*/
|
static void sw_i2c_stop(void)
|
{
|
/* Stop the I2C */
|
sw_i2c_scl(1);
|
sw_i2c_sda(0);
|
sw_i2c_sda(1);
|
}
|
|
/*
|
* This function writes one byte to the slave device
|
*
|
* Parameters:
|
* data - Data to be write to the slave device
|
*
|
* Return Value:
|
* 0 - Success
|
* -1 - Fail to write byte
|
*/
|
static long sw_i2c_write_byte(unsigned char data)
|
{
|
unsigned char value = data;
|
int i;
|
|
/* Sending the data bit by bit */
|
for (i = 0; i < 8; i++) {
|
/* Set SCL to low */
|
sw_i2c_scl(0);
|
|
/* Send data bit */
|
if ((value & 0x80) != 0)
|
sw_i2c_sda(1);
|
else
|
sw_i2c_sda(0);
|
|
sw_i2c_wait();
|
|
/* Toggle clk line to one */
|
sw_i2c_scl(1);
|
sw_i2c_wait();
|
|
/* Shift byte to be sent */
|
value = value << 1;
|
}
|
|
/* Set the SCL Low and SDA High (prepare to get input) */
|
sw_i2c_scl(0);
|
sw_i2c_sda(1);
|
|
/* Set the SCL High for ack */
|
sw_i2c_wait();
|
sw_i2c_scl(1);
|
sw_i2c_wait();
|
|
/* Read SDA, until SDA==0 */
|
for (i = 0; i < 0xff; i++) {
|
if (!sw_i2c_read_sda())
|
break;
|
|
sw_i2c_scl(0);
|
sw_i2c_wait();
|
sw_i2c_scl(1);
|
sw_i2c_wait();
|
}
|
|
/* Set the SCL Low and SDA High */
|
sw_i2c_scl(0);
|
sw_i2c_sda(1);
|
|
if (i < 0xff)
|
return 0;
|
else
|
return -1;
|
}
|
|
/*
|
* This function reads one byte from the slave device
|
*
|
* Parameters:
|
* ack - Flag to indicate either to send the acknowledge
|
* message to the slave device or not
|
*
|
* Return Value:
|
* One byte data read from the Slave device
|
*/
|
static unsigned char sw_i2c_read_byte(unsigned char ack)
|
{
|
int i;
|
unsigned char data = 0;
|
|
for (i = 7; i >= 0; i--) {
|
/* Set the SCL to Low and SDA to High (Input) */
|
sw_i2c_scl(0);
|
sw_i2c_sda(1);
|
sw_i2c_wait();
|
|
/* Set the SCL High */
|
sw_i2c_scl(1);
|
sw_i2c_wait();
|
|
/* Read data bits from SDA */
|
data |= (sw_i2c_read_sda() << i);
|
}
|
|
if (ack)
|
sw_i2c_ack();
|
|
/* Set the SCL Low and SDA High */
|
sw_i2c_scl(0);
|
sw_i2c_sda(1);
|
|
return data;
|
}
|
|
/*
|
* This function initializes GPIO port for SW I2C communication.
|
*
|
* Parameters:
|
* clk_gpio - The GPIO pin to be used as i2c SCL
|
* data_gpio - The GPIO pin to be used as i2c SDA
|
*
|
* Return Value:
|
* -1 - Fail to initialize the i2c
|
* 0 - Success
|
*/
|
static long sm750le_i2c_init(unsigned char clk_gpio, unsigned char data_gpio)
|
{
|
int i;
|
|
/* Initialize the GPIO pin for the i2c Clock Register */
|
sw_i2c_clk_gpio_data_reg = GPIO_DATA_SM750LE;
|
sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION_SM750LE;
|
|
/* Initialize the Clock GPIO Offset */
|
sw_i2c_clk_gpio = clk_gpio;
|
|
/* Initialize the GPIO pin for the i2c Data Register */
|
sw_i2c_data_gpio_data_reg = GPIO_DATA_SM750LE;
|
sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION_SM750LE;
|
|
/* Initialize the Data GPIO Offset */
|
sw_i2c_data_gpio = data_gpio;
|
|
/* Note that SM750LE don't have GPIO MUX and power is always on */
|
|
/* Clear the i2c lines. */
|
for (i = 0; i < 9; i++)
|
sw_i2c_stop();
|
|
return 0;
|
}
|
|
/*
|
* This function initializes the i2c attributes and bus
|
*
|
* Parameters:
|
* clk_gpio - The GPIO pin to be used as i2c SCL
|
* data_gpio - The GPIO pin to be used as i2c SDA
|
*
|
* Return Value:
|
* -1 - Fail to initialize the i2c
|
* 0 - Success
|
*/
|
long sm750_sw_i2c_init(unsigned char clk_gpio, unsigned char data_gpio)
|
{
|
int i;
|
|
/*
|
* Return 0 if the GPIO pins to be used is out of range. The
|
* range is only from [0..63]
|
*/
|
if ((clk_gpio > 31) || (data_gpio > 31))
|
return -1;
|
|
if (sm750_get_chip_type() == SM750LE)
|
return sm750le_i2c_init(clk_gpio, data_gpio);
|
|
/* Initialize the GPIO pin for the i2c Clock Register */
|
sw_i2c_clk_gpio_mux_reg = GPIO_MUX;
|
sw_i2c_clk_gpio_data_reg = GPIO_DATA;
|
sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION;
|
|
/* Initialize the Clock GPIO Offset */
|
sw_i2c_clk_gpio = clk_gpio;
|
|
/* Initialize the GPIO pin for the i2c Data Register */
|
sw_i2c_data_gpio_mux_reg = GPIO_MUX;
|
sw_i2c_data_gpio_data_reg = GPIO_DATA;
|
sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION;
|
|
/* Initialize the Data GPIO Offset */
|
sw_i2c_data_gpio = data_gpio;
|
|
/* Enable the GPIO pins for the i2c Clock and Data (GPIO MUX) */
|
poke32(sw_i2c_clk_gpio_mux_reg,
|
peek32(sw_i2c_clk_gpio_mux_reg) & ~(1 << sw_i2c_clk_gpio));
|
poke32(sw_i2c_data_gpio_mux_reg,
|
peek32(sw_i2c_data_gpio_mux_reg) & ~(1 << sw_i2c_data_gpio));
|
|
/* Enable GPIO power */
|
sm750_enable_gpio(1);
|
|
/* Clear the i2c lines. */
|
for (i = 0; i < 9; i++)
|
sw_i2c_stop();
|
|
return 0;
|
}
|
|
/*
|
* This function reads the slave device's register
|
*
|
* Parameters:
|
* addr - i2c Slave device address which register
|
* to be read from
|
* reg - Slave device's register to be read
|
*
|
* Return Value:
|
* Register value
|
*/
|
unsigned char sm750_sw_i2c_read_reg(unsigned char addr, unsigned char reg)
|
{
|
unsigned char data;
|
|
/* Send the Start signal */
|
sw_i2c_start();
|
|
/* Send the device address */
|
sw_i2c_write_byte(addr);
|
|
/* Send the register index */
|
sw_i2c_write_byte(reg);
|
|
/* Get the bus again and get the data from the device read address */
|
sw_i2c_start();
|
sw_i2c_write_byte(addr + 1);
|
data = sw_i2c_read_byte(1);
|
|
/* Stop swI2C and release the bus */
|
sw_i2c_stop();
|
|
return data;
|
}
|
|
/*
|
* This function writes a value to the slave device's register
|
*
|
* Parameters:
|
* addr - i2c Slave device address which register
|
* to be written
|
* reg - Slave device's register to be written
|
* data - Data to be written to the register
|
*
|
* Result:
|
* 0 - Success
|
* -1 - Fail
|
*/
|
long sm750_sw_i2c_write_reg(unsigned char addr,
|
unsigned char reg,
|
unsigned char data)
|
{
|
long ret = 0;
|
|
/* Send the Start signal */
|
sw_i2c_start();
|
|
/* Send the device address and read the data. All should return success
|
* in order for the writing processed to be successful
|
*/
|
if ((sw_i2c_write_byte(addr) != 0) ||
|
(sw_i2c_write_byte(reg) != 0) ||
|
(sw_i2c_write_byte(data) != 0)) {
|
ret = -1;
|
}
|
|
/* Stop i2c and release the bus */
|
sw_i2c_stop();
|
|
return ret;
|
}
|
