File: sig_serial.c

package info (click to toggle)
faumachine 20180503-4
  • links: PTS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 61,272 kB
  • sloc: ansic: 272,290; makefile: 6,199; asm: 4,251; sh: 3,022; perl: 886; xml: 563; pascal: 311; lex: 214; vhdl: 204
file content (132 lines) | stat: -rw-r--r-- 2,259 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
/*
 * Copyright (C) 2007-2009 FAUmachine Team <info@faumachine.org>.
 * This program is free software. You can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either version 2 of
 * the License, or (at your option) any later version. See COPYING.
 */

#include <assert.h>
#include <stdio.h>

#include "glue.h"

#include "sig_serial.h"

void
sig_serial_send(
	struct sig_serial *b,
	void *s,
	uint8_t c
)
{
	unsigned int nr;

	for (nr = 0; ; nr++) {
		if (nr == b->nmembers) {
			return;
		}
		if (b->member[nr].s == s) {
			continue;
		}
		b->member[nr].f->recv(b->member[nr].s, c);
	}
}

void
sig_serial_connect(
	struct sig_serial *b,
	void *s,
	const struct sig_serial_funcs *f
)
{
	assert(b);
	assert(b->type == SIG_GEN_SERIAL);
	assert(b->nmembers < sizeof(b->member) / sizeof(b->member[0]));

	b->member[b->nmembers].s = s;
	b->member[b->nmembers].f = f;
	b->nmembers++;
}

static void
sig_serial_s0_recv(void *_f, uint8_t byte)
{
	struct sig_serial_merge *f = _f;

	sig_serial_send(f->s1, f, byte);
}

static void
sig_serial_s1_recv(void *_f, uint8_t byte)
{
	struct sig_serial_merge *f = _f;

	sig_serial_send(f->s0, f, byte);
}

struct sig_serial_merge *
sig_serial_merge(struct sig_serial *s0, struct sig_serial *s1)
{
	static const struct sig_serial_funcs s0_funcs = {
		.recv = sig_serial_s0_recv,
	};
	static const struct sig_serial_funcs s1_funcs = {
		.recv = sig_serial_s1_recv,
	};
	struct sig_serial_merge *m;

	m = shm_alloc(sizeof(*m));
	assert(m);

	m->s0 = s0;
	sig_serial_connect(s0, m, &s0_funcs);
	m->s1 = s1;
	sig_serial_connect(s1, m, &s1_funcs);

	return m;
}

void
sig_serial_split(struct sig_serial_merge *m)
{
	fixme();
}

struct sig_serial *
sig_serial_create(const char *name)
{
	struct sig_serial *sig;

	sig = shm_alloc(sizeof(*sig));
	assert(sig);

	sig->type = SIG_GEN_SERIAL;
	sig->nmembers = 0;

	return sig;
}

void
sig_serial_destroy(struct sig_serial *sig)
{
	assert(sig);
	assert(sig->type == SIG_GEN_SERIAL);

	shm_free(sig);
}

void
sig_serial_suspend(struct sig_serial *b, FILE *fSig)
{
	size_t size = sizeof(*b);
	
	generic_suspend(b, size, fSig);
}

void
sig_serial_resume(struct sig_serial *b, FILE *fSig)
{
	size_t size = sizeof(*b);
	
	generic_resume(b, size, fSig);
}