i2c: mvtwsi: Factor out adap parameter
[J-u-boot.git] / drivers / i2c / mvtwsi.c
index 9b2ca1e81ba33a7f94e539a020336015b30592fa..688efc2a2391ea5f56618b9b4084c7cdc2ea3eb6 100644 (file)
 #include <asm/io.h>
 
 /*
- * include a file that will provide CONFIG_I2C_MVTWSI_BASE
- * and possibly other settings
+ * Include a file that will provide CONFIG_I2C_MVTWSI_BASE*, and possibly other
+ * settings
  */
 
 #if defined(CONFIG_ORION5X)
 #include <asm/arch/orion5x.h>
-#elif (defined(CONFIG_KIRKWOOD) || defined(CONFIG_ARMADA_XP))
+#elif (defined(CONFIG_KIRKWOOD) || defined(CONFIG_ARCH_MVEBU))
 #include <asm/arch/soc.h>
 #elif defined(CONFIG_SUNXI)
 #include <asm/arch/i2c.h>
@@ -51,8 +51,8 @@ struct  mvtwsi_registers {
        u32 data;
        u32 control;
        union {
-               u32 status;     /* when reading */
-               u32 baudrate;   /* when writing */
+               u32 status;     /* When reading */
+               u32 baudrate;   /* When writing */
        };
        u32 xtnd_slave_addr;
        u32 reserved[2];
@@ -62,62 +62,153 @@ struct  mvtwsi_registers {
 #endif
 
 /*
- * Control register fields
+ * enum mvtwsi_ctrl_register_fields - Bit masks for flags in the control
+ * register
+ */
+enum mvtwsi_ctrl_register_fields {
+       /* Acknowledge bit */
+       MVTWSI_CONTROL_ACK      = 0x00000004,
+       /* Interrupt flag */
+       MVTWSI_CONTROL_IFLG     = 0x00000008,
+       /* Stop bit */
+       MVTWSI_CONTROL_STOP     = 0x00000010,
+       /* Start bit */
+       MVTWSI_CONTROL_START    = 0x00000020,
+       /* I2C enable */
+       MVTWSI_CONTROL_TWSIEN   = 0x00000040,
+       /* Interrupt enable */
+       MVTWSI_CONTROL_INTEN    = 0x00000080,
+};
+
+/*
+ * On sun6i and newer, IFLG is a write-clear bit, which is cleared by writing 1;
+ * on other platforms, it is a normal r/w bit, which is cleared by writing 0.
  */
 
-#define        MVTWSI_CONTROL_ACK      0x00000004
-#define        MVTWSI_CONTROL_IFLG     0x00000008
-#define        MVTWSI_CONTROL_STOP     0x00000010
-#define        MVTWSI_CONTROL_START    0x00000020
-#define        MVTWSI_CONTROL_TWSIEN   0x00000040
-#define        MVTWSI_CONTROL_INTEN    0x00000080
+#ifdef CONFIG_SUNXI_GEN_SUN6I
+#define        MVTWSI_CONTROL_CLEAR_IFLG       0x00000008
+#else
+#define        MVTWSI_CONTROL_CLEAR_IFLG       0x00000000
+#endif
 
 /*
- * Status register values -- only those expected in normal master
- * operation on non-10-bit-address devices; whatever status we don't
- * expect in nominal conditions (bus errors, arbitration losses,
- * missing ACKs...) we just pass back to the caller as an error
+ * enum mvstwsi_status_values - Possible values of I2C controller's status
+ * register
+ *
+ * Only those statuses expected in normal master operation on
+ * non-10-bit-address devices are specified.
+ *
+ * Every status that's unexpected during normal operation (bus errors,
+ * arbitration losses, missing ACKs...) is passed back to the caller as an error
  * code.
  */
+enum mvstwsi_status_values {
+       /* START condition transmitted */
+       MVTWSI_STATUS_START             = 0x08,
+       /* Repeated START condition transmitted */
+       MVTWSI_STATUS_REPEATED_START    = 0x10,
+       /* Address + write bit transmitted, ACK received */
+       MVTWSI_STATUS_ADDR_W_ACK        = 0x18,
+       /* Data transmitted, ACK received */
+       MVTWSI_STATUS_DATA_W_ACK        = 0x28,
+       /* Address + read bit transmitted, ACK received */
+       MVTWSI_STATUS_ADDR_R_ACK        = 0x40,
+       /* Address + read bit transmitted, ACK not received */
+       MVTWSI_STATUS_ADDR_R_NAK        = 0x48,
+       /* Data received, ACK transmitted */
+       MVTWSI_STATUS_DATA_R_ACK        = 0x50,
+       /* Data received, ACK not transmitted */
+       MVTWSI_STATUS_DATA_R_NAK        = 0x58,
+       /* No relevant status */
+       MVTWSI_STATUS_IDLE              = 0xF8,
+};
 
-#define        MVTWSI_STATUS_START             0x08
-#define        MVTWSI_STATUS_REPEATED_START    0x10
-#define        MVTWSI_STATUS_ADDR_W_ACK        0x18
-#define        MVTWSI_STATUS_DATA_W_ACK        0x28
-#define        MVTWSI_STATUS_ADDR_R_ACK        0x40
-#define        MVTWSI_STATUS_ADDR_R_NAK        0x48
-#define        MVTWSI_STATUS_DATA_R_ACK        0x50
-#define        MVTWSI_STATUS_DATA_R_NAK        0x58
-#define        MVTWSI_STATUS_IDLE              0xF8
+/*
+ * enum mvstwsi_ack_flags - Determine whether a read byte should be
+ * acknowledged or not.
+ */
+enum mvtwsi_ack_flags {
+       /* Send NAK after received byte */
+       MVTWSI_READ_NAK = 0,
+       /* Send ACK after received byte */
+       MVTWSI_READ_ACK = 1,
+};
 
 /*
- * The single instance of the controller we'll be dealing with
+ * MVTWSI controller base
  */
 
-static struct  mvtwsi_registers *twsi =
-       (struct  mvtwsi_registers *) CONFIG_I2C_MVTWSI_BASE;
+static struct mvtwsi_registers *twsi_get_base(struct i2c_adapter *adap)
+{
+       switch (adap->hwadapnr) {
+#ifdef CONFIG_I2C_MVTWSI_BASE0
+       case 0:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE0;
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE1
+       case 1:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE1;
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE2
+       case 2:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE2;
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE3
+       case 3:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE3;
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE4
+       case 4:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE4;
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE5
+       case 5:
+               return (struct mvtwsi_registers *)CONFIG_I2C_MVTWSI_BASE5;
+#endif
+       default:
+               printf("Missing mvtwsi controller %d base\n", adap->hwadapnr);
+               break;
+       }
+
+       return NULL;
+}
 
 /*
- * Returned statuses are 0 for success and nonzero otherwise.
- * Currently, cmd_i2c and cmd_eeprom do not interpret an error status.
- * Thus to ease debugging, the return status contains some debug info:
- * - bits 31..24 are error class: 1 is timeout, 2 is 'status mismatch'.
- * - bits 23..16 are the last value of the control register.
- * - bits 15..8 are the last value of the status register.
- * - bits 7..0 are the expected value of the status register.
+ * enum mvtwsi_error_class - types of I2C errors
  */
+enum mvtwsi_error_class {
+       /* The controller returned a different status than expected */
+       MVTWSI_ERROR_WRONG_STATUS       = 0x01,
+       /* The controller timed out */
+       MVTWSI_ERROR_TIMEOUT            = 0x02,
+};
 
-#define MVTWSI_ERROR_WRONG_STATUS      0x01
-#define MVTWSI_ERROR_TIMEOUT           0x02
-
-#define MVTWSI_ERROR(ec, lc, ls, es) (((ec << 24) & 0xFF000000) | \
-       ((lc << 16) & 0x00FF0000) | ((ls<<8) & 0x0000FF00) | (es & 0xFF))
+/*
+ * mvtwsi_error() - Build I2C return code from error information
+ *
+ * For debugging purposes, this function packs some information of an occurred
+ * error into a return code. These error codes are returned from I2C API
+ * functions (i2c_{read,write}, dm_i2c_{read,write}, etc.).
+ *
+ * @ec:                The error class of the error (enum mvtwsi_error_class).
+ * @lc:                The last value of the control register.
+ * @ls:                The last value of the status register.
+ * @es:                The expected value of the status register.
+ * @return The generated error code.
+ */
+inline uint mvtwsi_error(uint ec, uint lc, uint ls, uint es)
+{
+       return ((ec << 24) & 0xFF000000)
+              | ((lc << 16) & 0x00FF0000)
+              | ((ls << 8) & 0x0000FF00)
+              | (es & 0xFF);
+}
 
 /*
- * Wait for IFLG to raise, or return 'timeout'; then if status is as expected,
- * return 0 (ok) or return 'wrong status'.
+ * Wait for IFLG to raise, or return 'timeout.' Then, if the status is as
+ * expected, return 0 (ok) or 'wrong status' otherwise.
  */
-static int twsi_wait(int expected_status)
+static int twsi_wait(struct mvtwsi_registers *twsi, int expected_status)
 {
        int control, status;
        int timeout = 1000;
@@ -129,146 +220,134 @@ static int twsi_wait(int expected_status)
                        if (status == expected_status)
                                return 0;
                        else
-                               return MVTWSI_ERROR(
+                               return mvtwsi_error(
                                        MVTWSI_ERROR_WRONG_STATUS,
                                        control, status, expected_status);
                }
-               udelay(10); /* one clock cycle at 100 kHz */
+               udelay(10); /* One clock cycle at 100 kHz */
        } while (timeout--);
        status = readl(&twsi->status);
-       return MVTWSI_ERROR(
-               MVTWSI_ERROR_TIMEOUT, control, status, expected_status);
+       return mvtwsi_error(MVTWSI_ERROR_TIMEOUT, control, status,
+                           expected_status);
 }
 
-/*
- * These flags are ORed to any write to the control register
- * They allow global setting of TWSIEN and ACK.
- * By default none are set.
- * twsi_start() sets TWSIEN (in case the controller was disabled)
- * twsi_recv() sets ACK or resets it depending on expected status.
- */
-static u8 twsi_control_flags = MVTWSI_CONTROL_TWSIEN;
-
 /*
  * Assert the START condition, either in a single I2C transaction
  * or inside back-to-back ones (repeated starts).
  */
-static int twsi_start(int expected_status)
+static int twsi_start(struct mvtwsi_registers *twsi, int expected_status)
 {
-       /* globally set TWSIEN in case it was not */
-       twsi_control_flags |= MVTWSI_CONTROL_TWSIEN;
-       /* assert START */
-       writel(twsi_control_flags | MVTWSI_CONTROL_START, &twsi->control);
-       /* wait for controller to process START */
-       return twsi_wait(expected_status);
+       /* Assert START */
+       writel(MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_START |
+              MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
+       /* Wait for controller to process START */
+       return twsi_wait(twsi, expected_status);
 }
 
 /*
  * Send a byte (i2c address or data).
  */
-static int twsi_send(u8 byte, int expected_status)
+static int twsi_send(struct mvtwsi_registers *twsi, u8 byte,
+                    int expected_status)
 {
-       /* put byte in data register for sending */
+       /* Write byte to data register for sending */
        writel(byte, &twsi->data);
-       /* clear any pending interrupt -- that'll cause sending */
-       writel(twsi_control_flags, &twsi->control);
-       /* wait for controller to receive byte and check ACK */
-       return twsi_wait(expected_status);
+       /* Clear any pending interrupt -- that will cause sending */
+       writel(MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_CLEAR_IFLG,
+              &twsi->control);
+       /* Wait for controller to receive byte, and check ACK */
+       return twsi_wait(twsi, expected_status);
 }
 
 /*
  * Receive a byte.
- * Global mvtwsi_control_flags variable says if we should ack or nak.
  */
-static int twsi_recv(u8 *byte)
+static int twsi_recv(struct mvtwsi_registers *twsi, u8 *byte, int ack_flag)
 {
-       int expected_status, status;
-
-       /* compute expected status based on ACK bit in global control flags */
-       if (twsi_control_flags & MVTWSI_CONTROL_ACK)
-               expected_status = MVTWSI_STATUS_DATA_R_ACK;
-       else
-               expected_status = MVTWSI_STATUS_DATA_R_NAK;
-       /* acknowledge *previous state* and launch receive */
-       writel(twsi_control_flags, &twsi->control);
-       /* wait for controller to receive byte and assert ACK or NAK */
-       status = twsi_wait(expected_status);
-       /* if we did receive expected byte then store it */
+       int expected_status, status, control;
+
+       /* Compute expected status based on passed ACK flag */
+       expected_status = ack_flag ? MVTWSI_STATUS_DATA_R_ACK :
+                         MVTWSI_STATUS_DATA_R_NAK;
+       /* Acknowledge *previous state*, and launch receive */
+       control = MVTWSI_CONTROL_TWSIEN;
+       control |= ack_flag == MVTWSI_READ_ACK ? MVTWSI_CONTROL_ACK : 0;
+       writel(control | MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
+       /* Wait for controller to receive byte, and assert ACK or NAK */
+       status = twsi_wait(twsi, expected_status);
+       /* If we did receive the expected byte, store it */
        if (status == 0)
                *byte = readl(&twsi->data);
-       /* return status */
        return status;
 }
 
 /*
  * Assert the STOP condition.
- * This is also used to force the bus back in idle (SDA=SCL=1).
+ * This is also used to force the bus back to idle (SDA = SCL = 1).
  */
-static int twsi_stop(int status)
+static int twsi_stop(struct mvtwsi_registers *twsi)
 {
        int control, stop_status;
+       int status = 0;
        int timeout = 1000;
 
-       /* assert STOP */
+       /* Assert STOP */
        control = MVTWSI_CONTROL_TWSIEN | MVTWSI_CONTROL_STOP;
-       writel(control, &twsi->control);
-       /* wait for IDLE; IFLG won't rise so twsi_wait() is no use. */
+       writel(control | MVTWSI_CONTROL_CLEAR_IFLG, &twsi->control);
+       /* Wait for IDLE; IFLG won't rise, so we can't use twsi_wait() */
        do {
                stop_status = readl(&twsi->status);
                if (stop_status == MVTWSI_STATUS_IDLE)
                        break;
-               udelay(10); /* one clock cycle at 100 kHz */
+               udelay(10); /* One clock cycle at 100 kHz */
        } while (timeout--);
        control = readl(&twsi->control);
        if (stop_status != MVTWSI_STATUS_IDLE)
-               if (status == 0)
-                       status = MVTWSI_ERROR(
-                               MVTWSI_ERROR_TIMEOUT,
-                               control, status, MVTWSI_STATUS_IDLE);
+               status = mvtwsi_error(MVTWSI_ERROR_TIMEOUT,
+                                     control, status, MVTWSI_STATUS_IDLE);
        return status;
 }
 
-/*
- * Ugly formula to convert m and n values to a frequency comes from
- * TWSI specifications
- */
-
-#define TWSI_FREQUENCY(m, n) \
-       (CONFIG_SYS_TCLK / (10 * (m + 1) * (1 << n)))
+static uint twsi_calc_freq(const int n, const int m)
+{
+#ifdef CONFIG_SUNXI
+       return CONFIG_SYS_TCLK / (10 * (m + 1) * (1 << n));
+#else
+       return CONFIG_SYS_TCLK / (10 * (m + 1) * (2 << n));
+#endif
+}
 
 /*
  * Reset controller.
  * Controller reset also resets the baud rate and slave address, so
  * they must be re-established afterwards.
  */
-static void twsi_reset(struct i2c_adapter *adap)
+static void twsi_reset(struct mvtwsi_registers *twsi)
 {
-       /* ensure controller will be enabled by any twsi*() function */
-       twsi_control_flags = MVTWSI_CONTROL_TWSIEN;
-       /* reset controller */
+       /* Reset controller */
        writel(0, &twsi->soft_reset);
-       /* wait 2 ms -- this is what the Marvell LSP does */
+       /* Wait 2 ms -- this is what the Marvell LSP does */
        udelay(20000);
 }
 
 /*
- * I2C init called by cmd_i2c when doing 'i2c reset'.
- * Sets baud to the highest possible value not exceeding requested one.
+ * Sets baud to the highest possible value not exceeding the requested one.
  */
-static unsigned int twsi_i2c_set_bus_speed(struct i2c_adapter *adap,
-                                          unsigned int requested_speed)
+static uint __twsi_i2c_set_bus_speed(struct mvtwsi_registers *twsi,
+                                    uint requested_speed)
 {
-       unsigned int tmp_speed, highest_speed, n, m;
-       unsigned int baud = 0x44; /* baudrate at controller reset */
+       uint tmp_speed, highest_speed, n, m;
+       uint baud = 0x44; /* Baud rate after controller reset */
 
-       /* use actual speed to collect progressively higher values */
        highest_speed = 0;
-       /* compute m, n setting for highest speed not above requested speed */
+       /* Successively try m, n combinations, and use the combination
+        * resulting in the largest speed that's not above the requested
+        * speed */
        for (n = 0; n < 8; n++) {
                for (m = 0; m < 16; m++) {
-                       tmp_speed = TWSI_FREQUENCY(m, n);
-                       if ((tmp_speed <= requested_speed)
-                        && (tmp_speed > highest_speed)) {
+                       tmp_speed = twsi_calc_freq(n, m);
+                       if ((tmp_speed <= requested_speed) &&
+                           (tmp_speed > highest_speed)) {
                                highest_speed = tmp_speed;
                                baud = (m << 3) | n;
                        }
@@ -278,129 +357,195 @@ static unsigned int twsi_i2c_set_bus_speed(struct i2c_adapter *adap,
        return 0;
 }
 
-static void twsi_i2c_init(struct i2c_adapter *adap, int speed, int slaveadd)
+static void __twsi_i2c_init(struct mvtwsi_registers *twsi, int speed,
+                         int slaveadd)
 {
-       /* reset controller */
-       twsi_reset(adap);
-       /* set speed */
-       twsi_i2c_set_bus_speed(adap, speed);
-       /* set slave address even though we don't use it */
+       /* Reset controller */
+       twsi_reset(twsi);
+       /* Set speed */
+       __twsi_i2c_set_bus_speed(twsi, speed);
+       /* Set slave address; even though we don't use it */
        writel(slaveadd, &twsi->slave_address);
        writel(0, &twsi->xtnd_slave_addr);
-       /* assert STOP but don't care for the result */
-       (void) twsi_stop(0);
+       /* Assert STOP, but don't care for the result */
+       (void) twsi_stop(twsi);
 }
 
 /*
  * Begin I2C transaction with expected start status, at given address.
- * Common to i2c_probe, i2c_read and i2c_write.
  * Expected address status will derive from direction bit (bit 0) in addr.
  */
-static int i2c_begin(int expected_start_status, u8 addr)
+static int i2c_begin(struct mvtwsi_registers *twsi, int expected_start_status,
+                    u8 addr)
 {
        int status, expected_addr_status;
 
-       /* compute expected address status from direction bit in addr */
-       if (addr & 1) /* reading */
+       /* Compute the expected address status from the direction bit in
+        * the address byte */
+       if (addr & 1) /* Reading */
                expected_addr_status = MVTWSI_STATUS_ADDR_R_ACK;
-       else /* writing */
+       else /* Writing */
                expected_addr_status = MVTWSI_STATUS_ADDR_W_ACK;
-       /* assert START */
-       status = twsi_start(expected_start_status);
-       /* send out the address if the start went well */
+       /* Assert START */
+       status = twsi_start(twsi, expected_start_status);
+       /* Send out the address if the start went well */
        if (status == 0)
-               status = twsi_send(addr, expected_addr_status);
-       /* return ok or status of first failure to caller */
+               status = twsi_send(twsi, addr, expected_addr_status);
+       /* Return 0, or the status of the first failure */
        return status;
 }
 
 /*
- * I2C probe called by cmd_i2c when doing 'i2c probe'.
  * Begin read, nak data byte, end.
  */
-static int twsi_i2c_probe(struct i2c_adapter *adap, uchar chip)
+static int __twsi_i2c_probe_chip(struct mvtwsi_registers *twsi, uchar chip)
 {
        u8 dummy_byte;
        int status;
 
-       /* begin i2c read */
-       status = i2c_begin(MVTWSI_STATUS_START, (chip << 1) | 1);
-       /* dummy read was accepted: receive byte but NAK it. */
+       /* Begin i2c read */
+       status = i2c_begin(twsi, MVTWSI_STATUS_START, (chip << 1) | 1);
+       /* Dummy read was accepted: receive byte, but NAK it. */
        if (status == 0)
-               status = twsi_recv(&dummy_byte);
+               status = twsi_recv(twsi, &dummy_byte, MVTWSI_READ_NAK);
        /* Stop transaction */
-       twsi_stop(0);
-       /* return 0 or status of first failure */
+       twsi_stop(twsi);
+       /* Return 0, or the status of the first failure */
        return status;
 }
 
 /*
- * I2C read called by cmd_i2c when doing 'i2c read' and by cmd_eeprom.c
  * Begin write, send address byte(s), begin read, receive data bytes, end.
  *
- * NOTE: some EEPROMS want a stop right before the second start, while
- * some will choke if it is there. Deciding which we should do is eeprom
- * stuff, not i2c, but at the moment the APIs won't let us put it in
- * cmd_eeprom, so we have to choose here, and for the moment that'll be
- * a repeated start without a preceding stop.
+ * NOTE: Some devices want a stop right before the second start, while some
+ * will choke if it is there. Since deciding this is not yet supported in
+ * higher level APIs, we need to make a decision here, and for the moment that
+ * will be a repeated start without a preceding stop.
  */
-static int twsi_i2c_read(struct i2c_adapter *adap, uchar chip, uint addr,
-                       int alen, uchar *data, int length)
+static int __twsi_i2c_read(struct mvtwsi_registers *twsi, uchar chip,
+                          uint addr, int alen, uchar *data, int length)
 {
-       int status;
+       int status = 0;
+       int stop_status;
 
-       /* begin i2c write to send the address bytes */
-       status = i2c_begin(MVTWSI_STATUS_START, (chip << 1));
-       /* send addr bytes */
+       /* Begin i2c write to send the address bytes */
+       status = i2c_begin(twsi, MVTWSI_STATUS_START, (chip << 1));
+       /* Send address bytes */
        while ((status == 0) && alen--)
-               status = twsi_send(addr >> (8*alen),
+               status = twsi_send(twsi, addr >> (8*alen),
                        MVTWSI_STATUS_DATA_W_ACK);
-       /* begin i2c read to receive eeprom data bytes */
+       /* Begin i2c read to receive data bytes */
        if (status == 0)
-               status = i2c_begin(
-                       MVTWSI_STATUS_REPEATED_START, (chip << 1) | 1);
-       /* prepare ACK if at least one byte must be received */
-       if (length > 0)
-               twsi_control_flags |= MVTWSI_CONTROL_ACK;
-       /* now receive actual bytes */
-       while ((status == 0) && length--) {
-               /* reset NAK if we if no more to read now */
-               if (length == 0)
-                       twsi_control_flags &= ~MVTWSI_CONTROL_ACK;
-               /* read current byte */
-               status = twsi_recv(data++);
-       }
+               status = i2c_begin(twsi, MVTWSI_STATUS_REPEATED_START,
+                                  (chip << 1) | 1);
+       /* Receive actual data bytes; set NAK if we if we have nothing more to
+        * read */
+       while ((status == 0) && length--)
+               status = twsi_recv(twsi, data++,
+                                  length > 0 ?
+                                  MVTWSI_READ_ACK : MVTWSI_READ_NAK);
        /* Stop transaction */
-       status = twsi_stop(status);
-       /* return 0 or status of first failure */
-       return status;
+       stop_status = twsi_stop(twsi);
+       /* Return 0, or the status of the first failure */
+       return status != 0 ? status : stop_status;
 }
 
 /*
- * I2C write called by cmd_i2c when doing 'i2c write' and by cmd_eeprom.c
  * Begin write, send address byte(s), send data bytes, end.
  */
-static int twsi_i2c_write(struct i2c_adapter *adap, uchar chip, uint addr,
-                       int alen, uchar *data, int length)
+static int __twsi_i2c_write(struct mvtwsi_registers *twsi, uchar chip,
+                           uint addr, int alen, uchar *data, int length)
 {
-       int status;
+       int status, stop_status;
 
-       /* begin i2c write to send the eeprom adress bytes then data bytes */
-       status = i2c_begin(MVTWSI_STATUS_START, (chip << 1));
-       /* send addr bytes */
+       /* Begin i2c write to send first the address bytes, then the
+        * data bytes */
+       status = i2c_begin(twsi, MVTWSI_STATUS_START, (chip << 1));
+       /* Send address bytes */
        while ((status == 0) && alen--)
-               status = twsi_send(addr >> (8*alen),
+               status = twsi_send(twsi, addr >> (8*alen),
                        MVTWSI_STATUS_DATA_W_ACK);
-       /* send data bytes */
+       /* Send data bytes */
        while ((status == 0) && (length-- > 0))
-               status = twsi_send(*(data++), MVTWSI_STATUS_DATA_W_ACK);
+               status = twsi_send(twsi, *(data++), MVTWSI_STATUS_DATA_W_ACK);
        /* Stop transaction */
-       status = twsi_stop(status);
-       /* return 0 or status of first failure */
-       return status;
+       stop_status = twsi_stop(twsi);
+       /* Return 0, or the status of the first failure */
+       return status != 0 ? status : stop_status;
+}
+
+static void twsi_i2c_init(struct i2c_adapter *adap, int speed,
+                         int slaveadd)
+{
+       struct mvtwsi_registers *twsi = twsi_get_base(adap);
+       __twsi_i2c_init(twsi, speed, slaveadd);
+}
+
+static uint twsi_i2c_set_bus_speed(struct i2c_adapter *adap,
+                                  uint requested_speed)
+{
+       struct mvtwsi_registers *twsi = twsi_get_base(adap);
+       return __twsi_i2c_set_bus_speed(twsi, requested_speed);
+}
+
+static int twsi_i2c_probe(struct i2c_adapter *adap, uchar chip)
+{
+       struct mvtwsi_registers *twsi = twsi_get_base(adap);
+       return __twsi_i2c_probe_chip(twsi, chip);
+}
+
+static int twsi_i2c_read(struct i2c_adapter *adap, uchar chip, uint addr,
+                        int alen, uchar *data, int length)
+{
+       struct mvtwsi_registers *twsi = twsi_get_base(adap);
+       return __twsi_i2c_read(twsi, chip, addr, alen, data, length);
+}
+
+static int twsi_i2c_write(struct i2c_adapter *adap, uchar chip, uint addr,
+                         int alen, uchar *data, int length)
+{
+       struct mvtwsi_registers *twsi = twsi_get_base(adap);
+       return __twsi_i2c_write(twsi, chip, addr, alen, data, length);
 }
 
+#ifdef CONFIG_I2C_MVTWSI_BASE0
 U_BOOT_I2C_ADAP_COMPLETE(twsi0, twsi_i2c_init, twsi_i2c_probe,
                         twsi_i2c_read, twsi_i2c_write,
                         twsi_i2c_set_bus_speed,
                         CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 0)
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE1
+U_BOOT_I2C_ADAP_COMPLETE(twsi1, twsi_i2c_init, twsi_i2c_probe,
+                        twsi_i2c_read, twsi_i2c_write,
+                        twsi_i2c_set_bus_speed,
+                        CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 1)
+
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE2
+U_BOOT_I2C_ADAP_COMPLETE(twsi2, twsi_i2c_init, twsi_i2c_probe,
+                        twsi_i2c_read, twsi_i2c_write,
+                        twsi_i2c_set_bus_speed,
+                        CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 2)
+
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE3
+U_BOOT_I2C_ADAP_COMPLETE(twsi3, twsi_i2c_init, twsi_i2c_probe,
+                        twsi_i2c_read, twsi_i2c_write,
+                        twsi_i2c_set_bus_speed,
+                        CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 3)
+
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE4
+U_BOOT_I2C_ADAP_COMPLETE(twsi4, twsi_i2c_init, twsi_i2c_probe,
+                        twsi_i2c_read, twsi_i2c_write,
+                        twsi_i2c_set_bus_speed,
+                        CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 4)
+
+#endif
+#ifdef CONFIG_I2C_MVTWSI_BASE5
+U_BOOT_I2C_ADAP_COMPLETE(twsi5, twsi_i2c_init, twsi_i2c_probe,
+                        twsi_i2c_read, twsi_i2c_write,
+                        twsi_i2c_set_bus_speed,
+                        CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE, 5)
+
+#endif
This page took 0.051998 seconds and 4 git commands to generate.