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
|
/* rlc header descriptions
*
* Copyright (C) 2012 Ivan Klyuchnikov
* Copyright (C) 2012 Andreas Eversberg <jolly@eversberg.eu>
*
* 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.
*/
#pragma once
#include <stdint.h>
#define RLC_MAX_SNS 128 /* GPRS, must be power of 2 */
#define RLC_MAX_WS 64 /* max window size */
#define RLC_MAX_LEN 54 /* CS-4 including spare bits */
struct gprs_rlc_data {
uint8_t *prepare(size_t block_data_length);
/* block history */
uint8_t block[RLC_MAX_LEN];
/* block len of history */
uint8_t len;
};
/*
* I hold the currently transferred blocks and will provide
* the routines to manipulate these arrays.
*/
struct gprs_rlc {
gprs_rlc_data blocks[RLC_MAX_SNS/2];
};
struct gprs_rlc_v_b {
bool is_nacked(int index) const;
bool is_acked(int index) const;
bool is_unacked(int index) const;
bool is_resend(int index) const;
char state(int index) const;
void mark_unacked(int index);
void mark_nacked(int index);
void mark_acked(int index);
void mark_resend(int index);
void mark_invalid(int index);
void reset();
private:
bool is_state(int index, const char state) const;
void mark(int index, const char state);
char m_v_b[RLC_MAX_SNS/2]; /* acknowledge state array */
};
extern "C" {
/* TS 04.60 10.2.2 */
struct rlc_ul_header {
uint8_t r:1,
si:1,
cv:4,
pt:2;
uint8_t ti:1,
tfi:5,
pi:1,
spare:1;
uint8_t e:1,
bsn:7;
} __attribute__ ((packed));
struct rlc_dl_header {
uint8_t usf:3,
s_p:1,
rrbp:2,
pt:2;
uint8_t fbi:1,
tfi:5,
pr:2;
uint8_t e:1,
bsn:7;
} __attribute__ ((packed));
struct rlc_li_field {
uint8_t e:1,
m:1,
li:6;
} __attribute__ ((packed));
}
inline bool gprs_rlc_v_b::is_state(int index, const char type) const
{
return m_v_b[index] == type;
}
inline void gprs_rlc_v_b::mark(int index, const char type)
{
m_v_b[index] = type;
}
inline char gprs_rlc_v_b::state(int index) const
{
return m_v_b[index];
}
inline bool gprs_rlc_v_b::is_nacked(int index) const
{
return is_state(index, 'N');
}
inline bool gprs_rlc_v_b::is_acked(int index) const
{
return is_state(index, 'A');
}
inline bool gprs_rlc_v_b::is_unacked(int index) const
{
return is_state(index, 'U');
}
inline bool gprs_rlc_v_b::is_resend(int index) const
{
return is_state(index, 'X');
}
inline void gprs_rlc_v_b::mark_resend(int index)
{
return mark(index, 'X');
}
inline void gprs_rlc_v_b::mark_unacked(int index)
{
return mark(index, 'U');
}
inline void gprs_rlc_v_b::mark_acked(int index)
{
return mark(index, 'A');
}
inline void gprs_rlc_v_b::mark_nacked(int index)
{
return mark(index, 'N');
}
inline void gprs_rlc_v_b::mark_invalid(int index)
{
return mark(index, 'I');
}
|
