/******************************************************************* * * Copyright (c) 2007 by Silicon Motion, Inc. (SMI) * * All rights are reserved. Reproduction or in part is prohibited * without the written consent of the copyright owner. * * swi2c.c --- SM750/SM718 DDK * This file contains the source code for I2C using software * implementation. * *******************************************************************/ #include "ddk750_help.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 * */ #if 0 /* Change wait algorithm to use PCI bus clock, it's more reliable than counter loop .. write 0x61 to 0x3ce and read from 0x3cf */ while (peekIO(0x3ce, 0x61) & 0x10); #else int i, Temp; for (i = 0; i < 600; i++) { Temp = i; Temp += i; } #endif } /* * 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 ulGPIOData; unsigned long ulGPIODirection; ulGPIODirection = PEEK32(sw_i2c_clk_gpio_data_dir_reg); if (value) { /* High */ /* Set direction as input. This will automatically pull the signal up. */ ulGPIODirection &= ~(1 << sw_i2c_clk_gpio); POKE32(sw_i2c_clk_gpio_data_dir_reg, ulGPIODirection); } else { /* Low */ /* Set the signal down */ ulGPIOData = PEEK32(sw_i2c_clk_gpio_data_reg); ulGPIOData &= ~(1 << sw_i2c_clk_gpio); POKE32(sw_i2c_clk_gpio_data_reg, ulGPIOData); /* Set direction as output */ ulGPIODirection |= (1 << sw_i2c_clk_gpio); POKE32(sw_i2c_clk_gpio_data_dir_reg, ulGPIODirection); } } /* * 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 ulGPIOData; unsigned long ulGPIODirection; ulGPIODirection = PEEK32(sw_i2c_data_gpio_data_dir_reg); if (value) { /* High */ /* Set direction as input. This will automatically pull the signal up. */ ulGPIODirection &= ~(1 << sw_i2c_data_gpio); POKE32(sw_i2c_data_gpio_data_dir_reg, ulGPIODirection); } else { /* Low */ /* Set the signal down */ ulGPIOData = PEEK32(sw_i2c_data_gpio_data_reg); ulGPIOData &= ~(1 << sw_i2c_data_gpio); POKE32(sw_i2c_data_gpio_data_reg, ulGPIOData); /* Set direction as output */ ulGPIODirection |= (1 << sw_i2c_data_gpio); POKE32(sw_i2c_data_gpio_data_dir_reg, ulGPIODirection); } } /* * 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 ulGPIODirection; unsigned long ulGPIOData; /* Make sure that the direction is input (High) */ ulGPIODirection = PEEK32(sw_i2c_data_gpio_data_dir_reg); if ((ulGPIODirection & (1 << sw_i2c_data_gpio)) != (~(1 << sw_i2c_data_gpio))) { ulGPIODirection &= ~(1 << sw_i2c_data_gpio); POKE32(sw_i2c_data_gpio_data_dir_reg, ulGPIODirection); } /* Now read the SDA line */ ulGPIOData = PEEK32(sw_i2c_data_gpio_data_reg); if (ulGPIOData & (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: * i2cClkGPIO - The GPIO pin to be used as i2c SCL * i2cDataGPIO - 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 i2cClkGPIO, unsigned char i2cDataGPIO) { 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 = i2cClkGPIO; /* 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 = i2cDataGPIO; /* 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: * i2cClkGPIO - The GPIO pin to be used as i2c SCL * i2cDataGPIO - 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 i2cClkGPIO, unsigned char i2cDataGPIO ) { int i; /* Return 0 if the GPIO pins to be used is out of range. The range is only from [0..63] */ if ((i2cClkGPIO > 31) || (i2cDataGPIO > 31)) return -1; if (getChipType() == SM750LE) return sm750le_i2c_init(i2cClkGPIO, i2cDataGPIO); /* 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 = i2cClkGPIO; /* 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 = i2cDataGPIO; /* 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 */ enableGPIO(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: * deviceAddress - i2c Slave device address which register * to be read from * registerIndex - Slave device's register to be read * * Return Value: * Register value */ unsigned char sm750_sw_i2c_read_reg( unsigned char deviceAddress, unsigned char registerIndex ) { unsigned char data; /* Send the Start signal */ sw_i2c_start(); /* Send the device address */ sw_i2c_write_byte(deviceAddress); /* Send the register index */ sw_i2c_write_byte(registerIndex); /* Get the bus again and get the data from the device read address */ sw_i2c_start(); sw_i2c_write_byte(deviceAddress + 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: * deviceAddress - i2c Slave device address which register * to be written * registerIndex - 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 deviceAddress, unsigned char registerIndex, unsigned char data ) { long returnValue = 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(deviceAddress) != 0) || (sw_i2c_write_byte(registerIndex) != 0) || (sw_i2c_write_byte(data) != 0)) { returnValue = -1; } /* Stop i2c and release the bus */ sw_i2c_stop(); return returnValue; }