mynewt-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sterl...@apache.org
Subject [13/51] [abbrv] [partial] incubator-mynewt-core git commit: directory re-org, part 1
Date Wed, 28 Sep 2016 00:43:39 GMT
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/ecc.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/ecc.c b/crypto/tinycrypt/src/ecc.c
new file mode 100644
index 0000000..357139b
--- /dev/null
+++ b/crypto/tinycrypt/src/ecc.c
@@ -0,0 +1,604 @@
+/* ecc.c - TinyCrypt implementation of ECC auxiliary functions */
+
+/*
+  *
+  * Copyright (c) 2013, Kenneth MacKay
+  * All rights reserved.
+  * https://github.com/kmackay/micro-ecc
+  *
+  *  Redistribution and use in source and binary forms, with or without modification,
+  *  are permitted provided that the following conditions are met:
+  * * Redistributions of source code must retain the above copyright notice, this
+  * list of conditions and the following disclaimer.
+  * * Redistributions in binary form must reproduce the above copyright notice,
+  * this list of conditions and the following disclaimer in the documentation
+  * and/or other materials provided with the distribution.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
+  *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+  *
+  *  Redistribution and use in source and binary forms, with or without
+  *  modification, are permitted provided that the following conditions are met:
+  *
+  *    - Redistributions of source code must retain the above copyright notice,
+  *     this list of conditions and the following disclaimer.
+  *
+  *    - Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  *
+  *    - Neither the name of Intel Corporation nor the names of its contributors
+  *    may be used to endorse or promote products derived from this software
+  *    without specific prior written permission.
+  *
+  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  *  POSSIBILITY OF SUCH DAMAGE.
+  */
+
+#include <tinycrypt/ecc.h>
+
+/* ------ Curve NIST P-256 constants: ------ */
+
+#define Curve_P {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000,	\
+			0x00000000, 0x00000000, 0x00000001, 0xFFFFFFFF}
+
+#define Curve_B {0x27D2604B, 0x3BCE3C3E, 0xCC53B0F6, 0x651D06B0,	\
+			0x769886BC, 0xB3EBBD55, 0xAA3A93E7, 0x5AC635D8}
+
+#define Curve_N {0xFC632551, 0xF3B9CAC2, 0xA7179E84, 0xBCE6FAAD,	\
+			0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF}
+
+#define Curve_G {{0xD898C296, 0xF4A13945, 0x2DEB33A0, 0x77037D81,	\
+				0x63A440F2, 0xF8BCE6E5, 0xE12C4247, 0x6B17D1F2}, \
+		{0x37BF51F5, 0xCBB64068, 0x6B315ECE, 0x2BCE3357,	\
+				0x7C0F9E16, 0x8EE7EB4A, 0xFE1A7F9B, 0x4FE342E2} }
+
+#define Curve_P_Barrett {0x00000003, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFE, \
+			0xFFFFFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x00000000, 0x00000001}
+
+#define Curve_N_Barrett {0xEEDF9BFE, 0x012FFD85, 0xDF1A6C21, 0x43190552, \
+			0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x00000000, 0x00000001}
+
+uint32_t curve_p[NUM_ECC_DIGITS] = Curve_P;
+uint32_t curve_b[NUM_ECC_DIGITS] = Curve_B;
+EccPoint curve_G = Curve_G;
+uint32_t curve_n[NUM_ECC_DIGITS] = Curve_N;
+uint32_t curve_pb[NUM_ECC_DIGITS + 1] = Curve_P_Barrett;
+uint32_t curve_nb[NUM_ECC_DIGITS + 1] = Curve_N_Barrett;
+
+/* ------ Static functions: ------ */
+
+/* Zeroing out p_vli. */
+static void vli_clear(uint32_t *p_vli)
+{
+	uint32_t i;
+
+	for (i = 0; i < NUM_ECC_DIGITS; ++i) {
+		p_vli[i] = 0;
+	}
+}
+
+/* Returns nonzero if bit p_bit of p_vli is set. */
+static uint32_t vli_testBit(uint32_t *p_vli, uint32_t p_bit)
+{
+	return (p_vli[p_bit / 32] & (1 << (p_bit % 32)));
+}
+
+uint32_t vli_isZero(uint32_t *p_vli)
+{
+	uint32_t acc = 0;
+
+	for (uint32_t i = 0; i < NUM_ECC_DIGITS; ++i) {
+		acc |= p_vli[i];
+	}
+
+	return (!acc);
+}
+
+/*
+ * Find the right-most nonzero 32-bit "digits" in p_vli.
+ *
+ * Side-channel countermeasure: algorithm strengthened against timing attack.
+ */
+static uint32_t vli_numDigits(uint32_t *p_vli)
+{
+	int32_t i;
+	uint32_t digits = 0;
+
+	for (i = NUM_ECC_DIGITS - 1; i >= 0 ; --i) {
+		digits += p_vli[i] || digits;
+	}
+
+	return digits;
+}
+
+/*
+ * Find the left-most non-zero bit in p_vli.
+ *
+ * Side-channel countermeasure: algorithm strengthened against timing attack.
+ */
+static uint32_t vli_numBits(uint32_t *p_vli)
+{
+	uint32_t l_digit;
+	uint32_t i, acc = 32;
+	uint32_t l_numDigits = vli_numDigits(p_vli);
+
+	l_digit = p_vli[l_numDigits - 1];
+
+	for (i = 0; i < 32; ++i) {
+		acc -= !l_digit;
+		l_digit >>= 1;
+	}
+
+	return ((l_numDigits - 1) * 32 + acc);
+}
+
+/*
+ * Computes p_result = p_left + p_right, returns carry.
+ *
+ * Side-channel countermeasure: algorithm strengthened against timing attack.
+ */
+static uint32_t vli_add(uint32_t *p_result, uint32_t *p_left,
+			uint32_t *p_right)
+{
+
+	uint32_t l_carry = 0;
+
+	for (uint32_t i = 0; i < NUM_ECC_DIGITS; ++i) {
+		uint32_t l_sum = p_left[i] + p_right[i] + l_carry;
+
+		l_carry = (l_sum < p_left[i]) | ((l_sum == p_left[i]) && l_carry);
+		p_result[i] = l_sum;
+	}
+
+	return l_carry;
+}
+
+
+/* Computes p_result = p_left * p_right. */
+static void vli_mult(uint32_t *p_result, uint32_t *p_left,
+		     uint32_t *p_right, uint32_t word_size)
+{
+
+	uint64_t r01 = 0;
+	uint32_t r2 = 0;
+
+	/* Compute each digit of p_result in sequence, maintaining the carries. */
+	for (uint32_t k = 0; k < word_size*2 - 1; ++k) {
+
+		uint32_t l_min = (k < word_size ? 0 : (k + 1) - word_size);
+
+		for (uint32_t i = l_min; i <= k && i < word_size; ++i) {
+
+			uint64_t l_product = (uint64_t)p_left[i] * p_right[k - i];
+
+			r01 += l_product;
+			r2 += (r01 < l_product);
+		}
+		p_result[k] = (uint32_t)r01;
+		r01 = (r01 >> 32) | (((uint64_t)r2) << 32);
+		r2 = 0;
+	}
+
+	p_result[word_size * 2 - 1] = (uint32_t)r01;
+}
+
+/* Computes p_result = p_left^2. */
+static void vli_square(uint32_t *p_result, uint32_t *p_left)
+{
+
+	uint64_t r01 = 0;
+	uint32_t r2 = 0;
+	uint32_t i, k;
+
+	for (k = 0; k < NUM_ECC_DIGITS * 2 - 1; ++k) {
+
+		uint32_t l_min = (k < NUM_ECC_DIGITS ? 0 : (k + 1) - NUM_ECC_DIGITS);
+
+		for (i = l_min; i <= k && i <= k - i; ++i) {
+
+			uint64_t l_product = (uint64_t)p_left[i] * p_left[k - i];
+
+			if (i < k - i) {
+
+				r2 += l_product >> 63;
+				l_product *= 2;
+			}
+			r01 += l_product;
+			r2 += (r01 < l_product);
+		}
+		p_result[k] = (uint32_t)r01;
+		r01 = (r01 >> 32) | (((uint64_t)r2) << 32);
+		r2 = 0;
+	}
+
+	p_result[NUM_ECC_DIGITS * 2 - 1] = (uint32_t)r01;
+}
+
+/* Computes p_result = p_product % curve_p using Barrett reduction. */
+static void vli_mmod_barrett(uint32_t *p_result, uint32_t *p_product,
+			     uint32_t *p_mod, uint32_t *p_barrett)
+{
+	uint32_t i;
+	uint32_t q1[NUM_ECC_DIGITS + 1];
+
+	for (i = NUM_ECC_DIGITS - 1; i < 2 * NUM_ECC_DIGITS; i++) {
+		q1[i - (NUM_ECC_DIGITS - 1)] = p_product[i];
+	}
+
+	uint32_t q2[2*NUM_ECC_DIGITS + 2];
+
+	vli_mult(q2, q1, p_barrett, NUM_ECC_DIGITS + 1);
+	for (i = NUM_ECC_DIGITS + 1; i < 2 * NUM_ECC_DIGITS + 2; i++) {
+		q1[i - (NUM_ECC_DIGITS + 1)] = q2[i];
+	}
+
+	uint32_t prime2[2*NUM_ECC_DIGITS];
+
+	for (i = 0; i < NUM_ECC_DIGITS; i++) {
+		prime2[i] = p_mod[i];
+		prime2[NUM_ECC_DIGITS + i] = 0;
+	}
+
+	vli_mult(q2, q1, prime2, NUM_ECC_DIGITS + 1);
+	vli_sub(p_product, p_product, q2, 2 * NUM_ECC_DIGITS);
+
+	uint32_t borrow;
+
+	borrow = vli_sub(q1, p_product, prime2, NUM_ECC_DIGITS + 1);
+	vli_cond_set(p_product, p_product, q1, borrow);
+	p_product[NUM_ECC_DIGITS] = q1[NUM_ECC_DIGITS] * (!borrow);
+	borrow = vli_sub(q1, p_product, prime2, NUM_ECC_DIGITS + 1);
+	vli_cond_set(p_product, p_product, q1, borrow);
+	p_product[NUM_ECC_DIGITS] = q1[NUM_ECC_DIGITS] * (!borrow);
+	borrow = vli_sub(q1, p_product, prime2, NUM_ECC_DIGITS + 1);
+	vli_cond_set(p_product, p_product, q1, borrow);
+	p_product[NUM_ECC_DIGITS] = q1[NUM_ECC_DIGITS] * (!borrow);
+
+	for (i = 0; i < NUM_ECC_DIGITS; i++) {
+		p_result[i] = p_product[i];
+	}
+}
+
+/*
+ * Computes modular exponentiation.
+ *
+ * Side-channel countermeasure: algorithm strengthened against timing attack.
+ */
+static void vli_modExp(uint32_t *p_result, uint32_t *p_base,
+		       uint32_t *p_exp, uint32_t *p_mod, uint32_t *p_barrett)
+{
+
+	uint32_t acc[NUM_ECC_DIGITS], tmp[NUM_ECC_DIGITS], product[2 * NUM_ECC_DIGITS];
+	uint32_t j;
+	int32_t i;
+
+	vli_clear(acc);
+	acc[0] = 1;
+
+	for (i = NUM_ECC_DIGITS - 1; i >= 0; i--) {
+		for (j = 1 << 31; j > 0; j = j >> 1) {
+			vli_square(product, acc);
+			vli_mmod_barrett(acc, product, p_mod, p_barrett);
+			vli_mult(product, acc, p_base, NUM_ECC_DIGITS);
+			vli_mmod_barrett(tmp, product, p_mod, p_barrett);
+			vli_cond_set(acc, tmp, acc, j & p_exp[i]);
+		}
+	}
+
+	vli_set(p_result, acc);
+}
+
+/* Conversion from Affine coordinates to Jacobi coordinates. */
+static void EccPoint_fromAffine(EccPointJacobi *p_point_jacobi,
+	EccPoint *p_point) {
+
+	vli_set(p_point_jacobi->X, p_point->x);
+	vli_set(p_point_jacobi->Y, p_point->y);
+	vli_clear(p_point_jacobi->Z);
+	p_point_jacobi->Z[0] = 1;
+}
+
+/*
+ * Elliptic curve point doubling in Jacobi coordinates: P = P + P.
+ *
+ * Requires 4 squares and 4 multiplications.
+ */
+static void EccPoint_double(EccPointJacobi *P)
+{
+
+	uint32_t m[NUM_ECC_DIGITS], s[NUM_ECC_DIGITS], t[NUM_ECC_DIGITS];
+
+	vli_modSquare_fast(t, P->Z);
+	vli_modSub(m, P->X, t, curve_p);
+	vli_modAdd(s, P->X, t, curve_p);
+	vli_modMult_fast(m, m, s);
+	vli_modAdd(s, m, m, curve_p);
+	vli_modAdd(m, s, m, curve_p); /* m = 3X^2 - 3Z^4 */
+	vli_modSquare_fast(t, P->Y);
+	vli_modMult_fast(s, P->X, t);
+	vli_modAdd(s, s, s, curve_p);
+	vli_modAdd(s, s, s, curve_p); /* s = 4XY^2 */
+	vli_modMult_fast(P->Z, P->Y, P->Z);
+	vli_modAdd(P->Z, P->Z, P->Z, curve_p); /* Z' = 2YZ */
+	vli_modSquare_fast(P->X, m);
+	vli_modSub(P->X, P->X, s, curve_p);
+	vli_modSub(P->X, P->X, s, curve_p); /* X' = m^2 - 2s */
+	vli_modSquare_fast(P->Y, t);
+	vli_modAdd(P->Y, P->Y, P->Y, curve_p);
+	vli_modAdd(P->Y, P->Y, P->Y, curve_p);
+	vli_modAdd(P->Y, P->Y, P->Y, curve_p);
+	vli_modSub(t, s, P->X, curve_p);
+	vli_modMult_fast(t, t, m);
+	vli_modSub(P->Y, t, P->Y, curve_p); /* Y' = m(s - X') - 8Y^4 */
+
+}
+
+/* Copy input to target. */
+static void EccPointJacobi_set(EccPointJacobi *target, EccPointJacobi *input)
+{
+	vli_set(target->X, input->X);
+	vli_set(target->Y, input->Y);
+	vli_set(target->Z, input->Z);
+}
+
+/* ------ Externally visible functions (see header file for comments): ------ */
+
+void vli_set(uint32_t *p_dest, uint32_t *p_src)
+{
+
+	uint32_t i;
+
+	for (i = 0; i < NUM_ECC_DIGITS; ++i) {
+		p_dest[i] = p_src[i];
+	}
+}
+
+int32_t vli_cmp(uint32_t *p_left, uint32_t *p_right, int32_t word_size)
+{
+
+	int32_t i, cmp = 0;
+
+	for (i = word_size-1; i >= 0; --i) {
+		cmp |= ((p_left[i] > p_right[i]) - (p_left[i] < p_right[i])) * (!cmp);
+	}
+
+	return cmp;
+}
+
+uint32_t vli_sub(uint32_t *p_result, uint32_t *p_left, uint32_t *p_right,
+	uint32_t word_size)
+{
+
+	uint32_t l_borrow = 0;
+
+	for (uint32_t i = 0; i < word_size; ++i) {
+		uint32_t l_diff = p_left[i] - p_right[i] - l_borrow;
+
+		l_borrow = (l_diff > p_left[i]) | ((l_diff == p_left[i]) && l_borrow);
+		p_result[i] = l_diff;
+	}
+
+	return l_borrow;
+}
+
+void vli_cond_set(uint32_t *output, uint32_t *p_true, uint32_t *p_false,
+	uint32_t cond)
+{
+	uint32_t i;
+
+	cond = (!cond);
+
+	for (i = 0; i < NUM_ECC_DIGITS; i++) {
+		output[i] = (p_true[i]*(!cond)) | (p_false[i]*cond);
+	}
+}
+
+void vli_modAdd(uint32_t *p_result, uint32_t *p_left, uint32_t *p_right,
+	uint32_t *p_mod)
+{
+	uint32_t l_carry = vli_add(p_result, p_left, p_right);
+	uint32_t p_temp[NUM_ECC_DIGITS];
+
+	l_carry = l_carry == vli_sub(p_temp, p_result, p_mod, NUM_ECC_DIGITS);
+	vli_cond_set(p_result, p_temp, p_result, l_carry);
+}
+
+void vli_modSub(uint32_t *p_result, uint32_t *p_left, uint32_t *p_right,
+	uint32_t *p_mod)
+{
+	uint32_t l_borrow = vli_sub(p_result, p_left, p_right, NUM_ECC_DIGITS);
+	uint32_t p_temp[NUM_ECC_DIGITS];
+
+	vli_add(p_temp, p_result, p_mod);
+	vli_cond_set(p_result, p_temp, p_result, l_borrow);
+}
+
+void vli_modMult_fast(uint32_t *p_result, uint32_t *p_left,
+	uint32_t *p_right)
+{
+	uint32_t l_product[2 * NUM_ECC_DIGITS];
+
+	vli_mult(l_product, p_left, p_right, NUM_ECC_DIGITS);
+	vli_mmod_barrett(p_result, l_product, curve_p, curve_pb);
+}
+
+void vli_modSquare_fast(uint32_t *p_result, uint32_t *p_left)
+{
+	uint32_t l_product[2 * NUM_ECC_DIGITS];
+
+	vli_square(l_product, p_left);
+	vli_mmod_barrett(p_result, l_product, curve_p, curve_pb);
+}
+
+void vli_modMult(uint32_t *p_result, uint32_t *p_left, uint32_t *p_right,
+		 uint32_t *p_mod, uint32_t *p_barrett)
+{
+
+	uint32_t l_product[2 * NUM_ECC_DIGITS];
+
+	vli_mult(l_product, p_left, p_right, NUM_ECC_DIGITS);
+	vli_mmod_barrett(p_result, l_product, p_mod, p_barrett);
+}
+
+void vli_modInv(uint32_t *p_result, uint32_t *p_input, uint32_t *p_mod,
+	uint32_t *p_barrett)
+{
+	uint32_t p_power[NUM_ECC_DIGITS];
+
+	vli_set(p_power, p_mod);
+	p_power[0] -= 2;
+	vli_modExp(p_result, p_input, p_power, p_mod, p_barrett);
+}
+
+uint32_t EccPoint_isZero(EccPoint *p_point)
+{
+	return (vli_isZero(p_point->x) && vli_isZero(p_point->y));
+}
+
+uint32_t EccPointJacobi_isZero(EccPointJacobi *p_point_jacobi)
+{
+	return vli_isZero(p_point_jacobi->Z);
+}
+
+void EccPoint_toAffine(EccPoint *p_point, EccPointJacobi *p_point_jacobi)
+{
+
+	if (vli_isZero(p_point_jacobi->Z)) {
+		vli_clear(p_point->x);
+		vli_clear(p_point->y);
+		return;
+	}
+
+	uint32_t z[NUM_ECC_DIGITS];
+
+	vli_set(z, p_point_jacobi->Z);
+	vli_modInv(z, z, curve_p, curve_pb);
+	vli_modSquare_fast(p_point->x, z);
+	vli_modMult_fast(p_point->y, p_point->x, z);
+	vli_modMult_fast(p_point->x, p_point->x, p_point_jacobi->X);
+	vli_modMult_fast(p_point->y, p_point->y, p_point_jacobi->Y);
+}
+
+void EccPoint_add(EccPointJacobi *P1, EccPointJacobi *P2)
+{
+
+	uint32_t s1[NUM_ECC_DIGITS], u1[NUM_ECC_DIGITS], t[NUM_ECC_DIGITS];
+	uint32_t h[NUM_ECC_DIGITS], r[NUM_ECC_DIGITS];
+
+	vli_modSquare_fast(r, P1->Z);
+	vli_modSquare_fast(s1, P2->Z);
+	vli_modMult_fast(u1, P1->X, s1); /* u1 = X1 Z2^2 */
+	vli_modMult_fast(h, P2->X, r);
+	vli_modMult_fast(s1, P1->Y, s1);
+	vli_modMult_fast(s1, s1, P2->Z); /* s1 = Y1 Z2^3 */
+	vli_modMult_fast(r, P2->Y, r);
+	vli_modMult_fast(r, r, P1->Z);
+	vli_modSub(h, h, u1, curve_p); /* h = X2 Z1^2 - u1 */
+	vli_modSub(r, r, s1, curve_p); /* r = Y2 Z1^3 - s1 */
+
+	if (vli_isZero(h)) {
+		if (vli_isZero(r)) {
+			/* P1 = P2 */
+			EccPoint_double(P1);
+			return;
+		}
+		/* point at infinity */
+		vli_clear(P1->Z);
+		return;
+	}
+
+	vli_modMult_fast(P1->Z, P1->Z, P2->Z);
+	vli_modMult_fast(P1->Z, P1->Z, h); /* Z3 = h Z1 Z2 */
+	vli_modSquare_fast(t, h);
+	vli_modMult_fast(h, t, h);
+	vli_modMult_fast(u1, u1, t);
+	vli_modSquare_fast(P1->X, r);
+	vli_modSub(P1->X, P1->X, h, curve_p);
+	vli_modSub(P1->X, P1->X, u1, curve_p);
+	vli_modSub(P1->X, P1->X, u1, curve_p); /* X3 = r^2 - h^3 - 2 u1 h^2 */
+	vli_modMult_fast(t, s1, h);
+	vli_modSub(P1->Y, u1, P1->X, curve_p);
+	vli_modMult_fast(P1->Y, P1->Y, r);
+	vli_modSub(P1->Y, P1->Y, t, curve_p); /* Y3 = r(u1 h^2 - X3) - s1 h^3 */
+}
+
+/*
+ * Elliptic curve scalar multiplication with result in Jacobi coordinates:
+ *
+ * p_result = p_scalar * p_point.
+ */
+void EccPoint_mult(EccPointJacobi *p_result, EccPoint *p_point, uint32_t *p_scalar)
+{
+
+	int32_t i;
+	uint32_t bit;
+	EccPointJacobi p_point_jacobi, p_tmp;
+
+	EccPoint_fromAffine(p_result, p_point);
+	EccPoint_fromAffine(&p_point_jacobi, p_point);
+
+	for (i = vli_numBits(p_scalar) - 2; i >= 0; i--) {
+		EccPoint_double(p_result);
+		EccPointJacobi_set(&p_tmp, p_result);
+		EccPoint_add(&p_tmp, &p_point_jacobi);
+		bit = vli_testBit(p_scalar, i);
+		vli_cond_set(p_result->X, p_tmp.X, p_result->X, bit);
+		vli_cond_set(p_result->Y, p_tmp.Y, p_result->Y, bit);
+		vli_cond_set(p_result->Z, p_tmp.Z, p_result->Z, bit);
+	}
+}
+
+/* -------- Conversions between big endian and little endian: -------- */
+
+void ecc_bytes2native(uint32_t p_native[NUM_ECC_DIGITS],
+		      uint8_t p_bytes[NUM_ECC_DIGITS * 4])
+{
+
+	uint32_t i;
+
+	for (i = 0; i < NUM_ECC_DIGITS; ++i) {
+		uint8_t *p_digit = p_bytes + 4 * (NUM_ECC_DIGITS - 1 - i);
+
+		p_native[i] = ((uint32_t)p_digit[0] << 24) |
+			((uint32_t)p_digit[1] << 16) |
+			((uint32_t)p_digit[2] << 8) |
+			(uint32_t)p_digit[3];
+	}
+}
+
+void ecc_native2bytes(uint8_t p_bytes[NUM_ECC_DIGITS * 4],
+	uint32_t p_native[NUM_ECC_DIGITS])
+{
+
+	uint32_t i;
+
+	for (i = 0; i < NUM_ECC_DIGITS; ++i) {
+		uint8_t *p_digit = p_bytes + 4 * (NUM_ECC_DIGITS - 1 - i);
+
+		p_digit[0] = p_native[i] >> 24;
+		p_digit[1] = p_native[i] >> 16;
+		p_digit[2] = p_native[i] >> 8;
+		p_digit[3] = p_native[i];
+	}
+}
+

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/ecc_dh.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/ecc_dh.c b/crypto/tinycrypt/src/ecc_dh.c
new file mode 100644
index 0000000..965394b
--- /dev/null
+++ b/crypto/tinycrypt/src/ecc_dh.c
@@ -0,0 +1,123 @@
+/* ec_dh.c - TinyCrypt implementation of EC-DH */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <tinycrypt/constants.h>
+#include <tinycrypt/ecc.h>
+
+extern uint32_t curve_p[NUM_ECC_DIGITS];
+extern uint32_t curve_b[NUM_ECC_DIGITS];
+extern uint32_t curve_n[NUM_ECC_DIGITS];
+extern EccPoint curve_G;
+
+int32_t ecc_make_key(EccPoint *p_publicKey, uint32_t p_privateKey[NUM_ECC_DIGITS],
+		     uint32_t p_random[NUM_ECC_DIGITS])
+{
+
+	/* Make sure the private key is in the range [1, n-1].
+	 * For the supported curve, n is always large enough
+	 * that we only need to subtract once at most.
+	 */
+	uint32_t p_tmp[NUM_ECC_DIGITS];
+
+	vli_set(p_privateKey, p_random);
+	vli_sub(p_tmp, p_privateKey, curve_n, NUM_ECC_DIGITS);
+
+	vli_cond_set(p_privateKey, p_privateKey, p_tmp,
+		     vli_cmp(curve_n, p_privateKey, NUM_ECC_DIGITS) == 1);
+
+	if (vli_isZero(p_privateKey)) {
+		return TC_CRYPTO_FAIL; /* The private key cannot be 0 (mod p). */
+	}
+
+	EccPointJacobi P;
+
+	EccPoint_mult(&P, &curve_G, p_privateKey);
+	EccPoint_toAffine(p_publicKey, &P);
+
+	return TC_CRYPTO_SUCCESS;
+}
+
+/* Compute p_result = x^3 - 3x + b */
+static void curve_x_side(uint32_t p_result[NUM_ECC_DIGITS],
+			 uint32_t x[NUM_ECC_DIGITS])
+{
+
+	uint32_t _3[NUM_ECC_DIGITS] = {3}; /* -a = 3 */
+
+	vli_modSquare_fast(p_result, x); /* r = x^2 */
+	vli_modSub(p_result, p_result, _3, curve_p); /* r = x^2 - 3 */
+	vli_modMult_fast(p_result, p_result, x); /* r = x^3 - 3x */
+	vli_modAdd(p_result, p_result, curve_b, curve_p); /* r = x^3 - 3x + b */
+
+}
+
+int32_t ecc_valid_public_key(EccPoint *p_publicKey)
+{
+	uint32_t l_tmp1[NUM_ECC_DIGITS];
+	uint32_t l_tmp2[NUM_ECC_DIGITS];
+
+	if (EccPoint_isZero(p_publicKey)) {
+		return -1;
+	}
+
+	if ((vli_cmp(curve_p, p_publicKey->x, NUM_ECC_DIGITS) != 1) ||
+	   (vli_cmp(curve_p, p_publicKey->y, NUM_ECC_DIGITS) != 1)) {
+		return -2;
+	}
+
+	vli_modSquare_fast(l_tmp1, p_publicKey->y); /* tmp1 = y^2 */
+
+	curve_x_side(l_tmp2, p_publicKey->x); /* tmp2 = x^3 - 3x + b */
+
+	/* Make sure that y^2 == x^3 + ax + b */
+	if (vli_cmp(l_tmp1, l_tmp2, NUM_ECC_DIGITS) != 0) {
+		return -3;
+	}
+
+	return 0;
+}
+
+int32_t ecdh_shared_secret(uint32_t p_secret[NUM_ECC_DIGITS],
+			   EccPoint *p_publicKey, uint32_t p_privateKey[NUM_ECC_DIGITS])
+{
+
+	EccPoint p_point;
+	EccPointJacobi P;
+
+	EccPoint_mult(&P, p_publicKey, p_privateKey);
+	if (EccPointJacobi_isZero(&P)) {
+		return TC_CRYPTO_FAIL;
+	}
+	EccPoint_toAffine(&p_point, &P);
+	vli_set(p_secret, p_point.x);
+
+	return TC_CRYPTO_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/ecc_dsa.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/ecc_dsa.c b/crypto/tinycrypt/src/ecc_dsa.c
new file mode 100644
index 0000000..8636fa1
--- /dev/null
+++ b/crypto/tinycrypt/src/ecc_dsa.c
@@ -0,0 +1,117 @@
+/* ec_dsa.c - TinyCrypt implementation of EC-DSA */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tinycrypt/constants.h>
+#include <tinycrypt/ecc.h>
+
+extern uint32_t curve_n[NUM_ECC_DIGITS];
+extern EccPoint curve_G;
+extern uint32_t curve_nb[NUM_ECC_DIGITS + 1];
+
+int32_t ecdsa_sign(uint32_t r[NUM_ECC_DIGITS], uint32_t s[NUM_ECC_DIGITS],
+		   uint32_t p_privateKey[NUM_ECC_DIGITS], uint32_t p_random[NUM_ECC_DIGITS],
+		   uint32_t p_hash[NUM_ECC_DIGITS])
+{
+
+	uint32_t k[NUM_ECC_DIGITS], tmp[NUM_ECC_DIGITS];
+	EccPoint p_point;
+	EccPointJacobi P;
+
+	if (vli_isZero(p_random)) {
+		return TC_CRYPTO_FAIL; /* The random number must not be 0. */
+	}
+
+	vli_set(k, p_random);
+
+	vli_sub(tmp, k, curve_n, NUM_ECC_DIGITS);
+	vli_cond_set(k, k, tmp, vli_cmp(curve_n, k, NUM_ECC_DIGITS) == 1);
+
+	/* tmp = k * G */
+	EccPoint_mult(&P, &curve_G, k);
+	EccPoint_toAffine(&p_point, &P);
+
+	/* r = x1 (mod n) */
+	vli_set(r, p_point.x);
+	if (vli_cmp(curve_n, r, NUM_ECC_DIGITS) != 1) {
+		vli_sub(r, r, curve_n, NUM_ECC_DIGITS);
+	}
+
+	if (vli_isZero(r)) {
+		return TC_CRYPTO_FAIL; /* If r == 0, fail (need a different random number). */
+	}
+
+	vli_modMult(s, r, p_privateKey, curve_n, curve_nb); /* s = r*d */
+	vli_modAdd(s, p_hash, s, curve_n); /* s = e + r*d */
+	vli_modInv(k, k, curve_n, curve_nb); /* k = 1 / k */
+	vli_modMult(s, s, k, curve_n, curve_nb); /* s = (e + r*d) / k */
+
+	return TC_CRYPTO_SUCCESS;
+}
+
+int32_t ecdsa_verify(EccPoint *p_publicKey, uint32_t p_hash[NUM_ECC_DIGITS],
+		     uint32_t r[NUM_ECC_DIGITS], uint32_t s[NUM_ECC_DIGITS])
+{
+
+	uint32_t u1[NUM_ECC_DIGITS], u2[NUM_ECC_DIGITS];
+	uint32_t z[NUM_ECC_DIGITS];
+	EccPointJacobi P, R;
+	EccPoint p_point;
+
+	if (vli_isZero(r) || vli_isZero(s)) {
+		return TC_CRYPTO_FAIL; /* r, s must not be 0. */
+	}
+
+	if ((vli_cmp(curve_n, r, NUM_ECC_DIGITS) != 1) ||
+	   (vli_cmp(curve_n, s, NUM_ECC_DIGITS) != 1)) {
+		return TC_CRYPTO_FAIL; /* r, s must be < n. */
+	}
+
+	/* Calculate u1 and u2. */
+	vli_modInv(z, s, curve_n, curve_nb); /* Z = s^-1 */
+	vli_modMult(u1, p_hash, z, curve_n, curve_nb); /* u1 = e/s */
+	vli_modMult(u2, r, z, curve_n, curve_nb); /* u2 = r/s */
+
+	/* calculate P = u1*G + u2*Q */
+	EccPoint_mult(&P, &curve_G, u1);
+	EccPoint_mult(&R, p_publicKey, u2);
+	EccPoint_add(&P, &R);
+	EccPoint_toAffine(&p_point, &P);
+
+	/* Accept only if P.x == r. */
+	vli_cond_set(
+		p_point.x,
+		p_point.x,
+		z,
+		vli_sub(z, p_point.x, curve_n, NUM_ECC_DIGITS));
+
+	return (vli_cmp(p_point.x, r, NUM_ECC_DIGITS) == 0);
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/hmac.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/hmac.c b/crypto/tinycrypt/src/hmac.c
new file mode 100644
index 0000000..b9af4a6
--- /dev/null
+++ b/crypto/tinycrypt/src/hmac.c
@@ -0,0 +1,149 @@
+/* hmac.c - TinyCrypt implementation of the HMAC algorithm */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tinycrypt/hmac.h>
+#include <tinycrypt/constants.h>
+#include <tinycrypt/utils.h>
+
+static void rekey(uint8_t *key, const uint8_t *new_key, uint32_t key_size)
+{
+	const uint8_t inner_pad = (uint8_t) 0x36;
+	const uint8_t outer_pad = (uint8_t) 0x5c;
+	uint32_t i;
+
+	for (i = 0; i < key_size; ++i) {
+		key[i] = inner_pad ^ new_key[i];
+		key[i + TC_SHA256_BLOCK_SIZE] = outer_pad ^ new_key[i];
+	}
+	for (; i < TC_SHA256_BLOCK_SIZE; ++i) {
+		key[i] = inner_pad; key[i + TC_SHA256_BLOCK_SIZE] = outer_pad;
+	}
+}
+
+int32_t tc_hmac_set_key(TCHmacState_t ctx,
+			const uint8_t *key,
+			uint32_t key_size)
+{
+	/* input sanity check: */
+	if (ctx == (TCHmacState_t) 0 ||
+	    key == (const uint8_t *) 0 ||
+	    key_size == 0) {
+		return TC_FAIL;
+	}
+
+	const uint8_t dummy_key[key_size];
+	struct tc_hmac_state_struct dummy_state;
+
+	if (key_size <= TC_SHA256_BLOCK_SIZE) {
+		/*
+		 * The next three lines consist of dummy calls just to avoid
+		 * certain timing attacks. Without these dummy calls,
+		 * adversaries would be able to learn whether the key_size is
+		 * greater than TC_SHA256_BLOCK_SIZE by measuring the time
+		 * consumed in this process.
+		 */
+		(void)tc_sha256_init(&dummy_state.hash_state);
+		(void)tc_sha256_update(&dummy_state.hash_state,
+				       dummy_key,
+				       key_size);
+		(void)tc_sha256_final(&dummy_state.key[TC_SHA256_DIGEST_SIZE],
+				      &dummy_state.hash_state);
+
+		/* Actual code for when key_size <= TC_SHA256_BLOCK_SIZE: */
+		rekey(ctx->key, key, key_size);
+	} else {
+		(void)tc_sha256_init(&ctx->hash_state);
+		(void)tc_sha256_update(&ctx->hash_state, key, key_size);
+		(void)tc_sha256_final(&ctx->key[TC_SHA256_DIGEST_SIZE],
+				      &ctx->hash_state);
+		rekey(ctx->key,
+		      &ctx->key[TC_SHA256_DIGEST_SIZE],
+		      TC_SHA256_DIGEST_SIZE);
+	}
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_hmac_init(TCHmacState_t ctx)
+{
+	/* input sanity check: */
+	if (ctx == (TCHmacState_t) 0 ||
+	    ctx->key == (uint8_t *) 0) {
+		return TC_FAIL;
+	}
+
+	(void)tc_sha256_init(&ctx->hash_state);
+	(void)tc_sha256_update(&ctx->hash_state,
+			       ctx->key,
+			       TC_SHA256_BLOCK_SIZE);
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_hmac_update(TCHmacState_t ctx,
+		       const void *data,
+		       uint32_t data_length)
+{
+	/* input sanity check: */
+	if (ctx == (TCHmacState_t) 0 || ctx->key == (uint8_t *) 0) {
+		return TC_FAIL;
+	}
+
+	(void)tc_sha256_update(&ctx->hash_state, data, data_length);
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_hmac_final(uint8_t *tag, uint32_t taglen, TCHmacState_t ctx)
+{
+	/* input sanity check: */
+	if (tag == (uint8_t *) 0 ||
+	    taglen != TC_SHA256_DIGEST_SIZE ||
+	    ctx == (TCHmacState_t) 0 ||
+	    ctx->key == (uint8_t *) 0) {
+		return TC_FAIL;
+	}
+
+	(void) tc_sha256_final(tag, &ctx->hash_state);
+
+	(void)tc_sha256_init(&ctx->hash_state);
+	(void)tc_sha256_update(&ctx->hash_state,
+			       &ctx->key[TC_SHA256_BLOCK_SIZE],
+				TC_SHA256_BLOCK_SIZE);
+	(void)tc_sha256_update(&ctx->hash_state, tag, TC_SHA256_DIGEST_SIZE);
+	(void)tc_sha256_final(tag, &ctx->hash_state);
+
+	/* destroy the current state */
+	_set(ctx, 0, sizeof(*ctx));
+
+	return TC_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/hmac_prng.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/hmac_prng.c b/crypto/tinycrypt/src/hmac_prng.c
new file mode 100644
index 0000000..c24c37e
--- /dev/null
+++ b/crypto/tinycrypt/src/hmac_prng.c
@@ -0,0 +1,210 @@
+/* Hmac_prng.c - TinyCrypt implementation of HMAC-PRNG */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tinycrypt/hmac_prng.h>
+#include <tinycrypt/hmac.h>
+#include <tinycrypt/constants.h>
+#include <tinycrypt/utils.h>
+
+/*
+ * min bytes in the seed string.
+ * MIN_SLEN*8 must be at least the expected security level.
+ */
+static const uint32_t MIN_SLEN = 32;
+
+/*
+ * max bytes in the seed string;
+ * SP800-90A specifies a maximum of 2^35 bits (i.e., 2^32 bytes).
+ */
+static const uint32_t MAX_SLEN = UINT32_MAX;
+
+/*
+ * max bytes in the personalization string;
+ * SP800-90A specifies a maximum of 2^35 bits (i.e., 2^32 bytes).
+ */
+static const uint32_t MAX_PLEN = UINT32_MAX;
+
+/*
+ * max bytes in the additional_info string;
+ * SP800-90A specifies a maximum of 2^35 bits (i.e., 2^32 bytes).
+ */
+static const uint32_t MAX_ALEN = UINT32_MAX;
+
+/*
+ * max number of generates between re-seeds;
+ * TinyCrypt accepts up to (2^32 - 1) which is the maximal value of
+ * a uint32_t variable, while SP800-90A specifies a maximum of 2^48.
+ */
+static const uint32_t MAX_GENS = UINT32_MAX;
+
+/*
+ * maximum bytes per generate call;
+ * SP800-90A specifies a maximum up to 2^19.
+ */
+static const uint32_t MAX_OUT = (1 << 19);
+
+/*
+ * Assumes: prng != NULL, e != NULL, len >= 0.
+ */
+static void update(TCHmacPrng_t prng, const uint8_t *e, uint32_t len)
+{
+	const uint8_t separator0 = 0x00;
+	const uint8_t separator1 = 0x01;
+
+	/* use current state, e and separator 0 to compute a new prng key: */
+	(void)tc_hmac_init(&prng->h);
+	(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
+	(void)tc_hmac_update(&prng->h, &separator0, sizeof(separator0));
+	(void)tc_hmac_update(&prng->h, e, len);
+	(void)tc_hmac_final(prng->key, sizeof(prng->key), &prng->h);
+	/* configure the new prng key into the prng's instance of hmac */
+	(void)tc_hmac_set_key(&prng->h, prng->key, sizeof(prng->key));
+
+	/* use the new key to compute a new state variable v */
+	(void)tc_hmac_init(&prng->h);
+	(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
+	(void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h);
+
+	/* use current state, e and separator 1 to compute a new prng key: */
+	(void)tc_hmac_init(&prng->h);
+	(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
+	(void)tc_hmac_update(&prng->h, &separator1, sizeof(separator1));
+	(void)tc_hmac_update(&prng->h, e, len);
+	(void)tc_hmac_final(prng->key, sizeof(prng->key), &prng->h);
+	/* configure the new prng key into the prng's instance of hmac */
+	(void)tc_hmac_set_key(&prng->h, prng->key, sizeof(prng->key));
+
+	/* use the new key to compute a new state variable v */
+	(void)tc_hmac_init(&prng->h);
+	(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
+	(void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h);
+}
+
+int32_t tc_hmac_prng_init(TCHmacPrng_t prng,
+			  const uint8_t *personalization,
+			  uint32_t plen)
+{
+	/* input sanity check: */
+	if (prng == (TCHmacPrng_t) 0 ||
+	    personalization == (uint8_t *) 0 ||
+	    plen > MAX_PLEN) {
+		return TC_FAIL;
+	}
+
+	/* put the generator into a known state: */
+	_set(prng->key, 0x00, sizeof(prng->key));
+	_set(prng->v, 0x01, sizeof(prng->v));
+	tc_hmac_set_key(&prng->h, prng->key, sizeof(prng->key));
+	/* update assumes SOME key has been configured into HMAC */
+
+	update(prng, personalization, plen);
+
+	/* force a reseed before allowing tc_hmac_prng_generate to succeed: */
+	prng->countdown = 0;
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng,
+			    const uint8_t *seed,
+			    uint32_t seedlen,
+			    const uint8_t *additional_input,
+			    uint32_t additionallen)
+{
+	/* input sanity check: */
+	if (prng == (TCHmacPrng_t) 0 ||
+	    seed == (const uint8_t *) 0 ||
+	    seedlen < MIN_SLEN ||
+	    seedlen > MAX_SLEN) {
+		return TC_FAIL;
+	}
+
+	if (additional_input != (const uint8_t *) 0) {
+		/*
+		 * Abort if additional_input is provided but has inappropriate
+		 * length
+		 */
+		if (additionallen == 0 ||
+		    additionallen > MAX_ALEN) {
+			return TC_FAIL;
+		} else {
+		/* call update for the seed and additional_input */
+		update(prng, seed, seedlen);
+		update(prng, additional_input, additionallen);
+		}
+	} else {
+		/* call update only for the seed */
+		update(prng, seed, seedlen);
+	}
+
+	/* ... and enable hmac_prng_generate */
+	prng->countdown = MAX_GENS;
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_hmac_prng_generate(uint8_t *out, uint32_t outlen, TCHmacPrng_t prng)
+{
+	uint32_t bufferlen;
+
+	/* input sanity check: */
+	if (out == (uint8_t *) 0 ||
+	    prng == (TCHmacPrng_t) 0 ||
+	    outlen == 0 ||
+	    outlen > MAX_OUT) {
+		return TC_FAIL;
+	} else if (prng->countdown == 0) {
+		return TC_HMAC_PRNG_RESEED_REQ;
+	}
+
+	prng->countdown--;
+
+	while (outlen != 0) {
+		/* operate HMAC in OFB mode to create "random" outputs */
+		(void)tc_hmac_init(&prng->h);
+		(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
+		(void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h);
+
+		bufferlen = (TC_SHA256_DIGEST_SIZE > outlen) ?
+			outlen : TC_SHA256_DIGEST_SIZE;
+		(void)_copy(out, bufferlen, prng->v, bufferlen);
+
+		out += bufferlen;
+		outlen = (outlen > TC_SHA256_DIGEST_SIZE) ?
+			(outlen - TC_SHA256_DIGEST_SIZE) : 0;
+	}
+
+	/* block future PRNG compromises from revealing past state */
+	update(prng, prng->v, TC_SHA256_DIGEST_SIZE);
+
+	return TC_SUCCESS;
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/sha256.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/sha256.c b/crypto/tinycrypt/src/sha256.c
new file mode 100644
index 0000000..1dced76
--- /dev/null
+++ b/crypto/tinycrypt/src/sha256.c
@@ -0,0 +1,219 @@
+/* sha256.c - TinyCrypt SHA-256 crypto hash algorithm implementation */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tinycrypt/sha256.h>
+#include <tinycrypt/constants.h>
+#include <tinycrypt/utils.h>
+
+static void compress(uint32_t *iv, const uint8_t *data);
+
+int32_t tc_sha256_init(TCSha256State_t s)
+{
+	/* input sanity check: */
+	if (s == (TCSha256State_t) 0) {
+		return TC_FAIL;
+	}
+
+	/*
+	 * Setting the initial state values.
+	 * These values correspond to the first 32 bits of the fractional parts
+	 * of the square roots of the first 8 primes: 2, 3, 5, 7, 11, 13, 17
+	 * and 19.
+	 */
+	_set((uint8_t *) s, 0x00, sizeof(*s));
+	s->iv[0] = 0x6a09e667;
+	s->iv[1] = 0xbb67ae85;
+	s->iv[2] = 0x3c6ef372;
+	s->iv[3] = 0xa54ff53a;
+	s->iv[4] = 0x510e527f;
+	s->iv[5] = 0x9b05688c;
+	s->iv[6] = 0x1f83d9ab;
+	s->iv[7] = 0x5be0cd19;
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_sha256_update(TCSha256State_t s, const uint8_t *data, size_t datalen)
+{
+	/* input sanity check: */
+	if (s == (TCSha256State_t) 0 ||
+	    s->iv == (uint32_t *) 0 ||
+	    data == (void *) 0) {
+		return TC_FAIL;
+	} else if (datalen == 0) {
+		return TC_SUCCESS;
+	}
+
+	while (datalen-- > 0) {
+		s->leftover[s->leftover_offset++] = *(data++);
+		if (s->leftover_offset >= TC_SHA256_BLOCK_SIZE) {
+			compress(s->iv, s->leftover);
+			s->leftover_offset = 0;
+			s->bits_hashed += (TC_SHA256_BLOCK_SIZE << 3);
+		}
+	}
+
+	return TC_SUCCESS;
+}
+
+int32_t tc_sha256_final(uint8_t *digest, TCSha256State_t s)
+{
+	uint32_t i;
+
+	/* input sanity check: */
+	if (digest == (uint8_t *) 0 ||
+	    s == (TCSha256State_t) 0 ||
+	    s->iv == (uint32_t *) 0) {
+		return TC_FAIL;
+	}
+
+	s->bits_hashed += (s->leftover_offset << 3);
+
+	s->leftover[s->leftover_offset++] = 0x80; /* always room for one byte */
+	if (s->leftover_offset > (sizeof(s->leftover) - 8)) {
+		/* there is not room for all the padding in this block */
+		_set(s->leftover + s->leftover_offset, 0x00,
+		     sizeof(s->leftover) - s->leftover_offset);
+		compress(s->iv, s->leftover);
+		s->leftover_offset = 0;
+	}
+
+	/* add the padding and the length in big-Endian format */
+	_set(s->leftover + s->leftover_offset, 0x00,
+	     sizeof(s->leftover) - 8 - s->leftover_offset);
+	s->leftover[sizeof(s->leftover) - 1] = (uint8_t)(s->bits_hashed);
+	s->leftover[sizeof(s->leftover) - 2] = (uint8_t)(s->bits_hashed >> 8);
+	s->leftover[sizeof(s->leftover) - 3] = (uint8_t)(s->bits_hashed >> 16);
+	s->leftover[sizeof(s->leftover) - 4] = (uint8_t)(s->bits_hashed >> 24);
+	s->leftover[sizeof(s->leftover) - 5] = (uint8_t)(s->bits_hashed >> 32);
+	s->leftover[sizeof(s->leftover) - 6] = (uint8_t)(s->bits_hashed >> 40);
+	s->leftover[sizeof(s->leftover) - 7] = (uint8_t)(s->bits_hashed >> 48);
+	s->leftover[sizeof(s->leftover) - 8] = (uint8_t)(s->bits_hashed >> 56);
+
+	/* hash the padding and length */
+	compress(s->iv, s->leftover);
+
+	/* copy the iv out to digest */
+	for (i = 0; i < TC_SHA256_STATE_BLOCKS; ++i) {
+		uint32_t t = *((uint32_t *) &s->iv[i]);
+		*digest++ = (uint8_t)(t >> 24);
+		*digest++ = (uint8_t)(t >> 16);
+		*digest++ = (uint8_t)(t >> 8);
+		*digest++ = (uint8_t)(t);
+	}
+
+	/* destroy the current state */
+	_set(s, 0, sizeof(*s));
+
+	return TC_SUCCESS;
+}
+
+/*
+ * Initializing SHA-256 Hash constant words K.
+ * These values correspond to the first 32 bits of the fractional parts of the
+ * cube roots of the first 64 primes between 2 and 311.
+ */
+static const uint32_t k256[64] = {
+	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+	0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+	0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+	0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+	0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+	0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+	0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+	0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+	0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+static inline uint32_t ROTR(uint32_t a, uint32_t n)
+{
+	return (((a) >> n) | ((a) << (32 - n)));
+}
+
+#define Sigma0(a)(ROTR((a), 2) ^ ROTR((a), 13) ^ ROTR((a), 22))
+#define Sigma1(a)(ROTR((a), 6) ^ ROTR((a), 11) ^ ROTR((a), 25))
+#define sigma0(a)(ROTR((a), 7) ^ ROTR((a), 18) ^ ((a) >> 3))
+#define sigma1(a)(ROTR((a), 17) ^ ROTR((a), 19) ^ ((a) >> 10))
+
+#define Ch(a, b, c)(((a) & (b)) ^ ((~(a)) & (c)))
+#define Maj(a, b, c)(((a) & (b)) ^ ((a) & (c)) ^ ((b) & (c)))
+
+static inline uint32_t BigEndian(const uint8_t **c)
+{
+	uint32_t n = 0;
+
+	n = (((uint32_t)(*((*c)++))) << 24);
+	n |= ((uint32_t)(*((*c)++)) << 16);
+	n |= ((uint32_t)(*((*c)++)) << 8);
+	n |= ((uint32_t)(*((*c)++)));
+	return n;
+}
+
+static void compress(uint32_t *iv, const uint8_t *data)
+{
+	uint32_t a, b, c, d, e, f, g, h;
+	uint32_t s0, s1;
+	uint32_t t1, t2;
+	uint32_t work_space[16];
+	uint32_t n;
+	uint32_t i;
+
+	a = iv[0]; b = iv[1]; c = iv[2]; d = iv[3];
+	e = iv[4]; f = iv[5]; g = iv[6]; h = iv[7];
+
+	for (i = 0; i < 16; ++i) {
+		n = BigEndian(&data);
+		t1 = work_space[i] = n;
+		t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
+		t2 = Sigma0(a) + Maj(a, b, c);
+		h = g; g = f; f = e; e = d + t1;
+		d = c; c = b; b = a; a = t1 + t2;
+	}
+
+	for ( ; i < 64; ++i) {
+		s0 = work_space[(i+1)&0x0f];
+		s0 = sigma0(s0);
+		s1 = work_space[(i+14)&0x0f];
+		s1 = sigma1(s1);
+
+		t1 = work_space[i&0xf] += s0 + s1 + work_space[(i+9)&0xf];
+		t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
+		t2 = Sigma0(a) + Maj(a, b, c);
+		h = g; g = f; f = e; e = d + t1;
+		d = c; c = b; b = a; a = t1 + t2;
+	}
+
+	iv[0] += a; iv[1] += b; iv[2] += c; iv[3] += d;
+	iv[4] += e; iv[5] += f; iv[6] += g; iv[7] += h;
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/crypto/tinycrypt/src/utils.c
----------------------------------------------------------------------
diff --git a/crypto/tinycrypt/src/utils.c b/crypto/tinycrypt/src/utils.c
new file mode 100644
index 0000000..7f05939
--- /dev/null
+++ b/crypto/tinycrypt/src/utils.c
@@ -0,0 +1,78 @@
+/* utils.c - TinyCrypt platform-dependent run-time operations */
+
+/*
+ *  Copyright (C) 2015 by Intel Corporation, All Rights Reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are met:
+ *
+ *    - Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *    - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ *    - Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tinycrypt/utils.h>
+#include <tinycrypt/constants.h>
+
+#include <string.h>
+
+#define MASK_MOST_SIG_BIT 0x80
+#define MASK_TWENTY_SEVEN 0x1b
+
+uint32_t _copy(uint8_t *to, uint32_t to_len,
+	       const uint8_t *from, uint32_t from_len)
+{
+	if (from_len <= to_len) {
+		(void)memcpy(to, from, from_len);
+		return from_len;
+	} else {
+		return TC_FAIL;
+	}
+}
+
+void _set(void *to, uint8_t val, uint32_t len)
+{
+	(void)memset(to, val, len);
+}
+
+/*
+ * Doubles the value of a byte for values up to 127. Original 'return
+ * ((a<<1) ^ ((a>>7) * 0x1b))' re-written to avoid extra multiplication which
+ * the compiler won't be able to optimize
+ */
+uint8_t _double_byte(uint8_t a)
+{
+	return (a & MASK_MOST_SIG_BIT) ?
+		((a << 1) ^ MASK_TWENTY_SEVEN) : (a << 1);
+}
+
+int32_t _compare(const uint8_t *a, const uint8_t *b, size_t size)
+{
+	const uint8_t *tempa = a;
+	const uint8_t *tempb = b;
+	uint8_t result = 0;
+
+	for (uint32_t i = 0; i < size; i++) {
+		result |= tempa[i] ^ tempb[i];
+	}
+	return result;
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf51/include/adc_nrf51/adc_nrf51.h
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf51/include/adc_nrf51/adc_nrf51.h b/drivers/adc/adc_nrf51/include/adc_nrf51/adc_nrf51.h
deleted file mode 100644
index 0006b89..0000000
--- a/drivers/adc/adc_nrf51/include/adc_nrf51/adc_nrf51.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef __ADC_NRF51_H__
-#define __ADC_NRF51_H__
-
-#include <adc/adc.h>
-
-#include <nrf.h>
-#include <nrf_adc.h>
-
-int nrf51_adc_dev_init(struct os_dev *, void *);
-
-#endif /* __ADC_NRF51_H__ */

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf51/pkg.yml
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf51/pkg.yml b/drivers/adc/adc_nrf51/pkg.yml
deleted file mode 100644
index 2f604ed..0000000
--- a/drivers/adc/adc_nrf51/pkg.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#  http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-pkg.name: drivers/adc/adc_nrf51
-pkg.description: ADC driver for the NRF51
-pkg.author: "Apache Mynewt <dev@mynewt.incubator.apache.org>"
-pkg.homepage: "http://mynewt.apache.org/"
-pkg.keywords:
-pkg.apis:
-    - ADC_HW_IMPL
-pkg.deps:
-   - drivers/adc

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf51/src/adc_nrf51.c
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf51/src/adc_nrf51.c b/drivers/adc/adc_nrf51/src/adc_nrf51.c
deleted file mode 100644
index cf57de6..0000000
--- a/drivers/adc/adc_nrf51/src/adc_nrf51.c
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-#include <hal/hal_bsp.h>
-#include <adc/adc.h>
-#include <assert.h>
-#include <os/os.h>
-#include <bsp/cmsis_nvic.h>
-
-/* Nordic headers */
-#include <nrf.h>
-#include <nrf_adc.h>
-#include <nrf_drv_adc.h>
-#include <app_error.h>
-
-/**
- * Weak symbol, this is defined in Nordic drivers but not exported.
- * Needed for NVIC_SetVector().
- */
-extern void ADC_IRQHandler(void);
-
-#define NRF_ADC_CHANNEL_COUNT   (1)
-
-struct nrf51_adc_stats {
-    uint16_t adc_events;
-    uint16_t adc_events_failed;
-};
-static struct nrf51_adc_stats nrf51_adc_stats;
-
-struct adc_dev *global_adc_dev;
-
-nrf_adc_config_t adc_cfg;
-nrf_drv_adc_config_t *global_adc_config;
-
-struct adc_chan_config nrf51_adc_chans[NRF_ADC_CHANNEL_COUNT];
-nrf_drv_adc_channel_t *nrf_adc_chan;
-
-static void
-nrf51_adc_event_handler(const nrf_drv_adc_evt_t *event)
-{
-    nrf_drv_adc_done_evt_t *done_ev;
-    int rc;
-
-    if (global_adc_dev == NULL) {
-        ++nrf51_adc_stats.adc_events_failed;
-        return;
-    }
-
-    ++nrf51_adc_stats.adc_events;
-
-    /* Right now only data reads supported, assert for unknown event
-     * type.
-     */
-    assert(event->type == NRF_DRV_ADC_EVT_DONE);
-
-    done_ev = (nrf_drv_adc_done_evt_t * const) &event->data.done;
-
-    rc = global_adc_dev->ad_event_handler_func(global_adc_dev,
-            global_adc_dev->ad_event_handler_arg,
-            ADC_EVENT_RESULT, done_ev->p_buffer,
-            done_ev->size * sizeof(nrf_adc_value_t));
-    if (rc != 0) {
-        ++nrf51_adc_stats.adc_events_failed;
-    }
-}
-
-/**
- * Open the NRF51 ADC device
- *
- * This function locks the device for access from other tasks.
- *
- * @param odev The OS device to open
- * @param wait The time in MS to wait.  If 0 specified, returns immediately
- *             if resource unavailable.  If OS_WAIT_FOREVER specified, blocks
- *             until resource is available.
- * @param arg  Argument provided by higher layer to open, in this case
- *             it can be a nrf_drv_saadc_config_t, to override the default
- *             configuration.
- *
- * @return 0 on success, non-zero on failure.
- */
-static int
-nrf51_adc_open(struct os_dev *odev, uint32_t wait, void *arg)
-{
-    struct adc_dev *dev;
-    nrf_drv_adc_config_t *cfg;
-    int rc;
-
-    dev = (struct adc_dev *) odev;
-
-    if (os_started()) {
-        rc = os_mutex_pend(&dev->ad_lock, wait);
-        if (rc != OS_OK) {
-            goto err;
-        }
-    }
-
-    /* Initialize the device */
-    cfg = (nrf_drv_adc_config_t *)arg;
-    rc = nrf_drv_adc_init(cfg, nrf51_adc_event_handler);
-    if (rc != 0) {
-        goto err;
-    }
-
-    global_adc_dev = dev;
-    global_adc_config = arg;
-
-    return (0);
-err:
-    return (rc);
-}
-
-
-/**
- * Close the NRF51 ADC device.
- *
- * This function unlocks the device.
- *
- * @param odev The device to close.
- */
-static int
-nrf51_adc_close(struct os_dev *odev)
-{
-    struct adc_dev *dev;
-
-    dev = (struct adc_dev *) odev;
-
-    nrf_drv_adc_uninit();
-
-    global_adc_dev = NULL;
-    global_adc_config = NULL;
-
-    if (os_started()) {
-        os_mutex_release(&dev->ad_lock);
-    }
-
-    return (0);
-}
-
-/**
- * Configure an ADC channel on the Nordic ADC.
- *
- * @param dev The ADC device to configure
- * @param cnum The channel on the ADC device to configure
- * @param cfgdata An opaque pointer to channel config, expected to be
- *                a nrf_drv_adc_channel_config_t
- *
- * @return 0 on success, non-zero on failure.
- */
-static int
-nrf51_adc_configure_channel(struct adc_dev *dev, uint8_t cnum,
-                            void *cfgdata)
-{
-    nrf_drv_adc_channel_t *cc;
-    nrf_drv_adc_channel_config_t *cc_cfg;
-    nrf_adc_config_t adc_cfg;
-    uint16_t refmv;
-    uint8_t res;
-    int rc;
-
-    rc = -1;
-    if (global_adc_config == NULL) {
-        goto err;
-    }
-
-    cc = (nrf_drv_adc_channel_t *)cfgdata;
-    nrf_adc_chan = cc;
-    cc_cfg = &cc->config.config;
-
-    adc_cfg.reference = cc_cfg->reference |
-        (cc_cfg->external_reference << ADC_CONFIG_EXTREFSEL_Pos);
-    adc_cfg.resolution = cc_cfg->resolution;
-    adc_cfg.scaling = cc_cfg->input;
-    nrf_adc_configure(&adc_cfg);
-    nrf_drv_adc_channel_enable(cc);
-
-    /* Set the resolution and reference voltage for this channel to
-    * enable conversion functions.
-    */
-    switch (adc_cfg.resolution) {
-        case NRF_ADC_CONFIG_RES_8BIT:
-            res = 8;
-            break;
-        case NRF_ADC_CONFIG_RES_9BIT:
-            res = 9;
-            break;
-        case NRF_ADC_CONFIG_RES_10BIT:
-            res = 10;
-            break;
-        default:
-            assert(0);
-    }
-
-    switch (adc_cfg.reference) {
-        case NRF_ADC_CONFIG_REF_VBG:
-            refmv = 1200; /* 1.2V for NRF51 */
-            break;
-        case NRF_ADC_CONFIG_REF_EXT_REF0:
-            refmv = bsp_get_refmv(cc_cfg);
-            break;
-        case NRF_ADC_CONFIG_REF_EXT_REF1:
-            refmv = bsp_get_refmv(cc_cfg);
-            break;
-        case NRF_ADC_CONFIG_REF_SUPPLY_ONE_HALF:
-            refmv = bsp_get_refmv(cc_cfg) / 2;
-            break;
-        case NRF_ADC_CONFIG_REF_SUPPLY_ONE_THIRD:
-            refmv = bsp_get_refmv(cc_cfg) / 3;
-            break;
-        default:
-            assert(0);
-    }
-
-    /* Adjust reference voltage for gain. */
-    switch (cc_cfg->input) {
-        case NRF_ADC_CONFIG_SCALING_INPUT_FULL_SCALE:
-            break;
-        case NRF_ADC_CONFIG_SCALING_INPUT_ONE_THIRD:
-            refmv *= 3;
-            break;
-        case NRF_ADC_CONFIG_SCALING_INPUT_TWO_THIRDS:
-            refmv = (refmv * 3) / 2;
-            break;
-        case NRF_ADC_CONFIG_SCALING_SUPPLY_ONE_THIRD:
-            refmv = refmv * 3;
-            break;
-        case NRF_ADC_CONFIG_SCALING_SUPPLY_TWO_THIRDS:
-            refmv = (refmv * 3) / 2;
-            break;
-        default:
-            break;
-    }
-
-    /* Store these values in channel definitions, for conversions to
-     * milivolts.
-     */
-    dev->ad_chans[cnum].c_res = res;
-    dev->ad_chans[cnum].c_refmv = refmv;
-    dev->ad_chans[cnum].c_configured = 1;
-
-    return (0);
-err:
-    return (rc);
-}
-
-/**
- * Set buffer to read data into.  Implementation of setbuffer handler.
- * Sets both the primary and secondary buffers for DMA.
- */
-static int
-nrf51_adc_set_buffer(struct adc_dev *dev, void *buf1, void *buf2,
-                     int buf_len)
-{
-    int rc;
-
-    /* XXX: If this is called in blocking mode, it will result in a wait. */
-
-    /* Convert overall buffer length, into a total number of samples which
-     * Nordic APIs expect.
-     */
-    buf_len /= sizeof(nrf_adc_value_t);
-
-    rc = nrf_drv_adc_buffer_convert((nrf_adc_value_t *) buf1, buf_len);
-    if (rc != 0) {
-        goto err;
-    }
-
-    /* XXX: For now, only support one buffer */
-#if 0
-    if (buf2) {
-        rc = nrf_drv_adc_buffer_convert((nrf_adc_value_t *) buf2,
-                buf_len);
-        if (rc != 0) {
-            goto err;
-        }
-    }
-#endif
-    return (0);
-err:
-    return (rc);
-}
-
-static int
-nrf51_adc_release_buffer(struct adc_dev *dev, void *buf, int buf_len)
-{
-    int rc;
-
-    buf_len /= sizeof(nrf_adc_value_t);
-
-    rc = nrf_drv_adc_buffer_convert((nrf_adc_value_t *) buf, buf_len);
-    if (rc != 0) {
-        goto err;
-    }
-
-    return (0);
-err:
-    return (rc);
-}
-
-/**
- * Trigger an ADC sample.
- */
-static int
-nrf51_adc_sample(struct adc_dev *dev)
-{
-    nrf_drv_adc_sample();
-
-    return (0);
-}
-
-/**
- * Blocking read of an ADC channel, returns result as an integer.
- */
-static int
-nrf51_adc_read_channel(struct adc_dev *dev, uint8_t cnum, int *result)
-{
-    nrf_adc_value_t adc_value;
-    int rc;
-
-    rc = nrf_drv_adc_sample_convert(nrf_adc_chan, &adc_value);
-    if (rc == 0) {
-        *result = (int) adc_value;
-    }
-    return (rc);
-}
-
-static int
-nrf51_adc_read_buffer(struct adc_dev *dev, void *buf, int buf_len, int off,
-                      int *result)
-{
-    nrf_adc_value_t val;
-    int data_off;
-
-    data_off = off * sizeof(nrf_adc_value_t);
-    assert(data_off < buf_len);
-
-    val = *(nrf_adc_value_t *) ((uint8_t *) buf + data_off);
-    *result = val;
-
-    return (0);
-}
-
-static int
-nrf51_adc_size_buffer(struct adc_dev *dev, int chans, int samples)
-{
-    return (sizeof(nrf_adc_value_t) * chans * samples);
-}
-
-
-/**
- * Callback to initialize an adc_dev structure from the os device
- * initialization callback.  This sets up a nrf51_adc_device(), so that
- * subsequent lookups to this device allow us to manipulate it.
- */
-int
-nrf51_adc_dev_init(struct os_dev *odev, void *arg)
-{
-    struct adc_dev *dev;
-    struct adc_driver_funcs *af;
-
-    dev = (struct adc_dev *) odev;
-
-    os_mutex_init(&dev->ad_lock);
-
-    dev->ad_chans = (void *) nrf51_adc_chans;
-    dev->ad_chan_count = NRF_ADC_CHANNEL_COUNT;
-
-    OS_DEV_SETHANDLERS(odev, nrf51_adc_open, nrf51_adc_close);
-
-    af = &dev->ad_funcs;
-
-    af->af_configure_channel = nrf51_adc_configure_channel;
-    af->af_sample = nrf51_adc_sample;
-    af->af_read_channel = nrf51_adc_read_channel;
-    af->af_set_buffer = nrf51_adc_set_buffer;
-    af->af_release_buffer = nrf51_adc_release_buffer;
-    af->af_read_buffer = nrf51_adc_read_buffer;
-    af->af_size_buffer = nrf51_adc_size_buffer;
-
-    NVIC_SetVector(ADC_IRQn, (uint32_t) ADC_IRQHandler);
-
-    return (0);
-}
-
-

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf52/include/adc_nrf52/adc_nrf52.h
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf52/include/adc_nrf52/adc_nrf52.h b/drivers/adc/adc_nrf52/include/adc_nrf52/adc_nrf52.h
deleted file mode 100644
index f356f89..0000000
--- a/drivers/adc/adc_nrf52/include/adc_nrf52/adc_nrf52.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef __ADC_NRF52_H__
-#define __ADC_NRF52_H__
-
-#include <adc/adc.h>
-
-#include <nrf.h>
-#include <nrf_saadc.h>
-
-int nrf52_adc_dev_init(struct os_dev *, void *);
-
-#endif /* __ADC_H__ */

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf52/pkg.yml
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf52/pkg.yml b/drivers/adc/adc_nrf52/pkg.yml
deleted file mode 100644
index fa2eb70..0000000
--- a/drivers/adc/adc_nrf52/pkg.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#  http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-pkg.name: drivers/adc/adc_nrf52
-pkg.description: ADC driver for the NRF52
-pkg.author: "Apache Mynewt <dev@mynewt.incubator.apache.org>"
-pkg.homepage: "http://mynewt.apache.org/"
-pkg.keywords:
-pkg.apis: 
-    - ADC_HW_IMPL
-pkg.deps:
-   - drivers/adc

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/adc_nrf52/src/adc_nrf52.c
----------------------------------------------------------------------
diff --git a/drivers/adc/adc_nrf52/src/adc_nrf52.c b/drivers/adc/adc_nrf52/src/adc_nrf52.c
deleted file mode 100644
index d167175..0000000
--- a/drivers/adc/adc_nrf52/src/adc_nrf52.c
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-
-#include <hal/hal_bsp.h>
-#include <adc/adc.h>
-#include <assert.h>
-#include <os/os.h>
-#include <bsp/cmsis_nvic.h>
-
-/* Nordic headers */
-#include <nrf.h>
-#include <nrf_saadc.h>
-#include <nrf_drv_saadc.h>
-#include <app_error.h>
-
-/**
- * Weak symbol, this is defined in Nordic drivers but not exported.
- * Needed for NVIC_SetVector().
- */
-extern void SAADC_IRQHandler(void);
-
-struct nrf52_saadc_stats {
-    uint16_t saadc_events;
-    uint16_t saadc_events_failed;
-};
-static struct nrf52_saadc_stats nrf52_saadc_stats;
-
-struct adc_dev *global_adc_dev;
-nrf_drv_saadc_config_t *global_adc_config;
-
-uint8_t nrf52_adc_chans[NRF_SAADC_CHANNEL_COUNT * sizeof(struct adc_chan_config)];
-
-static void
-nrf52_saadc_event_handler(const nrf_drv_saadc_evt_t *event)
-{
-    nrf_drv_saadc_done_evt_t *done_ev;
-    int rc;
-
-    if (global_adc_dev == NULL) {
-        ++nrf52_saadc_stats.saadc_events_failed;
-        return;
-    }
-
-    ++nrf52_saadc_stats.saadc_events;
-
-    /* Right now only data reads supported, assert for unknown event
-     * type.
-     */
-    assert(event->type == NRF_DRV_SAADC_EVT_DONE);
-
-    done_ev = (nrf_drv_saadc_done_evt_t * const) &event->data.done;
-
-    rc = global_adc_dev->ad_event_handler_func(global_adc_dev,
-            global_adc_dev->ad_event_handler_arg,
-            ADC_EVENT_RESULT, done_ev->p_buffer,
-            done_ev->size * sizeof(nrf_saadc_value_t));
-    if (rc != 0) {
-        ++nrf52_saadc_stats.saadc_events_failed;
-    }
-}
-
-
-/**
- * Open the NRF52 ADC device
- *
- * This function locks the device for access from other tasks.
- *
- * @param odev The OS device to open
- * @param wait The time in MS to wait.  If 0 specified, returns immediately
- *             if resource unavailable.  If OS_WAIT_FOREVER specified, blocks
- *             until resource is available.
- * @param arg  Argument provided by higher layer to open, in this case
- *             it can be a nrf_drv_saadc_config_t, to override the default
- *             configuration.
- *
- * @return 0 on success, non-zero on failure.
- */
-static int
-nrf52_adc_open(struct os_dev *odev, uint32_t wait, void *arg)
-{
-    struct adc_dev *dev;
-    int rc;
-
-    dev = (struct adc_dev *) odev;
-
-    if (os_started()) {
-        rc = os_mutex_pend(&dev->ad_lock, wait);
-        if (rc != OS_OK) {
-            goto err;
-        }
-    }
-
-    if (odev->od_flags & OS_DEV_F_STATUS_OPEN) {
-        os_mutex_release(&dev->ad_lock);
-        rc = OS_EBUSY;
-        goto err;
-    }
-
-    /* Initialize the device */
-    rc = nrf_drv_saadc_init((nrf_drv_saadc_config_t *) arg,
-            nrf52_saadc_event_handler);
-    if (rc != 0) {
-        goto err;
-    }
-
-    global_adc_dev = dev;
-    global_adc_config = arg;
-
-    return (0);
-err:
-    return (rc);
-}
-
-
-/**
- * Close the NRF52 ADC device.
- *
- * This function unlocks the device.
- *
- * @param odev The device to close.
- */
-static int
-nrf52_adc_close(struct os_dev *odev)
-{
-    struct adc_dev *dev;
-
-    dev = (struct adc_dev *) odev;
-
-    nrf_drv_saadc_uninit();
-
-    global_adc_dev = NULL;
-    global_adc_config = NULL;
-
-    if (os_started()) {
-        os_mutex_release(&dev->ad_lock);
-    }
-
-    return (0);
-}
-
-/**
- * Configure an ADC channel on the Nordic ADC.
- *
- * @param dev The ADC device to configure
- * @param cnum The channel on the ADC device to configure
- * @param cfgdata An opaque pointer to channel config, expected to be
- *                a nrf_saadc_channel_config_t
- *
- * @return 0 on success, non-zero on failure.
- */
-static int
-nrf52_adc_configure_channel(struct adc_dev *dev, uint8_t cnum,
-        void *cfgdata)
-{
-    nrf_saadc_channel_config_t *cc;
-    uint16_t refmv;
-    uint8_t res;
-    int rc;
-
-    cc = (nrf_saadc_channel_config_t *) cfgdata;
-
-    rc = nrf_drv_saadc_channel_init(cnum, cc);
-    if (rc != 0) {
-        goto err;
-    }
-
-    if (global_adc_config) {
-        /* Set the resolution and reference voltage for this channel to
-        * enable conversion functions.
-        */
-        switch (global_adc_config->resolution) {
-            case NRF_SAADC_RESOLUTION_8BIT:
-                res = 8;
-                break;
-            case NRF_SAADC_RESOLUTION_10BIT:
-                res = 10;
-                break;
-            case NRF_SAADC_RESOLUTION_12BIT:
-                res = 12;
-                break;
-            case NRF_SAADC_RESOLUTION_14BIT:
-                res = 14;
-                break;
-            default:
-                assert(0);
-        }
-    } else {
-        /* Default to 10-bit resolution. */
-        res = 10;
-    }
-
-    switch (cc->reference) {
-        case NRF_SAADC_REFERENCE_INTERNAL:
-            refmv = 600; /* 0.6V for NRF52 */
-            break;
-        case NRF_SAADC_REFERENCE_VDD4:
-            refmv = bsp_get_refmv(NULL) / 4;
-            break;
-        default:
-            assert(0);
-    }
-
-    /* Adjust reference voltage for gain. */
-    switch (cc->gain) {
-        case NRF_SAADC_GAIN1_6:
-            refmv *= 6;
-            break;
-        case NRF_SAADC_GAIN1_5:
-            refmv *= 5;
-            break;
-        case NRF_SAADC_GAIN1_4:
-            refmv *= 4;
-            break;
-        case NRF_SAADC_GAIN1_3:
-            refmv *= 3;
-            break;
-        case NRF_SAADC_GAIN1_2:
-            refmv *= 2;
-            break;
-        case NRF_SAADC_GAIN2:
-            refmv /= 2;
-            break;
-        case NRF_SAADC_GAIN4:
-            refmv /= 4;
-            break;
-        default:
-            break;
-    }
-
-    /* Store these values in channel definitions, for conversions to
-     * milivolts.
-     */
-    dev->ad_chans[cnum].c_res = res;
-    dev->ad_chans[cnum].c_refmv = refmv;
-    dev->ad_chans[cnum].c_configured = 1;
-
-    return (0);
-err:
-    return (rc);
-}
-
-/**
- * Set buffer to read data into.  Implementation of setbuffer handler.
- * Sets both the primary and secondary buffers for DMA.
- */
-static int
-nrf52_adc_set_buffer(struct adc_dev *dev, void *buf1, void *buf2,
-        int buf_len)
-{
-    int rc;
-
-    /* Convert overall buffer length, into a total number of samples which
-     * Nordic APIs expect.
-     */
-    buf_len /= sizeof(nrf_saadc_value_t);
-
-    rc = nrf_drv_saadc_buffer_convert((nrf_saadc_value_t *) buf1, buf_len);
-    if (rc != 0) {
-        goto err;
-    }
-
-    if (buf2) {
-        rc = nrf_drv_saadc_buffer_convert((nrf_saadc_value_t *) buf2,
-                buf_len);
-        if (rc != 0) {
-            goto err;
-        }
-    }
-    return (0);
-err:
-    return (rc);
-}
-
-static int
-nrf52_adc_release_buffer(struct adc_dev *dev, void *buf, int buf_len)
-{
-    int rc;
-
-    buf_len /= sizeof(nrf_saadc_value_t);
-
-    rc = nrf_drv_saadc_buffer_convert((nrf_saadc_value_t *) buf, buf_len);
-    if (rc != 0) {
-        goto err;
-    }
-
-    return (0);
-err:
-    return (rc);
-}
-
-/**
- * Trigger an ADC sample.
- */
-static int
-nrf52_adc_sample(struct adc_dev *dev)
-{
-    nrf_drv_saadc_sample();
-
-    return (0);
-}
-
-/**
- * Blocking read of an ADC channel, returns result as an integer.
- */
-static int
-nrf52_adc_read_channel(struct adc_dev *dev, uint8_t cnum, int *result)
-{
-    nrf_saadc_value_t adc_value;
-    int rc;
-
-    rc = nrf_drv_saadc_sample_convert(cnum, &adc_value);
-    if (rc != 0) {
-        goto err;
-    }
-
-    *result = (int) adc_value;
-
-    return (0);
-err:
-    return (rc);
-}
-
-static int
-nrf52_adc_read_buffer(struct adc_dev *dev, void *buf, int buf_len, int off,
-        int *result)
-{
-    nrf_saadc_value_t val;
-    int data_off;
-
-    data_off = off * sizeof(nrf_saadc_value_t);
-    assert(data_off < buf_len);
-
-    val = *(nrf_saadc_value_t *) ((uint8_t *) buf + data_off);
-    *result = val;
-
-    return (0);
-}
-
-static int
-nrf52_adc_size_buffer(struct adc_dev *dev, int chans, int samples)
-{
-    return (sizeof(nrf_saadc_value_t) * chans * samples);
-}
-
-
-/**
- * Callback to initialize an adc_dev structure from the os device
- * initialization callback.  This sets up a nrf52_adc_device(), so
- * that subsequent lookups to this device allow us to manipulate it.
- */
-int
-nrf52_adc_dev_init(struct os_dev *odev, void *arg)
-{
-    struct adc_dev *dev;
-    struct adc_driver_funcs *af;
-
-    dev = (struct adc_dev *) odev;
-
-    os_mutex_init(&dev->ad_lock);
-
-    dev->ad_chans = (void *) nrf52_adc_chans;
-    dev->ad_chan_count = NRF_SAADC_CHANNEL_COUNT;
-
-    OS_DEV_SETHANDLERS(odev, nrf52_adc_open, nrf52_adc_close);
-
-    af = &dev->ad_funcs;
-
-    af->af_configure_channel = nrf52_adc_configure_channel;
-    af->af_sample = nrf52_adc_sample;
-    af->af_read_channel = nrf52_adc_read_channel;
-    af->af_set_buffer = nrf52_adc_set_buffer;
-    af->af_release_buffer = nrf52_adc_release_buffer;
-    af->af_read_buffer = nrf52_adc_read_buffer;
-    af->af_size_buffer = nrf52_adc_size_buffer;
-
-    NVIC_SetVector(SAADC_IRQn, (uint32_t) SAADC_IRQHandler);
-
-    return (0);
-}
-
-

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/include/adc/adc.h
----------------------------------------------------------------------
diff --git a/drivers/adc/include/adc/adc.h b/drivers/adc/include/adc/adc.h
deleted file mode 100644
index 2ffb6cd..0000000
--- a/drivers/adc/include/adc/adc.h
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef __ADC_H__
-#define __ADC_H__
-
-#include <os/os_dev.h>
-
-struct adc_dev;
-
-/**
- * Types of ADC events passed to the ADC driver.
- */
-typedef enum {
-    /* This event represents the result of an ADC run. */
-    ADC_EVENT_RESULT = 0
-} adc_event_type_t;
-
-/**
- * Event handler for ADC events that are processed in asynchronous mode.
- *
- * @param The ADC device being processed
- * @param The argument data passed to adc_set_result_handler()
- * @param The event type
- * @param The buffer containing event data
- * @param The size in bytes of that buffer.
- *
- * @return 0 on success, non-zero error code on failure
- */
-typedef int (*adc_event_handler_func_t)(struct adc_dev *, void *,
-    adc_event_type_t, void *, int);
-
-/**
- * Configure an ADC channel for this ADC device.  This is implemented
- * by the HW specific drivers.
- *
- * @param The ADC device to configure
- * @param The channel number to configure
- * @param An opaque blob containing HW specific configuration.
- *
- * @return 0 on success, non-zero error code on failure.
- */
-typedef int (*adc_configure_channel_func_t)(struct adc_dev *dev, uint8_t,
-        void *);
-
-/**
- * Trigger a sample on the ADC device asynchronously.  This is implemented
- * by the HW specific drivers.
- *
- * @param The ADC device to sample
- *
- * @return 0 on success, non-zero error code on failure
- */
-typedef int (*adc_sample_func_t)(struct adc_dev *);
-
-/**
- * Blocking read of an ADC channel.  This is implemented by the HW specific
- * drivers.
- *
- * @param The ADC device to perform the blocking read on
- * @param The channel to read
- * @param The result to put the ADC reading into
- *
- * @return 0 on success, non-zero error code on failure
- */
-typedef int (*adc_read_channel_func_t)(struct adc_dev *, uint8_t, int *);
-
-/**
- * Set the buffer(s) to read ADC results into for non-blocking reads.  This
- * is implemented by the HW specific drivers.
- *
- * @param The ADC device to read results into
- * @param The primary buffer to read results into
- * @param The secondary buffer to read results into (for cases where
- *        DMA'ing occurs, and secondary buffer can be used while primary
- *        is being processed.)
- * @param The length of both buffers in number of bytes
- *
- * @return 0 on success, non-zero error code on failure.
- */
-typedef int (*adc_buf_set_func_t)(struct adc_dev *, void *, void *, int);
-
-/**
- * Release a buffer for an ADC device, allowing the driver to re-use it for
- * DMA'ing data.
- *
- * @param The ADC device to release the buffer to
- * @param A pointer to the buffer to release
- * @param The length of the buffer being released.
- *
- * @return 0 on success, non-zero error code on failure.
- */
-typedef int (*adc_buf_release_func_t)(struct adc_dev *, void *, int);
-
-/**
- * Read the next entry from an ADC buffer as a integer
- *
- * @param The ADC device to read the entry from
- * @param The buffer to read the entry from
- * @param The total length of the buffer
- * @param The entry number to read from the buffer
- * @param The result to put the entry into
- *
- * @return 0 on success, non-zero error code on failure.
- */
-typedef int (*adc_buf_read_func_t)(struct adc_dev *, void *, int, int, int *);
-
-/**
- * Get the size of a buffer
- *
- * @param The ADC device to get the buffer size from
- * @param The number of channels in the buffer
- * @param The number of samples in the buffer
- *
- * @return The size of the buffer
- */
-typedef int (*adc_buf_size_func_t)(struct adc_dev *, int, int);
-
-struct adc_driver_funcs {
-    adc_configure_channel_func_t af_configure_channel;
-    adc_sample_func_t af_sample;
-    adc_read_channel_func_t af_read_channel;
-    adc_buf_set_func_t af_set_buffer;
-    adc_buf_release_func_t af_release_buffer;
-    adc_buf_read_func_t af_read_buffer;
-    adc_buf_size_func_t af_size_buffer;
-};
-
-struct adc_chan_config {
-    uint16_t c_refmv;
-    uint8_t c_res;
-    uint8_t c_configured;
-    uint8_t c_cnum;
-};
-
-struct adc_dev {
-    struct os_dev ad_dev;
-    struct os_mutex ad_lock;
-    struct adc_driver_funcs ad_funcs;
-    struct adc_chan_config *ad_chans;
-    int ad_chan_count;
-    adc_event_handler_func_t ad_event_handler_func;
-    void *ad_event_handler_arg;
-};
-
-int adc_chan_config(struct adc_dev *, uint8_t, void *);
-int adc_chan_read(struct adc_dev *, uint8_t, int *);
-int adc_event_handler_set(struct adc_dev *, adc_event_handler_func_t,
-        void *);
-
-/**
- * Sample the device specified by dev.  This is used in non-blocking mode
- * to generate samples into the event buffer.
- *
- * @param dev The device to sample
- *
- * @return 0 on success, non-zero on failure
- */
-static inline int
-adc_sample(struct adc_dev *dev)
-{
-    return (dev->ad_funcs.af_sample(dev));
-}
-
-/**
- * Set a result buffer to store data into.  Optionally, provide a
- * second buffer to continue writing data into as the first buffer
- * fills up.  Both buffers must be the same size.
- *
- * @param dev The ADC device to set the buffer for
- * @param buf1 The first buffer to spool data into
- * @param buf2 The second buffer to spool data into, while the first
- *             buffer is being processed.  If NULL is provided, it's
- *             unused.
- * @param buf_len The length of both buffers, in bytes.
- *
- * @return 0 on success, non-zero on failure.
- */
-static inline int
-adc_buf_set(struct adc_dev *dev, void *buf1, void *buf2,
-        int buf_len)
-{
-    return (dev->ad_funcs.af_set_buffer(dev, buf1, buf2, buf_len));
-}
-
-/**
- * Release a result buffer on the ADC device, and allow for it to be
- * re-used for DMA'ing results.
- *
- * @param dev The device to release the buffer for
- * @param buf The buffer to release
- * @param buf_len The length of the buffer being released.
- *
- * @return 0 on success, non-zero error code on failure.
- */
-static inline int
-adc_buf_release(struct adc_dev *dev, void *buf, int buf_len)
-{
-    return (dev->ad_funcs.af_release_buffer(dev, buf, buf_len));
-}
-
-/**
- * Read an entry from an ADC buffer
- *
- * @param dev The device that the entry is being read from
- * @param buf The buffer that we're reading the entry from
- * @param buf_len The length of the buffer we're reading the entry from
- * @param off The entry number to read from the buffer
- * @param result A pointer to the result to store the data in
- *
- * @return 0 on success, non-zero error code on failure
- */
-static inline int
-adc_buf_read(struct adc_dev *dev, void *buf, int buf_len, int entry,
-        int *result)
-{
-    return (dev->ad_funcs.af_read_buffer(dev, buf, buf_len, entry, result));
-}
-
-/**
- * Return the size of an ADC buffer
- *
- * @param dev The ADC device to return the buffer size from
- * @param channels The number of channels for these samples
- * @param samples The number of SAMPLES on this ADC device
- *
- * @return The size of the resulting buffer
- */
-static inline int
-adc_buf_size(struct adc_dev *dev, int chans, int samples)
-{
-    return (dev->ad_funcs.af_size_buffer(dev, chans, samples));
-}
-
-/**
- * Take an ADC result and convert it to millivolts.
- *
- * @param dev The ADC dev to convert the result on
- * @param cnum The channel number to convert the result from
- * @param val The ADC value to convert to millivolts
- *
- * @return The convert value in millivolts
- */
-static inline int
-adc_result_mv(struct adc_dev *dev, uint8_t cnum, int val)
-{
-    int res;
-    int refmv;
-    int ret;
-
-    refmv = (int) dev->ad_chans[cnum].c_refmv;
-    res = (int) dev->ad_chans[cnum].c_res;
-
-    ret = val * refmv;
-    ret += (1 << (res - 2));
-    ret = ret >> res;
-
-    return (ret);
-}
-
-#endif /* __ADC_H__ */

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/0216c73e/drivers/adc/pkg.yml
----------------------------------------------------------------------
diff --git a/drivers/adc/pkg.yml b/drivers/adc/pkg.yml
deleted file mode 100644
index bf0205a..0000000
--- a/drivers/adc/pkg.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#  http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-pkg.name: drivers/adc
-pkg.description: ADC driver interfaces
-pkg.author: "Apache Mynewt <dev@mynewt.incubator.apache.org>"
-pkg.homepage: "http://mynewt.apache.org/"
-pkg.keywords:
-pkg.req_apis:
-    - ADC_HW_IMPL



Mime
View raw message