OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [rdi-share/] [params.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/*
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: 1.1.1.1 $
12
 *     $Date: 2001-05-18 11:16:45 $
13
 *
14
 *
15
 *   Project: ANGEL
16
 *
17
 *     Title: Parameter negotiation utility functions
18
 */
19
 
20
#include "params.h"
21
 
22
#include "angel_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 */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.