File: ao_trng_send.c

package info (click to toggle)
altos 1.6.8-5
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 63,748 kB
  • ctags: 36,577
  • sloc: ansic: 92,100; java: 36,273; makefile: 6,495; xml: 3,096; sh: 1,971; pascal: 1,581
file content (258 lines) | stat: -rw-r--r-- 5,795 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/*
 * Copyright © 2015 Keith Packard <keithp@keithp.com>
 *
 * 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.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 */

#include <ao.h>
#include <ao_adc_fast.h>
#include <ao_crc.h>
#include <ao_trng_send.h>
#include <ao_exti.h>
#include <ao_power.h>

static struct ao_task	ao_trng_send_task;
static uint8_t		trng_running;
static AO_TICK_TYPE	trng_power_time;

#define TRNG_ENABLE_DELAY	AO_MS_TO_TICKS(100)

static uint8_t		random_mutex;

#if AO_USB_HAS_IN2

static struct ao_task	ao_trng_send_raw_task;

static void
ao_trng_get_raw(uint16_t *buf)
{
	uint16_t	i;
	uint16_t	t;
	uint16_t	v;

	t = ao_adc_get(AO_USB_IN_SIZE>>1);	/* one 16-bit value per two output bytes */
	for (i = 0; i < AO_USB_IN_SIZE / sizeof (uint16_t); i++) {
		v = ao_adc_ring[t];
		*buf++ = v;
		t = (t + 1) & (AO_ADC_RING_SIZE - 1);
	}
	ao_adc_ack(AO_USB_IN_SIZE>>1);
}

static void
ao_trng_send_raw(void)
{
	static uint16_t	*buffer[2];
	int		usb_buf_id;

	if (!buffer[0]) {
		buffer[0] = ao_usb_alloc();
		buffer[1] = ao_usb_alloc();
		if (!buffer[0])
			ao_exit();
	}

	usb_buf_id = 0;

	for (;;) {
		ao_mutex_get(&random_mutex);
		if (!trng_running) {
			AO_TICK_TYPE	delay;

			delay = trng_power_time + TRNG_ENABLE_DELAY - ao_time();
			if (delay > TRNG_ENABLE_DELAY)
				delay = TRNG_ENABLE_DELAY;

			/* Delay long enough for the HV power supply
			 * to stabilize so that the first bits we read
			 * aren't of poor quality
			 */
			ao_delay(delay);
			trng_running = TRUE;
		}
#ifdef AO_LED_TRNG_RAW
		ao_led_on(AO_LED_TRNG_RAW);
#endif
		ao_trng_get_raw(buffer[usb_buf_id]);
#ifdef AO_LED_TRNG_RAW
		ao_led_off(AO_LED_TRNG_RAW);
#endif
		ao_mutex_put(&random_mutex);
		ao_usb_write2(buffer[usb_buf_id], AO_USB_IN_SIZE);
		usb_buf_id = 1-usb_buf_id;
	}
}

#endif

static uint32_t	previous[AO_USB_IN_SIZE / sizeof (uint16_t)];

static int
ao_trng_get_cooked(uint16_t *buf)
{
	uint16_t	i;
	uint16_t	t;
	uint32_t	*rnd = (uint32_t *) (void *) ao_adc_ring;
	uint8_t		mismatch = 0;

	t = ao_adc_get(AO_USB_IN_SIZE) >> 1;		/* one 16-bit value per output byte */
	for (i = 0; i < AO_USB_IN_SIZE / sizeof (uint16_t); i++) {
		uint32_t	v;

		/* Fetch two values in one operation */
		v = rnd[t];
		if (v != previous[i]) {
			mismatch = 1;
			previous[i] = v;
		}
		t = (t + 1) & ((AO_ADC_RING_SIZE >> 1) - 1);

		*buf++ = ao_crc_in_32_out_16(v);
	}
	ao_adc_ack(AO_USB_IN_SIZE);
	return mismatch;
}

#define AO_TRNG_START_WAIT	1024
#define AO_TRNG_START_CHECK	32

static void
ao_trng_send(void)
{
	static uint16_t	*buffer[2];
	int	usb_buf_id;
	int	good_bits;
	int	failed;
	int	s;

	if (!buffer[0]) {
		buffer[0] = ao_usb_alloc();
		buffer[1] = ao_usb_alloc();
		if (!buffer[0])
			ao_exit();
	}

	usb_buf_id = 0;

#ifdef AO_TRNG_ENABLE_PORT
	ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
#endif
	trng_power_time = ao_time();

	ao_crc_reset();

	ao_delay(TRNG_ENABLE_DELAY);

	for (s = 0; s < AO_TRNG_START_WAIT; s++) {
		if (ao_trng_get_cooked(buffer[0]))
			break;
		ao_delay(AO_MS_TO_TICKS(10));
	}

	/* Validate the hardware before enabling USB */
	failed = 0;
	for (s = 0; s < AO_TRNG_START_CHECK; s++) {
		if (!ao_trng_get_cooked(buffer[0])) {
			failed++;
			ao_delay(AO_MS_TO_TICKS(10));
		}
	}
	if (failed > AO_TRNG_START_CHECK / 4)
		ao_panic(AO_PANIC_DMA);

#if AO_USB_HAS_IN2
	ao_add_task(&ao_trng_send_raw_task, ao_trng_send_raw, "trng_send_raw");
#endif

#ifdef AO_USB_START_DISABLED
	ao_usb_enable();
#endif

	for (;;) {
		ao_mutex_get(&random_mutex);
		if (!trng_running) {
			AO_TICK_TYPE	delay;

			delay = trng_power_time + TRNG_ENABLE_DELAY - ao_time();
			if (delay > TRNG_ENABLE_DELAY)
				delay = TRNG_ENABLE_DELAY;

			/* Delay long enough for the HV power supply
			 * to stabilize so that the first bits we read
			 * aren't of poor quality
			 */
			ao_delay(delay);
			trng_running = TRUE;
		}
#ifdef AO_LED_TRNG_COOKED
		ao_led_on(AO_LED_TRNG_COOKED);
#endif
		good_bits = ao_trng_get_cooked(buffer[usb_buf_id]);
#ifdef AO_LED_TRNG_COOKED
		ao_led_off(AO_LED_TRNG_COOKED);
#endif
		ao_mutex_put(&random_mutex);
		if (good_bits) {
			ao_usb_write(buffer[usb_buf_id], AO_USB_IN_SIZE);
			usb_buf_id = 1-usb_buf_id;
			failed = 0;
		} else {
			failed++;
			ao_delay(AO_MS_TO_TICKS(10));
			if (failed > 10) {
				ao_usb_disable();
				ao_panic(AO_PANIC_DMA);
			}
		}
	}
}

#if AO_POWER_MANAGEMENT

static void ao_trng_suspend(void *arg)
{
	(void) arg;
#ifdef AO_TRNG_ENABLE_PORT
	ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
#endif
	trng_running = FALSE;
}

static void ao_trng_resume(void *arg)
{
	(void) arg;
#ifdef AO_TRNG_ENABLE_PORT
	ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
#endif
	trng_power_time = ao_time();
}

static struct ao_power ao_trng_power = {
	.suspend = ao_trng_suspend,
	.resume = ao_trng_resume
};

#endif

void
ao_trng_send_init(void)
{
#ifdef AO_TRNG_ENABLE_PORT
	ao_enable_output(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
	ao_power_register(&ao_trng_power);
#endif
	ao_enable_input(AO_RAW_PORT, AO_RAW_BIT, AO_EXTI_MODE_PULL_UP);
	ao_add_task(&ao_trng_send_task, ao_trng_send, "trng_send");
}