[coreboot-gerrit] New patch to review for coreboot: 74de8b4 i2c: Add software_i2c driver for I2C debugging and emulation
Marc Jones (marc.jones@se-eng.com)
gerrit at coreboot.org
Sat Dec 27 07:08:17 CET 2014
Marc Jones (marc.jones at se-eng.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/7947
-gerrit
commit 74de8b4cfbe7d056304703e2d179c9193d859bb0
Author: Julius Werner <jwerner at chromium.org>
Date: Mon May 5 18:03:46 2014 -0700
i2c: Add software_i2c driver for I2C debugging and emulation
This patch adds I2C emulation in software through raw toggling of the
SDA/SCL lines. Platforms need to provide bindings to toggle their
respective I2C busses for this to work (e.g. by pinmuxing them as GPIOs,
currently only enabled for Tegra).
This is mostly useful as a debugging feature, to drive unusual states on
a bus and closely monitor the device output without the need of a bus
analyzer. It provides a few functions to "wedge" an I2C bus by aborting
a transaction at certain points, which can be used to test if a system
can correctly recover from an ill-timed reboot. However, it can also
dynamically replace the existing I2C transfer functions and drive
some/all I2C transfers on the system, which might be useful if a driver
for the actual I2C controller hardware is not (yet) available.
Based on original code by Doug Anderson <dianders at chromium.org> and
Hung-ying Tyan <tyanh at chromium.org> for the ChromeOS embedded
controller project.
BRANCH=None
BUG=chrome-os-partner:28323
TEST=Spread tegra_software_i2c_init()/tegra_software_i2c_disable()
through the code and see that everything still works.
Original-Change-Id: I9ee7ccbd1efb38206669a35d0c3318af16f8be63
Original-Signed-off-by: Julius Werner <jwerner at chromium.org>
Original-Reviewed-on: https://chromium-review.googlesource.com/198791
Original-Reviewed-by: Doug Anderson <dianders at chromium.org>
Original-Reviewed-by: Tom Warren <twarren at nvidia.com>
Original-Reviewed-by: Stefan Reinauer <reinauer at chromium.org>
(cherry picked from commit 8f71503dbbd74c5298e90e2163b67d4efe3e89db)
Signed-off-by: Marc Jones <marc.jones at se-eng.com>
Change-Id: Id6c5f75bb5baaabd62b6b1fc26c2c71d9f1ce682
---
src/device/Kconfig | 10 +
src/device/Makefile.inc | 4 +
src/device/software_i2c.c | 345 +++++++++++++++++++++++++++++++++++
src/include/device/i2c.h | 34 +++-
src/soc/nvidia/tegra/i2c.c | 2 +-
src/soc/nvidia/tegra/i2c.h | 2 +
src/soc/nvidia/tegra/software_i2c.c | 96 ++++++++++
src/soc/nvidia/tegra124/Makefile.inc | 3 +
src/soc/samsung/exynos5250/i2c.c | 2 +-
src/soc/samsung/exynos5420/i2c.c | 2 +-
10 files changed, 496 insertions(+), 4 deletions(-)
diff --git a/src/device/Kconfig b/src/device/Kconfig
index bd2f34b..67d01e0 100644
--- a/src/device/Kconfig
+++ b/src/device/Kconfig
@@ -376,6 +376,16 @@ config PXE_ROM_ID
Under GNU/Linux you can run `lspci -nn` to list the IDs of your PCI devices.
+config SOFTWARE_I2C
+ bool "Enable I2C controller emulation in software"
+ default n
+ help
+ This config option will enable code to override the i2c_transfer
+ routine with a (simple) software emulation of the protocol. This may
+ be useful for debugging or on platforms where a driver for the real
+ I2C controller is not (yet) available. The platform code needs to
+ provide bindings to manually toggle I2C lines.
+
endmenu
menu "Display"
diff --git a/src/device/Makefile.inc b/src/device/Makefile.inc
index a7f3364..7fdd9b5 100644
--- a/src/device/Makefile.inc
+++ b/src/device/Makefile.inc
@@ -24,3 +24,7 @@ romstage-$(CONFIG_PCI) += pci_early.c
subdirs-y += oprom dram
ramstage-$(CONFIG_VGA_ROM_RUN) += pci_rom.c
+
+bootblock-$(CONFIG_SOFTWARE_I2C) += software_i2c.c
+romstage-$(CONFIG_SOFTWARE_I2C) += software_i2c.c
+ramstage-$(CONFIG_SOFTWARE_I2C) += software_i2c.c
diff --git a/src/device/software_i2c.c b/src/device/software_i2c.c
new file mode 100644
index 0000000..6c9c200
--- /dev/null
+++ b/src/device/software_i2c.c
@@ -0,0 +1,345 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <assert.h>
+#include <timer.h>
+#include <console/console.h>
+#include <device/i2c.h>
+
+/*
+ * The implementation is based on Wikipedia.
+ */
+
+#define DEBUG 0 /* Set to 1 for per-byte output */
+#define SPEW 0 /* Set to 1 for verbose bitwise/line-state output */
+#define DELAY_US 5 /* Default setup delay: 4us (+1 for timer inaccuracy) */
+#define TIMEOUT_US 50000 /* Maximum clock stretching time we want to allow */
+
+#define spew(...) do { if (SPEW) printk(BIOS_SPEW, ##__VA_ARGS__); } while (0)
+
+struct software_i2c_ops *software_i2c[SOFTWARE_I2C_MAX_BUS];
+
+/*
+ * Waits until either timeout_us have passed or (iff for_scl is set) until SCL
+ * goes high. Will report random line changes during the wait and return SCL.
+ */
+static int __wait(unsigned bus, int timeout_us, int for_scl)
+{
+ int us;
+ int sda = software_i2c[bus]->get_sda(bus);
+ int scl = software_i2c[bus]->get_scl(bus);
+ struct mono_time start;
+ timer_monotonic_get(&start);
+
+ do {
+ int old_sda = sda;
+ int old_scl = scl;
+ struct rela_time diff = current_time_from(&start);
+ us = rela_time_in_microseconds(&diff);
+
+ if (old_sda != (sda = software_i2c[bus]->get_sda(bus)))
+ spew("[SDA transitioned to %d after %dus] ", sda, us);
+ if (old_scl != (scl = software_i2c[bus]->get_scl(bus)))
+ spew("[SCL transitioned to %d after %dus] ", scl, us);
+ } while (us < timeout_us && (!for_scl || !scl));
+
+ return scl;
+}
+
+/* Waits the default DELAY_US to allow line state to stabilize. */
+static void wait(unsigned bus)
+{
+ __wait(bus, DELAY_US, 0);
+}
+
+/* Waits until SCL goes high. Prints a contextual error message on timeout. */
+static int wait_for_scl(unsigned bus, const char *error_context)
+{
+ if (!__wait(bus, TIMEOUT_US, 1)) {
+ printk(BIOS_ERR, "software_i2c(%d): ERROR: Clock stretching "
+ "timeout %s!\n", bus, error_context);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int start_cond(unsigned bus)
+{
+ spew("software_i2c(%d): Sending start condition... ", bus);
+
+ /* SDA might not yet be high if repeated start. */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+
+ /* Might need to wait for clock stretching if repeated start. */
+ software_i2c[bus]->set_scl(bus, 1);
+ if (wait_for_scl(bus, "before start condition"))
+ return -1;
+ wait(bus); /* Repeated start setup time, minimum 4.7us */
+
+ if (!software_i2c[bus]->get_sda(bus)) {
+ printk(BIOS_ERR, "software_i2c(%d): Arbitration lost trying "
+ "to send start condition!\n", bus);
+ return -1;
+ }
+
+ /* SCL is high, transition SDA low as first part of start condition. */
+ software_i2c[bus]->set_sda(bus, 0);
+ wait(bus);
+ assert(software_i2c[bus]->get_scl(bus));
+
+ /* Pull SCL low to finish start condition (next pulse will be data). */
+ software_i2c[bus]->set_scl(bus, 0);
+
+ spew("Start condition transmitted!\n");
+ return 0;
+}
+
+static int stop_cond(unsigned bus)
+{
+ spew("software_i2c(%d): Sending stop condition... ", bus);
+
+ /* SDA is unknown, set it to low. SCL must be low. */
+ software_i2c[bus]->set_sda(bus, 0);
+ wait(bus);
+
+ /* Clock stretching */
+ assert(!software_i2c[bus]->get_scl(bus));
+ software_i2c[bus]->set_scl(bus, 1);
+ if (wait_for_scl(bus, "before stop condition"))
+ return -1;
+ wait(bus); /* Stop bit setup time, minimum 4us */
+
+ /* SCL is high, transition SDA high to signal stop condition. */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+ if (!software_i2c[bus]->get_sda(bus)) {
+ printk(BIOS_WARNING, "software_i2c(%d): WARNING: SDA low after "
+ "stop condition... access by another master or line "
+ "stuck from faulty slave?\n", bus);
+ /* Could theoretically happen with multi-master, so no -1. */
+ }
+
+ spew("Stop condition transmitted\n");
+ return 0;
+}
+
+static int out_bit(unsigned bus, int bit)
+{
+ spew("software_i2c(%d): Sending a %d bit... ", bus, bit);
+
+ software_i2c[bus]->set_sda(bus, bit);
+ wait(bus);
+
+ if (bit && !software_i2c[bus]->get_sda(bus)) {
+ printk(BIOS_ERR, "software_i2c(%d): ERROR: SDA wedged low "
+ "by slave before clock pulse on transmit!\n", bus);
+ return -1;
+ }
+
+ /* Clock stretching */
+ assert(!software_i2c[bus]->get_scl(bus));
+ software_i2c[bus]->set_scl(bus, 1);
+ if (wait_for_scl(bus, "on transmit"))
+ return -1;
+ wait(bus);
+
+ if (bit && !software_i2c[bus]->get_sda(bus)) {
+ printk(BIOS_ERR, "software_i2c(%d): ERROR: SDA wedged low "
+ "by slave after clock pulse on transmit!\n", bus);
+ return -1;
+ }
+
+ assert(software_i2c[bus]->get_scl(bus));
+ software_i2c[bus]->set_scl(bus, 0);
+
+ spew("%d bit sent!\n", bit);
+ return 0;
+}
+
+static int in_bit(unsigned bus)
+{
+ int bit;
+
+ spew("software_i2c(%d): Receiving a bit... ", bus);
+
+ /* Let the slave drive data */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+
+ /* Clock stretching */
+ assert(!software_i2c[bus]->get_scl(bus));
+ software_i2c[bus]->set_scl(bus, 1);
+ if (wait_for_scl(bus, "on receive"))
+ return -1;
+
+ /* SCL is high, now data is valid */
+ bit = software_i2c[bus]->get_sda(bus);
+ wait(bus);
+ assert(software_i2c[bus]->get_scl(bus));
+ software_i2c[bus]->set_scl(bus, 0);
+
+ spew("Received a %d!\n", bit);
+
+ return bit;
+}
+
+/* Write a byte to I2C bus. Return 0 if ack by the slave. */
+static int out_byte(unsigned bus, u8 byte)
+{
+ unsigned bit;
+ int nack;
+
+ for (bit = 0; bit < 8; bit++)
+ if (out_bit(bus, (byte >> (7 - bit)) & 0x1) < 0)
+ return -1;
+
+ nack = in_bit(bus);
+
+ if (DEBUG && nack >= 0)
+ printk(BIOS_DEBUG, "software_i2c(%d): wrote byte 0x%02x, "
+ "received %s\n", bus, byte, nack ? "NAK" : "ACK");
+
+ return nack;
+}
+
+static int in_byte(unsigned bus, int ack)
+{
+ u8 byte = 0;
+ int i;
+ for (i = 0; i < 8; ++i) {
+ int bit = in_bit(bus);
+ if (bit < 0)
+ return -1;
+ byte = (byte << 1) | bit;
+ }
+
+ if (out_bit(bus, !ack) < 0)
+ return -1;
+
+ if (DEBUG)
+ printk(BIOS_DEBUG, "software_i2c(%d): read byte 0x%02x, "
+ "sent %s\n", bus, byte, ack ? "ACK" : "NAK");
+
+ return byte;
+}
+
+int software_i2c_transfer(unsigned bus, struct i2c_seg *segments, int count)
+{
+ int i;
+ struct i2c_seg *seg;
+
+ for (seg = segments; seg - segments < count; seg++) {
+ if (start_cond(bus) < 0)
+ return -1;
+ if (out_byte(bus, seg->chip << 1 | !!seg->read) < 0)
+ return -1;
+ for (i = 0; i < seg->len; i++) {
+ int ret;
+ if (seg->read) {
+ ret = in_byte(bus, i < seg->len - 1);
+ seg->buf[i] = (u8)ret;
+ } else {
+ ret = out_byte(bus, seg->buf[i]);
+ }
+ if (ret < 0)
+ return -1;
+ }
+ }
+ if (stop_cond(bus) < 0)
+ return -1;
+
+ return 0;
+}
+
+void software_i2c_wedge_ack(unsigned bus, u8 chip)
+{
+ int i;
+
+ /* Start a command to 'chip'... */
+ start_cond(bus);
+
+ /* Send the address bits but don't yet read the ACK. */
+ chip <<= 1;
+ for (i = 0; i < 8; ++i)
+ out_bit(bus, (chip >> (7 - i)) & 0x1);
+
+ /* Let the slave drive it's ACK but keep the clock high forever. */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+ software_i2c[bus]->set_scl(bus, 1);
+ wait_for_scl(bus, "on wedge_ack()");
+
+ printk(BIOS_INFO, "software_i2c(%d): wedged address write on slave "
+ "ACK. SDA %d, SCL %d\n", bus, software_i2c[bus]->get_sda(bus),
+ software_i2c[bus]->get_scl(bus));
+}
+
+void software_i2c_wedge_read(unsigned bus, u8 chip, u8 reg, int bits)
+{
+ int i;
+
+ /* Start a command to 'chip'... */
+ start_cond(bus);
+ out_byte(bus, chip << 1);
+ /* ...for register 'reg'. */
+ out_byte(bus, reg);
+
+ /* Start a read command... */
+ start_cond(bus);
+ out_byte(bus, chip << 1 | 1);
+
+ /* Read bit_count bits and stop */
+ for (i = 0; i < bits; ++i)
+ in_bit(bus);
+
+ /* Let the slave drive SDA but keep the clock high forever. */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+ software_i2c[bus]->set_scl(bus, 1);
+ wait_for_scl(bus, "on wedge_read()");
+
+ printk(BIOS_INFO, "software_i2c(%d): wedged data read after %d bits. "
+ "SDA %d, SCL %d\n", bus, bits, software_i2c[bus]->get_sda(bus),
+ software_i2c[bus]->get_scl(bus));
+}
+
+void software_i2c_wedge_write(unsigned bus, u8 chip, u8 reg, int bits)
+{
+ int i;
+
+ /* Start a command to 'chip'... */
+ start_cond(bus);
+ out_byte(bus, chip << 1);
+
+ /* Write bit_count register bits and stop */
+ for (i = 0; i < bits; ++i)
+ out_bit(bus, (reg >> (7 - i)) & 0x1);
+
+ /* Pretend to write another 1 bit but keep the clock high forever. */
+ software_i2c[bus]->set_sda(bus, 1);
+ wait(bus);
+ software_i2c[bus]->set_scl(bus, 1);
+ wait_for_scl(bus, "on wedge_write()");
+
+ printk(BIOS_INFO, "software_i2c(%d): wedged data write after %d bits. "
+ "SDA %d, SCL %d\n", bus, bits, software_i2c[bus]->get_sda(bus),
+ software_i2c[bus]->get_scl(bus));
+}
diff --git a/src/include/device/i2c.h b/src/include/device/i2c.h
index da9d1bc..c1f2a21 100644
--- a/src/include/device/i2c.h
+++ b/src/include/device/i2c.h
@@ -31,7 +31,39 @@ struct i2c_seg
int len;
};
-int i2c_transfer(unsigned bus, struct i2c_seg *segments, int count);
+int platform_i2c_transfer(unsigned bus, struct i2c_seg *segments, int count);
+
+#define SOFTWARE_I2C_MAX_BUS 10 /* increase as necessary */
+
+struct software_i2c_ops {
+ void (*set_sda)(unsigned bus, int high);
+ void (*set_scl)(unsigned bus, int high);
+ int (*get_sda)(unsigned bus);
+ int (*get_scl)(unsigned bus);
+};
+
+extern struct software_i2c_ops *software_i2c[];
+
+int software_i2c_transfer(unsigned bus, struct i2c_seg *segments, int count);
+void software_i2c_wedge_ack(unsigned bus, u8 chip);
+void software_i2c_wedge_read(unsigned bus, u8 chip, u8 reg, int bit_count);
+void software_i2c_wedge_write(unsigned bus, u8 chip, u8 reg, int bit_count);
+
+/*
+ * software_i2c is supposed to be a debug feature. It's usually not compiled in,
+ * but when it is it can be dynamically enabled at runtime for certain busses.
+ * Need this ugly stub to arbitrate since I2C device drivers hardcode
+ * 'i2c_transfer()' as their entry point.
+ */
+static inline int i2c_transfer(unsigned bus, struct i2c_seg *segments,
+ int count)
+{
+ if (CONFIG_SOFTWARE_I2C)
+ if (bus < SOFTWARE_I2C_MAX_BUS && software_i2c[bus])
+ return software_i2c_transfer(bus, segments, count);
+
+ return platform_i2c_transfer(bus, segments, count);
+}
/*
* Read a raw chunk of data in one segment and one frame.
diff --git a/src/soc/nvidia/tegra/i2c.c b/src/soc/nvidia/tegra/i2c.c
index 6c269cf..555d031 100644
--- a/src/soc/nvidia/tegra/i2c.c
+++ b/src/soc/nvidia/tegra/i2c.c
@@ -180,7 +180,7 @@ static int i2c_transfer_segment(unsigned bus, unsigned chip, int restart,
return 0;
}
-int i2c_transfer(unsigned bus, struct i2c_seg *segments, int count)
+int platform_i2c_transfer(unsigned bus, struct i2c_seg *segments, int count)
{
struct i2c_seg *seg = segments;
diff --git a/src/soc/nvidia/tegra/i2c.h b/src/soc/nvidia/tegra/i2c.h
index 6347fff..4b1bddd 100644
--- a/src/soc/nvidia/tegra/i2c.h
+++ b/src/soc/nvidia/tegra/i2c.h
@@ -23,6 +23,8 @@
#include <stdint.h>
void i2c_init(unsigned bus);
+void tegra_software_i2c_init(unsigned bus);
+void tegra_software_i2c_disable(unsigned bus);
enum {
/* Word 0 */
diff --git a/src/soc/nvidia/tegra/software_i2c.c b/src/soc/nvidia/tegra/software_i2c.c
new file mode 100644
index 0000000..b50fb4f
--- /dev/null
+++ b/src/soc/nvidia/tegra/software_i2c.c
@@ -0,0 +1,96 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <device/i2c.h>
+#include <soc/nvidia/tegra124/gpio.h>
+#include <soc/nvidia/tegra124/pinmux.h>
+
+#include "i2c.h"
+
+static struct {
+ int pinmux_func;
+ gpio_t sda;
+ gpio_t scl;
+} pins[] = {
+ [0]{.pinmux_func = PINMUX_GEN1_I2C_SCL_FUNC_I2C1,
+ .sda = GPIO(C5), .scl = GPIO(C4)},
+ [1]{.pinmux_func = PINMUX_GEN2_I2C_SCL_FUNC_I2C2,
+ .sda = GPIO(T6), .scl = GPIO(T5)},
+ [2]{.pinmux_func = PINMUX_CAM_I2C_SCL_FUNC_I2C3,
+ .sda = GPIO(BB2), .scl = GPIO(BB1)},
+ [3]{.pinmux_func = PINMUX_DDC_SCL_FUNC_I2C4,
+ .sda = GPIO(V5), .scl = GPIO(V4)},
+ [4]{.pinmux_func = PINMUX_PWR_I2C_SCL_FUNC_I2CPMU,
+ .sda = GPIO(Z7), .scl = GPIO(Z6)},
+};
+
+static void tegra_set_sda(unsigned bus, int high)
+{
+ if (high)
+ gpio_input_pullup(pins[bus].sda);
+ else
+ gpio_output(pins[bus].sda, 0);
+}
+
+static void tegra_set_scl(unsigned bus, int high)
+{
+ if (high)
+ gpio_input_pullup(pins[bus].scl);
+ else
+ gpio_output(pins[bus].scl, 0);
+}
+
+static int tegra_get_sda(unsigned bus)
+{
+ return gpio_get_in_value(pins[bus].sda);
+}
+
+static int tegra_get_scl(unsigned bus)
+{
+ return gpio_get_in_value(pins[bus].scl);
+}
+
+static struct software_i2c_ops tegra_ops = {
+ .set_sda = tegra_set_sda,
+ .set_scl = tegra_set_scl,
+ .get_sda = tegra_get_sda,
+ .get_scl = tegra_get_scl,
+};
+
+void tegra_software_i2c_init(unsigned bus)
+{
+ software_i2c[bus] = &tegra_ops;
+
+ /* Initialize bus to idle state. */
+ tegra_set_sda(bus, 1);
+ tegra_set_scl(bus, 1);
+}
+
+void tegra_software_i2c_disable(unsigned bus)
+{
+ software_i2c[bus] = NULL;
+
+ /* Return pins to I2C controller. */
+ pinmux_set_config(pins[bus].sda >> GPIO_PINMUX_SHIFT,
+ pins[bus].pinmux_func | PINMUX_INPUT_ENABLE);
+ pinmux_set_config(pins[bus].scl >> GPIO_PINMUX_SHIFT,
+ pins[bus].pinmux_func | PINMUX_INPUT_ENABLE);
+ gpio_set_mode(pins[bus].sda, GPIO_MODE_SPIO);
+ gpio_set_mode(pins[bus].scl, GPIO_MODE_SPIO);
+}
diff --git a/src/soc/nvidia/tegra124/Makefile.inc b/src/soc/nvidia/tegra124/Makefile.inc
index c7b2e16..792bb99 100644
--- a/src/soc/nvidia/tegra124/Makefile.inc
+++ b/src/soc/nvidia/tegra124/Makefile.inc
@@ -11,6 +11,7 @@ bootblock-y += power.c
bootblock-y += spi.c
bootblock-y += ../tegra/gpio.c
bootblock-y += ../tegra/i2c.c
+bootblock-$(CONFIG_SOFTWARE_I2C) += ../tegra/software_i2c.c
bootblock-y += ../tegra/pingroup.c
bootblock-y += ../tegra/pinmux.c
bootblock-y += ../tegra/apbmisc.c
@@ -32,6 +33,7 @@ romstage-y += sdram_lp0.c
romstage-y += spi.c
romstage-y += ../tegra/gpio.c
romstage-y += ../tegra/i2c.c
+romstage-$(CONFIG_SOFTWARE_I2C) += ../tegra/software_i2c.c
romstage-y += ../tegra/pinmux.c
romstage-y += timer.c
romstage-$(CONFIG_CONSOLE_SERIAL) += uart.c
@@ -51,6 +53,7 @@ ramstage-y += spi.c
ramstage-y += dp.c
ramstage-y += ../tegra/gpio.c
ramstage-y += ../tegra/i2c.c
+ramstage-$(CONFIG_SOFTWARE_I2C) += ../tegra/software_i2c.c
ramstage-y += ../tegra/pinmux.c
ramstage-y += ../tegra/usb.c
ramstage-y += timer.c
diff --git a/src/soc/samsung/exynos5250/i2c.c b/src/soc/samsung/exynos5250/i2c.c
index d5d83b3..1e526d6 100644
--- a/src/soc/samsung/exynos5250/i2c.c
+++ b/src/soc/samsung/exynos5250/i2c.c
@@ -237,7 +237,7 @@ static int i2c_recv_buf(struct i2c_regs *regs, uint8_t *data, int len)
return 0;
}
-int i2c_transfer(unsigned bus, struct i2c_seg *segments, int seg_count)
+int platform_i2c_transfer(unsigned bus, struct i2c_seg *segments, int seg_count)
{
struct s3c24x0_i2c_bus *i2c = &i2c_busses[bus];
struct i2c_regs *regs = i2c->regs;
diff --git a/src/soc/samsung/exynos5420/i2c.c b/src/soc/samsung/exynos5420/i2c.c
index b79f914..49875d7 100644
--- a/src/soc/samsung/exynos5420/i2c.c
+++ b/src/soc/samsung/exynos5420/i2c.c
@@ -633,7 +633,7 @@ static int i2c_recv_buf(struct i2c_regs *regs, uint8_t *data, int len)
return 0;
}
-int i2c_transfer(unsigned bus, struct i2c_seg *segments, int count)
+int platform_i2c_transfer(unsigned bus, struct i2c_seg *segments, int count)
{
struct i2c_bus *i2c = &i2c_busses[bus];
if (i2c->is_highspeed)
More information about the coreboot-gerrit
mailing list