Commit | Line | Data |
---|---|---|
3a9c3d12 NC |
1 | /* |
2 | * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. | |
3 | * | |
4 | * This software may be freely used, copied, modified, and distributed | |
5 | * provided that the above copyright notice is preserved in all copies of the | |
6 | * software. | |
7 | */ | |
8 | ||
9 | /* -*-C-*- | |
10 | * | |
11 | * $Revision$ | |
12 | * $Date$ | |
13 | * | |
14 | * | |
15 | * Project: ANGEL | |
16 | * | |
17 | * Title: Parameter negotiation utility functions | |
18 | */ | |
19 | ||
20 | #include "params.h" | |
21 | ||
22 | #include "endian.h" | |
23 | #include "logging.h" | |
24 | ||
25 | ||
26 | /* | |
27 | * Function: Angel_FindParam | |
28 | * Purpose: find the value of a given parameter from a config. | |
29 | * | |
30 | * see params.h for details | |
31 | */ | |
32 | bool Angel_FindParam( ADP_Parameter type, | |
33 | const ParameterConfig *config, | |
34 | unsigned int *value ) | |
35 | { | |
36 | unsigned int i; | |
37 | ||
38 | for ( i = 0; i < config->num_parameters; ++i ) | |
39 | if ( config->param[i].type == type ) | |
40 | { | |
41 | *value = config->param[i].value; | |
42 | return TRUE; | |
43 | } | |
44 | ||
45 | return FALSE; | |
46 | } | |
47 | ||
48 | ||
49 | #if !defined(TARGET) || !defined(MINIMAL_ANGEL) || MINIMAL_ANGEL == 0 | |
50 | ||
51 | ParameterList *Angel_FindParamList( const ParameterOptions *options, | |
52 | ADP_Parameter type ) | |
53 | { | |
54 | unsigned int i; | |
55 | ||
56 | for ( i = 0; i < options->num_param_lists; ++i ) | |
57 | if ( options->param_list[i].type == type ) | |
58 | return &options->param_list[i]; | |
59 | ||
60 | return NULL; | |
61 | } | |
62 | ||
63 | ||
64 | #if defined(TARGET) || defined(TEST_PARAMS) | |
65 | /* | |
66 | * Function: Angel_MatchParams | |
67 | * Purpose: find a configuration from the requested options which is | |
68 | * the best match from the supported options. | |
69 | * | |
70 | * see params.h for details | |
71 | */ | |
72 | const ParameterConfig *Angel_MatchParams( const ParameterOptions *requested, | |
73 | const ParameterOptions *supported ) | |
74 | { | |
75 | static Parameter chosen_params[AP_NUM_PARAMS]; | |
76 | static ParameterConfig chosen_config = { | |
77 | AP_NUM_PARAMS, | |
78 | chosen_params | |
79 | }; | |
80 | unsigned int i; | |
81 | ||
82 | ASSERT( requested != NULL, "requested is NULL" ); | |
83 | ASSERT( requested != NULL, "requested is NULL" ); | |
84 | ASSERT( supported->num_param_lists <= AP_NUM_PARAMS, "supp_num too big" ); | |
85 | ||
86 | if ( requested->num_param_lists > supported->num_param_lists ) | |
87 | { | |
88 | WARN( "req_num exceeds supp_num" ); | |
89 | return NULL; | |
90 | } | |
91 | ||
92 | for ( i = 0; i < requested->num_param_lists; ++i ) | |
93 | { | |
94 | bool match; | |
95 | unsigned int j; | |
96 | ||
97 | const ParameterList *req_list = &requested->param_list[i]; | |
98 | ADP_Parameter req_type = req_list->type; | |
99 | const ParameterList *sup_list = Angel_FindParamList( | |
100 | supported, req_type ); | |
101 | ||
102 | if ( sup_list == NULL ) | |
103 | { | |
104 | #ifdef ASSERTIONS_ENABLED | |
105 | __rt_warning( "option %x not supported\n", req_type ); | |
106 | #endif | |
107 | return NULL; | |
108 | } | |
109 | ||
110 | for ( j = 0, match = FALSE; | |
111 | (j < req_list->num_options) && !match; | |
112 | ++j | |
113 | ) | |
114 | { | |
115 | unsigned int k; | |
116 | ||
117 | for ( k = 0; | |
118 | (k < sup_list->num_options) && !match; | |
119 | ++k | |
120 | ) | |
121 | { | |
122 | if ( req_list->option[j] == sup_list->option[k] ) | |
123 | { | |
124 | #ifdef DEBUG | |
125 | __rt_info( "chose value %d for option %x\n", | |
126 | req_list->option[j], req_type ); | |
127 | #endif | |
128 | match = TRUE; | |
129 | chosen_config.param[i].type = req_type; | |
130 | chosen_config.param[i].value = req_list->option[j]; | |
131 | } | |
132 | } | |
133 | } | |
134 | ||
135 | if ( !match ) | |
136 | { | |
137 | #ifdef ASSERTIONS_ENABLED | |
138 | __rt_warning( "no match found for option %x\n", req_type ); | |
139 | #endif | |
140 | return NULL; | |
141 | } | |
142 | } | |
143 | ||
144 | chosen_config.num_parameters = i; | |
145 | INFO( "match succeeded" ); | |
146 | return &chosen_config; | |
147 | } | |
148 | #endif /* defined(TARGET) || defined(TEST_PARAMS) */ | |
149 | ||
150 | ||
151 | #if !defined(TARGET) || defined(TEST_PARAMS) | |
152 | /* | |
153 | * Function: Angel_StoreParam | |
154 | * Purpose: store the value of a given parameter to a config. | |
155 | * | |
156 | * see params.h for details | |
157 | */ | |
158 | bool Angel_StoreParam( ParameterConfig *config, | |
159 | ADP_Parameter type, | |
160 | unsigned int value ) | |
161 | { | |
162 | unsigned int i; | |
163 | ||
164 | for ( i = 0; i < config->num_parameters; ++i ) | |
165 | if ( config->param[i].type == type ) | |
166 | { | |
167 | config->param[i].value = value; | |
168 | return TRUE; | |
169 | } | |
170 | ||
171 | return FALSE; | |
172 | } | |
173 | #endif /* !defined(TARGET) || defined(TEST_PARAMS) */ | |
174 | ||
175 | ||
176 | #if defined(TARGET) || defined(LINK_RECOVERY) || defined(TEST_PARAMS) | |
177 | /* | |
178 | * Function: Angel_BuildParamConfigMessage | |
179 | * Purpose: write a parameter config to a buffer in ADP format. | |
180 | * | |
181 | * see params.h for details | |
182 | */ | |
183 | unsigned int Angel_BuildParamConfigMessage( unsigned char *buffer, | |
184 | const ParameterConfig *config ) | |
185 | { | |
186 | unsigned char *start = buffer; | |
187 | unsigned int i; | |
188 | ||
189 | PUT32LE( buffer, config->num_parameters ); | |
190 | buffer += sizeof( word ); | |
191 | ||
192 | for ( i = 0; i < config->num_parameters; ++i ) | |
193 | { | |
194 | PUT32LE( buffer, config->param[i].type ); | |
195 | buffer += sizeof( word ); | |
196 | PUT32LE( buffer, config->param[i].value ); | |
197 | buffer += sizeof( word ); | |
198 | } | |
199 | ||
200 | return (buffer - start); | |
201 | } | |
202 | #endif /* defined(TARGET) || defined(LINK_RECOVERY) || defined(TEST_PARAMS) */ | |
203 | ||
204 | ||
205 | #if !defined(TARGET) || defined(TEST_PARAMS) | |
206 | /* | |
207 | * Function: Angel_BuildParamOptionsMessage | |
208 | * Purpose: write a parameter Options to a buffer in ADP format. | |
209 | * | |
210 | * see params.h for details | |
211 | */ | |
212 | unsigned int Angel_BuildParamOptionsMessage( unsigned char *buffer, | |
213 | const ParameterOptions *options ) | |
214 | { | |
215 | unsigned char *start = buffer; | |
216 | unsigned int i, j; | |
217 | ||
218 | PUT32LE( buffer, options->num_param_lists ); | |
219 | buffer += sizeof( word ); | |
220 | ||
221 | for ( i = 0; i < options->num_param_lists; ++i ) | |
222 | { | |
223 | PUT32LE( buffer, options->param_list[i].type ); | |
224 | buffer += sizeof( word ); | |
225 | PUT32LE( buffer, options->param_list[i].num_options ); | |
226 | buffer += sizeof( word ); | |
227 | for ( j = 0; j < options->param_list[i].num_options; ++j ) | |
228 | { | |
229 | PUT32LE( buffer, options->param_list[i].option[j] ); | |
230 | buffer += sizeof( word ); | |
231 | } | |
232 | } | |
233 | ||
234 | return (buffer - start); | |
235 | } | |
236 | #endif /* !defined(TARGET) || defined(TEST_PARAMS) */ | |
237 | ||
238 | ||
239 | #if !defined(TARGET) || defined(LINK_RECOVERY) || defined(TEST_PARAMS) | |
240 | /* | |
241 | * Function: Angel_ReadParamConfigMessage | |
242 | * Purpose: read a parameter config from a buffer where it is in ADP format. | |
243 | * | |
244 | * see params.h for details | |
245 | */ | |
246 | bool Angel_ReadParamConfigMessage( const unsigned char *buffer, | |
247 | ParameterConfig *config ) | |
248 | { | |
249 | unsigned int word; | |
250 | unsigned int i; | |
251 | ||
252 | word = GET32LE( buffer ); | |
253 | buffer += sizeof( word ); | |
254 | if ( word > config->num_parameters ) | |
255 | { | |
256 | WARN( "not enough space" ); | |
257 | return FALSE; | |
258 | } | |
259 | config->num_parameters = word; | |
260 | ||
261 | for ( i = 0; i < config->num_parameters; ++i ) | |
262 | { | |
263 | config->param[i].type = (ADP_Parameter)GET32LE( buffer ); | |
264 | buffer += sizeof( word ); | |
265 | config->param[i].value = GET32LE( buffer ); | |
266 | buffer += sizeof( word ); | |
267 | } | |
268 | ||
269 | return TRUE; | |
270 | } | |
271 | #endif /* !defined(TARGET) || defined(LINK_RECOVERY) || defined(TEST_PARAMS) */ | |
272 | ||
273 | ||
274 | #if defined(TARGET) || defined(TEST_PARAMS) | |
275 | /* | |
276 | * Function: Angel_ReadParamOptionsMessage | |
277 | * Purpose: read a parameter options block from a buffer | |
278 | * where it is in ADP format. | |
279 | * | |
280 | * see params.h for details | |
281 | */ | |
282 | bool Angel_ReadParamOptionsMessage( const unsigned char *buffer, | |
283 | ParameterOptions *options ) | |
284 | { | |
285 | unsigned int word; | |
286 | unsigned int i, j; | |
287 | ||
288 | word = GET32LE( buffer ); | |
289 | buffer += sizeof( word ); | |
290 | if ( word > options->num_param_lists ) | |
291 | { | |
292 | WARN( "not enough space" ); | |
293 | return FALSE; | |
294 | } | |
295 | options->num_param_lists = word; | |
296 | ||
297 | for ( i = 0; i < options->num_param_lists; ++i ) | |
298 | { | |
299 | ParameterList *list = &options->param_list[i]; | |
300 | ||
301 | list->type = (ADP_Parameter)GET32LE( buffer ); | |
302 | buffer += sizeof( word ); | |
303 | word = GET32LE( buffer ); | |
304 | buffer += sizeof( word ); | |
305 | if ( word > list->num_options ) | |
306 | { | |
307 | WARN( "not enough list space" ); | |
308 | return FALSE; | |
309 | } | |
310 | list->num_options = word; | |
311 | ||
312 | for ( j = 0; j < list->num_options; ++j ) | |
313 | { | |
314 | list->option[j] = GET32LE( buffer ); | |
315 | buffer += sizeof( word ); | |
316 | } | |
317 | } | |
318 | ||
319 | return TRUE; | |
320 | } | |
321 | #endif /* defined(TARGET) || defined(TEST_PARAMS) */ | |
322 | ||
323 | #endif /* !define(TARGET) || !defined(MINIMAL_ANGEL) || MINIMAL_ANGEL == 0 */ | |
324 | ||
325 | /* EOF params.c */ |