Openbmc dev snapshot.

1 files changed, 236 insertions, 0 deletions

diff --git a/common/recipes-utils/bitbang/files/src/bitbang.c b/common/recipes-utils/bitbang/files/src/bitbang.c
new file mode 100644
index 0000000..1318f42
--- /dev/null
+++ b/common/recipes-utils/bitbang/files/src/bitbang.c
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2014-present Facebook. All Rights Reserved.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+//#define DEBUG
+//#define VERBOSE
+
+#include "bitbang.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <openbmc/log.h>
+
+#define NANOSEC_IN_SEC (1000 * 1000 * 1000)
+
+#define BITBANG_FREQ_MAX (500 * 1000 * 1000) /* 500M Hz */
+#define BITBANG_FREQ_DEFAULT (1 * 1000 * 1000) /* 1M Hz */
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+struct bitbang_handle {
+  bitbang_init_st bbh_init;
+  uint32_t bbh_half_clk;           /* ns per clock cycle */
+};
+
+void bitbang_init_default(bitbang_init_st *init)
+{
+  memset(init, sizeof(*init), 0);
+  init->bbi_clk_start = BITBANG_PIN_HIGH;
+  init->bbi_data_out = BITBANG_CLK_EDGE_FALLING;
+  init->bbi_data_in = BITBANG_CLK_EDGE_RISING;
+  init->bbi_freq = BITBANG_FREQ_DEFAULT;
+}
+
+bitbang_handle_st* bitbang_open(const bitbang_init_st *init)
+{
+  bitbang_handle_st *hdl;
+
+  if (!init || !init->bbi_pin_f
+      || !init->bbi_freq || init->bbi_freq > BITBANG_FREQ_MAX) {
+    LOG_ERR(EINVAL, "Invalid init structure");
+    return NULL;
+  }
+
+  hdl = calloc(1, sizeof(*hdl));
+  if (!hdl) {
+    return NULL;
+  }
+
+  hdl->bbh_init = *init;
+  hdl->bbh_half_clk = NANOSEC_IN_SEC / init->bbi_freq / 2;
+
+  LOG_DBG("Bitbang open with initial %s, data out at %s, data in at %s, "
+          "freq at %uHz, half clk %uns",
+          (init->bbi_clk_start == BITBANG_PIN_LOW) ? "LOW" : "HIGH",
+          (init->bbi_data_out == BITBANG_CLK_EDGE_RISING)
+          ? "RISING" : "FALLING",
+          (init->bbi_data_in == BITBANG_CLK_EDGE_RISING)
+          ? "RISING" : "FALLING",
+          init->bbi_freq, hdl->bbh_half_clk);
+
+  return hdl;
+}
+
+void bitbang_close(bitbang_handle_st *hdl)
+{
+  free(hdl);
+}
+
+/*
+ * The threshold (ns) to use spin instead of nanosleep().
+ * Before adding the high resolution timer support, either spin or nanosleep()
+ * will not bring the process wakeup within 10ms. It turns out the system time
+ * update is also controlled by HZ (100).
+ * After I added the high resolution timer support, the spin works as the
+ * system time is updated more frequently. However, nanosleep() solution is
+ * still noticable slower comparing with spin. There could be some kernel
+ * scheduling tweak missing. Did not get time on that yet.
+ * For now, use 10ms as the threshold to determine if spin or nanosleep()
+ * is used.
+ */
+#define BITBANG_SPIN_THRESHOLD (10 * 1000 * 1000)
+
+static int sleep_ns(uint32_t clk)
+{
+  struct timespec req, rem;
+  int rc = 0;
+  if (clk <= BITBANG_SPIN_THRESHOLD) {
+    struct timespec orig;
+    rc = clock_gettime(CLOCK_MONOTONIC, &req);
+    orig = req;
+    while (!rc && clk) {
+      uint32_t tmp;
+      rc = clock_gettime(CLOCK_MONOTONIC, &rem);
+      tmp = (rem.tv_sec - req.tv_sec) * NANOSEC_IN_SEC;
+      if (rem.tv_nsec >= req.tv_nsec) {
+        tmp += rem.tv_nsec - req.tv_nsec;
+      } else {
+        tmp -= req.tv_nsec - rem.tv_nsec;
+      }
+      if (tmp >= clk) {
+        break;
+      }
+      clk -= tmp;
+      req = rem;
+    }
+  } else {
+    req.tv_sec = 0;
+    req.tv_nsec = clk;
+    while ((rc = nanosleep(&req, &rem)) == -1 && errno == EINTR) {
+      req = rem;
+    }
+  }
+  if (rc == -1) {
+    rc = errno;
+    LOG_ERR(rc, "Failed to sleep %u nanoseconds", clk);
+  }
+  return rc;
+}
+
+int bitbang_io(const bitbang_handle_st *hdl, bitbang_io_st *io)
+{
+  int rc = 0;
+  uint32_t clk = hdl->bbh_half_clk;
+  const struct {
+    bitbang_pin_value_en value;
+    bitbang_clk_edge_en edge;
+  } clks[] = {
+    {BITBANG_PIN_HIGH, BITBANG_CLK_EDGE_FALLING},
+    {BITBANG_PIN_LOW, BITBANG_CLK_EDGE_RISING},
+  };
+  int clk_idx;
+  int n_clk = 0;
+  int n_bits = 0;
+  const uint8_t *dout = io->bbio_dout;
+  uint8_t *din = io->bbio_din;
+  int bit_pos = 7;
+  bitbang_pin_func pin_f = hdl->bbh_init.bbi_pin_f;
+  void *context = hdl->bbh_init.bbi_context;
+
+  if ((io->bbio_in_bits == 0 && io->bbio_din)
+      || (io->bbio_in_bits > 0 && !io->bbio_din)) {
+    rc = EINVAL;
+    LOG_ERR(rc, "Incorrect in bits and in buffer");
+    goto out;
+  }
+
+  if ((io->bbio_out_bits == 0 && io->bbio_dout)
+      || (io->bbio_out_bits > 0 && !io->bbio_dout)) {
+    rc = EINVAL;
+    LOG_ERR(rc, "Incorrect out bits and out buffer");
+    goto out;
+  }
+
+  if (io->bbio_in_bits == 0 && io->bbio_out_bits == 0) {
+    rc = EINVAL;
+    LOG_ERR(rc, "Both in and out bits are 0");
+    goto out;
+  }
+
+  if (hdl->bbh_init.bbi_clk_start == BITBANG_PIN_HIGH) {
+    clk_idx = 0;
+  } else {
+    clk_idx = 1;
+  }
+
+  /* set the CLK pin start position */
+  pin_f(BITBANG_CLK_PIN, clks[clk_idx].value, context);
+
+  /* clear the first byte of din */
+  if (din && io->bbio_in_bits) {
+    memset(din, 0, (io->bbio_in_bits + 7) / 8);
+  }
+
+  do {
+    if ((rc = sleep_ns(clk))) {
+      goto out;
+    }
+
+    /* output first */
+    if (hdl->bbh_init.bbi_data_out == clks[clk_idx].edge) {
+      if (dout && n_bits < io->bbio_out_bits) {
+        pin_f(BITBANG_DATA_OUT, (*dout >> bit_pos) & 0x1, context);
+      }
+    }
+
+    /* then, input */
+    if (hdl->bbh_init.bbi_data_in == clks[clk_idx].edge) {
+      if (din && n_bits < io->bbio_in_bits) {
+        *din |= (pin_f(BITBANG_DATA_IN, 0, context) & 0x1) << bit_pos;
+      }
+    }
+
+    if (++n_clk % 2 == 0) {
+      /* one bit for every 2 half clks */
+      n_bits ++;
+      if (bit_pos == 0) {
+        if (dout) {
+          dout++;
+        }
+        if (din) {
+          din++;
+        }
+        bit_pos = 7;
+      } else {
+        bit_pos --;
+      }
+    }
+    clk_idx = 1 - clk_idx;
+    pin_f(BITBANG_CLK_PIN, clks[clk_idx].value, context);
+  } while (n_bits < MAX(io->bbio_in_bits, io->bbio_out_bits));
+
+ out:
+
+  return -rc;
+}