git.oblomov.eu Git - linux-2.6/blob - arch/mips/pmc-sierra/yosemite/i2c-yosemite.c

   1 /*
   2  *  Copyright (C) 2003 PMC-Sierra Inc.
   3  *  Author: Manish Lachwani (lachwani@pmc-sierra.com)
   4  *
   5  *  This program is free software; you can redistribute  it and/or modify it
   6  *  under  the terms of  the GNU General  Public License as published by the
   7  *  Free Software Foundation;  either version 2 of the  License, or (at your
   8  *  option) any later version.
   9  *
  10  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
  11  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  12  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  13  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
  14  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  15  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
  16  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  17  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  18  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  19  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  20  *
  21  *  You should have received a copy of the  GNU General Public License along
  22  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  23  *  675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 /*
  27  * Detailed Description:
  28  *
  29  * This block implements the I2C interface to the slave devices like the
  30  * Atmel 24C32 EEPROM and the MAX 1619 Sensors device. The I2C Master interface
  31  * can be controlled by the SCMB block. And the SCMB block kicks in only when
  32  * using the Ethernet Mode of operation and __not__ the SysAD mode
  33  *
  34  * The SCMB controls the two modes: MDIO and the I2C. The MDIO mode is used to
  35  * communicate with the Quad-PHY from Marvel. The I2C is used to communicate
  36  * with the I2C slave devices.  It seems that the driver does not explicitly
  37  * deal with the control of SDA and SCL serial lines. So, the driver will set
  38  * the slave address, drive the command and then the data.  The SCMB will then
  39  * control the two serial lines as required.
  40  *
  41  * It seems the documents are very unclear abt this. Hence, I took some time
  42  * out to write the desciption to have an idea of how the I2C can actually
  43  * work. Currently, this Linux driver wont be integrated into the generic Linux
  44  * I2C framework. And finally, the I2C interface is also known as the 2BI
  45  * interface. 2BI means 2-bit interface referring to SDA and SCL serial lines
  46  * respectively.
  47  *
  48  * - Manish Lachwani (12/09/2003)
  49  */
  50
  51 #include "i2c-yosemite.h"
  52
  53 /*
  54  * Poll the I2C interface for the BUSY bit.
  55  */
  56 static int titan_i2c_poll(void)
  57 {
  58         int i = 0;
  59         unsigned long val = 0;
  60
  61         for (i = 0; i < TITAN_I2C_MAX_POLL; i++) {
  62                 val = TITAN_I2C_READ(TITAN_I2C_COMMAND);
  63
  64                 if (!(val & 0x8000))
  65                         return 0;
  66         }
  67
  68         return TITAN_I2C_ERR_TIMEOUT;
  69 }
  70
  71 /*
  72  * Execute the I2C command
  73  */
  74 int titan_i2c_xfer(unsigned int slave_addr, titan_i2c_command * cmd,
  75                    int size, unsigned int *addr)
  76 {
  77         int loop = 0, bytes, i;
  78         unsigned int *write_data, data, *read_data;
  79         unsigned long reg_val, val;
  80
  81         write_data = cmd->data;
  82         read_data = addr;
  83
  84         TITAN_I2C_WRITE(TITAN_I2C_SLAVE_ADDRESS, slave_addr);
  85
  86         if (cmd->type == TITAN_I2C_CMD_WRITE)
  87                 loop = cmd->write_size;
  88         else
  89                 loop = size;
  90
  91         while (loop > 0) {
  92                 if ((cmd->type == TITAN_I2C_CMD_WRITE) ||
  93                     (cmd->type == TITAN_I2C_CMD_READ_WRITE)) {
  94
  95                         reg_val = TITAN_I2C_DATA;
  96                         for (i = 0; i < TITAN_I2C_MAX_WORDS_PER_RW;
  97                              ++i, write_data += 2, reg_val += 4) {
  98                                 if (bytes < cmd->write_size) {
  99                                         data = write_data[0];
 100                                         ++data;
 101                                 }
 102
 103                                 if (bytes < cmd->write_size) {
 104                                         data = write_data[1];
 105                                         ++data;
 106                                 }
 107
 108                                 TITAN_I2C_WRITE(reg_val, data);
 109                         }
 110                 }
 111
 112                 TITAN_I2C_WRITE(TITAN_I2C_COMMAND,
 113                                 (unsigned int) (cmd->type << 13));
 114                 if (titan_i2c_poll() != TITAN_I2C_ERR_OK)
 115                         return TITAN_I2C_ERR_TIMEOUT;
 116
 117                 if ((cmd->type == TITAN_I2C_CMD_READ) ||
 118                     (cmd->type == TITAN_I2C_CMD_READ_WRITE)) {
 119
 120                         reg_val = TITAN_I2C_DATA;
 121                         for (i = 0; i < TITAN_I2C_MAX_WORDS_PER_RW;
 122                              ++i, read_data += 2, reg_val += 4) {
 123                                 data = TITAN_I2C_READ(reg_val);
 124
 125                                 if (bytes < size) {
 126                                         read_data[0] = data & 0xff;
 127                                         ++bytes;
 128                                 }
 129
 130                                 if (bytes < size) {
 131                                         read_data[1] =
 132                                             ((data >> 8) & 0xff);
 133                                         ++bytes;
 134                                 }
 135                         }
 136                 }
 137
 138                 loop -= (TITAN_I2C_MAX_WORDS_PER_RW * 2);
 139         }
 140
 141         /*
 142          * Read the Interrupt status and then return the appropriate error code
 143          */
 144
 145         val = TITAN_I2C_READ(TITAN_I2C_INTERRUPTS);
 146         if (val & 0x0020)
 147                 return TITAN_I2C_ERR_ARB_LOST;
 148
 149         if (val & 0x0040)
 150                 return TITAN_I2C_ERR_NO_RESP;
 151
 152         if (val & 0x0080)
 153                 return TITAN_I2C_ERR_DATA_COLLISION;
 154
 155         return TITAN_I2C_ERR_OK;
 156 }
 157
 158 /*
 159  * Init the I2C subsystem of the PMC-Sierra Yosemite board
 160  */
 161 int titan_i2c_init(titan_i2c_config * config)
 162 {
 163         unsigned int val;
 164
 165         /*
 166          * Reset the SCMB and program into the I2C mode
 167          */
 168         TITAN_I2C_WRITE(TITAN_I2C_SCMB_CONTROL, 0xA000);
 169         TITAN_I2C_WRITE(TITAN_I2C_SCMB_CONTROL, 0x2000);
 170
 171         /*
 172          * Configure the filtera and clka values
 173          */
 174         val = TITAN_I2C_READ(TITAN_I2C_SCMB_CLOCK_A);
 175         val |= ((val & ~(0xF000)) | ((config->filtera << 12) & 0xF000));
 176         val |= ((val & ~(0x03FF)) | (config->clka & 0x03FF));
 177         TITAN_I2C_WRITE(TITAN_I2C_SCMB_CLOCK_A, val);
 178
 179         /*
 180          * Configure the filterb and clkb values
 181          */
 182         val = TITAN_I2C_READ(TITAN_I2C_SCMB_CLOCK_B);
 183         val |= ((val & ~(0xF000)) | ((config->filterb << 12) & 0xF000));
 184         val |= ((val & ~(0x03FF)) | (config->clkb & 0x03FF));
 185         TITAN_I2C_WRITE(TITAN_I2C_SCMB_CLOCK_B, val);
 186
 187         return TITAN_I2C_ERR_OK;
 188 }