← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mstflint/vivid-proposed

« back to all changes in this revision

Viewing changes to tools_layouts/tools_layouts.c

  • Committer: Package Import Robot
  • Author(s): Ana Beatriz Guerrero Lopez
  • Date: 2014-07-04 15:39:23 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20140704153923-khknwv3o1jeap3oo
Tags: 3.7.0-1
* New upstream release: 3.7.0-1.10.gdf7ec73
* Add build depends on libibmad-dev and autotools-dev.
* Remove build depends on automake and libtool.
* Switch to dh 9 and source format version 3.0
* Remove placeholder manpages.
* Remove flag DM-Upload-Allowed.
* Remove all current Uploaders, they're welcome back anytime.
  Add myself to Uploaders.
* Bump Standards-Version to 3.9.5 (no changes required).
* Update homepage.
* Add a watch file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools_layouts/tools_layouts.c
 
1
/*
 
2
 * Copyright (C) Jan 2013 Mellanox Technologies Ltd. All rights reserved.
 
3
 *
 
4
 * This software is available to you under a choice of one of two
 
5
 * licenses.  You may choose to be licensed under the terms of the GNU
 
6
 * General Public License (GPL) Version 2, available from the file
 
7
 * COPYING in the main directory of this source tree, or the
 
8
 * OpenIB.org BSD license below:
 
9
 *
 
10
 *     Redistribution and use in source and binary forms, with or
 
11
 *     without modification, are permitted provided that the following
 
12
 *     conditions are met:
 
13
 *
 
14
 *      - Redistributions of source code must retain the above
 
15
 *        copyright notice, this list of conditions and the following
 
16
 *        disclaimer.
 
17
 *
 
18
 *      - Redistributions in binary form must reproduce the above
 
19
 *        copyright notice, this list of conditions and the following
 
20
 *        disclaimer in the documentation and/or other materials
 
21
 *        provided with the distribution.
 
22
 *
 
23
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
24
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
25
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
26
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 
27
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 
28
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
29
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 
30
 * SOFTWARE.
 
31
 */
 
32
 
 
33
/***
 
34
 *** This file was generated at "2014-03-11 10:10:14"
 
35
 *** by:
 
36
 ***    > /mswg/release/eat_me/last_release/adabe_plugins/adb2c/adb2pack.py --input adb/tools/tools.adb --file-prefix tools --prefix tools_
 
37
 ***    and modified to fit the needs of mstflint.
 
38
 ***/
 
39
#include "tools_layouts.h"
 
40
 
 
41
void tools_mnv_hdr_pack(const struct tools_mnv_hdr *ptr_struct, u_int8_t* ptr_buff){
 
42
    u_int32_t offset;
 
43
    int i=0;
 
44
    (void)offset;
 
45
    (void)i;
 
46
    (void)ptr_struct;
 
47
    (void)ptr_buff;
 
48
 
 
49
    offset=16;
 
50
    adb2c_push_bits_to_buff(ptr_buff, offset, 16, (u_int32_t)ptr_struct->type);
 
51
 
 
52
    offset=2;
 
53
    adb2c_push_bits_to_buff(ptr_buff, offset, 12, (u_int32_t)ptr_struct->length);
 
54
 
 
55
    offset=40;
 
56
    adb2c_push_bits_to_buff(ptr_buff, offset, 8, (u_int32_t)ptr_struct->type_mod);
 
57
 
 
58
    offset=39;
 
59
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->shadow);
 
60
 
 
61
    offset=37;
 
62
    adb2c_push_bits_to_buff(ptr_buff, offset, 2, (u_int32_t)ptr_struct->pad_cnt);
 
63
 
 
64
    offset=32;
 
65
    adb2c_push_bits_to_buff(ptr_buff, offset, 4, (u_int32_t)ptr_struct->version);
 
66
 
 
67
}
 
68
 
 
69
void tools_mnv_hdr_unpack(struct tools_mnv_hdr *ptr_struct, const u_int8_t* ptr_buff){
 
70
    u_int32_t offset;
 
71
    int i=0;
 
72
    (void)offset;
 
73
    (void)i;
 
74
    (void)ptr_struct;
 
75
    (void)ptr_buff;
 
76
 
 
77
    offset=16;
 
78
    ptr_struct->type = (u_int16_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 16);
 
79
 
 
80
    offset=2;
 
81
    ptr_struct->length = (u_int16_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 12);
 
82
 
 
83
    offset=40;
 
84
    ptr_struct->type_mod = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 8);
 
85
 
 
86
    offset=39;
 
87
    ptr_struct->shadow = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
88
 
 
89
    offset=37;
 
90
    ptr_struct->pad_cnt = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 2);
 
91
 
 
92
    offset=32;
 
93
    ptr_struct->version = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 4);
 
94
 
 
95
}
 
96
 
 
97
void tools_mnv_hdr_print(const struct tools_mnv_hdr *ptr_struct, FILE* file, int indent_level){
 
98
    adb2c_add_indentation(file, indent_level);
 
99
    fprintf(file, "======== mnv_hdr ========\n");
 
100
    int i=0;
 
101
    (void)i;(void)ptr_struct;
 
102
    (void)file;
 
103
    (void)indent_level;
 
104
 
 
105
    adb2c_add_indentation(file, indent_level);
 
106
    fprintf(file, "type                 : "UH_FMT"\n", ptr_struct->type);
 
107
 
 
108
    adb2c_add_indentation(file, indent_level);
 
109
    fprintf(file, "length               : "UH_FMT"\n", ptr_struct->length);
 
110
 
 
111
    adb2c_add_indentation(file, indent_level);
 
112
    fprintf(file, "type_mod             : "UH_FMT"\n", ptr_struct->type_mod);
 
113
 
 
114
    adb2c_add_indentation(file, indent_level);
 
115
    fprintf(file, "shadow               : "UH_FMT"\n", ptr_struct->shadow);
 
116
 
 
117
    adb2c_add_indentation(file, indent_level);
 
118
    fprintf(file, "pad_cnt              : "UH_FMT"\n", ptr_struct->pad_cnt);
 
119
 
 
120
    adb2c_add_indentation(file, indent_level);
 
121
    fprintf(file, "version              : "UH_FMT"\n", ptr_struct->version);
 
122
 
 
123
}
 
124
 
 
125
int tools_mnv_hdr_size(){
 
126
     return 8;
 
127
}
 
128
 
 
129
void tools_mnv_hdr_dump(const struct tools_mnv_hdr *ptr_struct, FILE* file) {
 
130
    tools_mnv_hdr_print(ptr_struct, file, 0);
 
131
}
 
132
 
 
133
void tools_mnvia_pack(const struct tools_mnvia *ptr_struct, u_int8_t* ptr_buff){
 
134
    u_int32_t offset;
 
135
    int i=0;
 
136
    (void)offset;
 
137
    (void)i;
 
138
    (void)ptr_struct;
 
139
    (void)ptr_buff;
 
140
 
 
141
    offset=0;
 
142
    tools_mnv_hdr_pack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
143
 
 
144
}
 
145
 
 
146
void tools_mnvia_unpack(struct tools_mnvia *ptr_struct, const u_int8_t* ptr_buff){
 
147
    u_int32_t offset;
 
148
    int i=0;
 
149
    (void)offset;
 
150
    (void)i;
 
151
    (void)ptr_struct;
 
152
    (void)ptr_buff;
 
153
 
 
154
    offset=0;
 
155
    tools_mnv_hdr_unpack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
156
 
 
157
}
 
158
 
 
159
void tools_mnvia_print(const struct tools_mnvia *ptr_struct, FILE* file, int indent_level){
 
160
    adb2c_add_indentation(file, indent_level);
 
161
    fprintf(file, "======== mnvia ========\n");
 
162
    int i=0;
 
163
    (void)i;(void)ptr_struct;
 
164
    (void)file;
 
165
    (void)indent_level;
 
166
 
 
167
    adb2c_add_indentation(file, indent_level);
 
168
    fprintf(file, "mnv_hdr:\n");
 
169
    tools_mnv_hdr_print(&(ptr_struct->mnv_hdr), file, indent_level + 1);
 
170
 
 
171
}
 
172
 
 
173
int tools_mnvia_size(){
 
174
     return 8;
 
175
}
 
176
 
 
177
void tools_mnvia_dump(const struct tools_mnvia *ptr_struct, FILE* file) {
 
178
    tools_mnvia_print(ptr_struct, file, 0);
 
179
}
 
180
 
 
181
void tools_mnvi_pack(const struct tools_mnvi *ptr_struct, u_int8_t* ptr_buff){
 
182
    u_int32_t offset;
 
183
    int i=0;
 
184
    (void)offset;
 
185
    (void)i;
 
186
    (void)ptr_struct;
 
187
    (void)ptr_buff;
 
188
 
 
189
    offset=0;
 
190
    tools_mnv_hdr_pack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
191
 
 
192
}
 
193
 
 
194
void tools_mnvi_unpack(struct tools_mnvi *ptr_struct, const u_int8_t* ptr_buff){
 
195
    u_int32_t offset;
 
196
    int i=0;
 
197
    (void)offset;
 
198
    (void)i;
 
199
    (void)ptr_struct;
 
200
    (void)ptr_buff;
 
201
 
 
202
    offset=0;
 
203
    tools_mnv_hdr_unpack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
204
 
 
205
}
 
206
 
 
207
void tools_mnvi_print(const struct tools_mnvi *ptr_struct, FILE* file, int indent_level){
 
208
    adb2c_add_indentation(file, indent_level);
 
209
    fprintf(file, "======== mnvi ========\n");
 
210
    int i=0;
 
211
    (void)i;(void)ptr_struct;
 
212
    (void)file;
 
213
    (void)indent_level;
 
214
 
 
215
    adb2c_add_indentation(file, indent_level);
 
216
    fprintf(file, "mnv_hdr:\n");
 
217
    tools_mnv_hdr_print(&(ptr_struct->mnv_hdr), file, indent_level + 1);
 
218
 
 
219
}
 
220
 
 
221
int tools_mnvi_size(){
 
222
     return 8;
 
223
}
 
224
 
 
225
void tools_mnvi_dump(const struct tools_mnvi *ptr_struct, FILE* file) {
 
226
    tools_mnvi_print(ptr_struct, file, 0);
 
227
}
 
228
 
 
229
void tools_mnva_pack(const struct tools_mnva *ptr_struct, u_int8_t* ptr_buff){
 
230
    u_int32_t offset;
 
231
    int i=0;
 
232
    (void)offset;
 
233
    (void)i;
 
234
    (void)ptr_struct;
 
235
    (void)ptr_buff;
 
236
 
 
237
    offset=0;
 
238
    tools_mnv_hdr_pack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
239
 
 
240
    for (i=0; i < 128; i++) {
 
241
    offset=adb2c_calc_array_field_address(88, 8, i, 2048, 1);
 
242
    adb2c_push_bits_to_buff(ptr_buff, offset, 8, (u_int32_t)ptr_struct->data[i]);
 
243
    }
 
244
 
 
245
}
 
246
 
 
247
void tools_mnva_unpack(struct tools_mnva *ptr_struct, const u_int8_t* ptr_buff){
 
248
    u_int32_t offset;
 
249
    int i=0;
 
250
    (void)offset;
 
251
    (void)i;
 
252
    (void)ptr_struct;
 
253
    (void)ptr_buff;
 
254
 
 
255
    offset=0;
 
256
    tools_mnv_hdr_unpack(&(ptr_struct->mnv_hdr), ptr_buff + offset/8);
 
257
 
 
258
    for (i=0; i < 128; i++) {
 
259
    offset=adb2c_calc_array_field_address(88, 8, i, 2048, 1);
 
260
    ptr_struct->data[i] = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 8);
 
261
    }
 
262
 
 
263
}
 
264
 
 
265
void tools_mnva_print(const struct tools_mnva *ptr_struct, FILE* file, int indent_level){
 
266
    adb2c_add_indentation(file, indent_level);
 
267
    fprintf(file, "======== mnva ========\n");
 
268
    int i=0;
 
269
    (void)i;(void)ptr_struct;
 
270
    (void)file;
 
271
    (void)indent_level;
 
272
 
 
273
    adb2c_add_indentation(file, indent_level);
 
274
    fprintf(file, "mnv_hdr:\n");
 
275
    tools_mnv_hdr_print(&(ptr_struct->mnv_hdr), file, indent_level + 1);
 
276
 
 
277
    for (i=0; i < 128; i++) {
 
278
    adb2c_add_indentation(file, indent_level);
 
279
    fprintf(file, "data[%3d]            : "UH_FMT"\n", i, ptr_struct->data[i]);
 
280
    }
 
281
 
 
282
}
 
283
 
 
284
int tools_mnva_size(){
 
285
     return 256;
 
286
}
 
287
 
 
288
void tools_mnva_dump(const struct tools_mnva *ptr_struct, FILE* file) {
 
289
    tools_mnva_print(ptr_struct, file, 0);
 
290
}
 
291
 
 
292
void tools_sriov_pack(const struct tools_sriov *ptr_struct, u_int8_t* ptr_buff){
 
293
    u_int32_t offset;
 
294
    int i=0;
 
295
    (void)offset;
 
296
    (void)i;
 
297
    (void)ptr_struct;
 
298
    (void)ptr_buff;
 
299
 
 
300
    offset=16;
 
301
    adb2c_push_bits_to_buff(ptr_buff, offset, 16, (u_int32_t)ptr_struct->total_vfs);
 
302
 
 
303
    offset=0;
 
304
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->sriov_en);
 
305
 
 
306
}
 
307
 
 
308
void tools_sriov_unpack(struct tools_sriov *ptr_struct, const u_int8_t* ptr_buff){
 
309
    u_int32_t offset;
 
310
    int i=0;
 
311
    (void)offset;
 
312
    (void)i;
 
313
    (void)ptr_struct;
 
314
    (void)ptr_buff;
 
315
 
 
316
    offset=16;
 
317
    ptr_struct->total_vfs = (u_int16_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 16);
 
318
 
 
319
    offset=0;
 
320
    ptr_struct->sriov_en = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
321
 
 
322
}
 
323
 
 
324
void tools_sriov_print(const struct tools_sriov *ptr_struct, FILE* file, int indent_level){
 
325
    adb2c_add_indentation(file, indent_level);
 
326
    fprintf(file, "======== sriov ========\n");
 
327
    int i=0;
 
328
    (void)i;(void)ptr_struct;
 
329
    (void)file;
 
330
    (void)indent_level;
 
331
 
 
332
    adb2c_add_indentation(file, indent_level);
 
333
    fprintf(file, "total_vfs            : "UH_FMT"\n", ptr_struct->total_vfs);
 
334
 
 
335
    adb2c_add_indentation(file, indent_level);
 
336
    fprintf(file, "sriov_en             : "UH_FMT"\n", ptr_struct->sriov_en);
 
337
 
 
338
}
 
339
 
 
340
int tools_sriov_size(){
 
341
     return 4;
 
342
}
 
343
 
 
344
void tools_sriov_dump(const struct tools_sriov *ptr_struct, FILE* file) {
 
345
    tools_sriov_print(ptr_struct, file, 0);
 
346
}
 
347
 
 
348
void tools_bar_size_pack(const struct tools_bar_size *ptr_struct, u_int8_t* ptr_buff){
 
349
    u_int32_t offset;
 
350
    int i=0;
 
351
    (void)offset;
 
352
    (void)i;
 
353
    (void)ptr_struct;
 
354
    (void)ptr_buff;
 
355
 
 
356
    offset=0;
 
357
    adb2c_push_integer_to_buff(ptr_buff, offset, 4, (u_int64_t)ptr_struct->log_uar_bar_size);
 
358
 
 
359
}
 
360
 
 
361
void tools_bar_size_unpack(struct tools_bar_size *ptr_struct, const u_int8_t* ptr_buff){
 
362
    u_int32_t offset;
 
363
    int i=0;
 
364
    (void)offset;
 
365
    (void)i;
 
366
    (void)ptr_struct;
 
367
    (void)ptr_buff;
 
368
 
 
369
    offset=0;
 
370
    ptr_struct->log_uar_bar_size = (u_int32_t)adb2c_pop_integer_from_buff(ptr_buff, offset, 4);
 
371
 
 
372
}
 
373
 
 
374
void tools_bar_size_print(const struct tools_bar_size *ptr_struct, FILE* file, int indent_level){
 
375
    adb2c_add_indentation(file, indent_level);
 
376
    fprintf(file, "======== bar_size ========\n");
 
377
    int i=0;
 
378
    (void)i;(void)ptr_struct;
 
379
    (void)file;
 
380
    (void)indent_level;
 
381
 
 
382
    adb2c_add_indentation(file, indent_level);
 
383
    fprintf(file, "log_uar_bar_size     : "U32H_FMT"\n", ptr_struct->log_uar_bar_size);
 
384
 
 
385
}
 
386
 
 
387
int tools_bar_size_size(){
 
388
     return 4;
 
389
}
 
390
 
 
391
void tools_bar_size_dump(const struct tools_bar_size *ptr_struct, FILE* file) {
 
392
    tools_bar_size_print(ptr_struct, file, 0);
 
393
}
 
394
 
 
395
void tools_vpi_settings_pack(const struct tools_vpi_settings *ptr_struct, u_int8_t* ptr_buff){
 
396
    u_int32_t offset;
 
397
    int i=0;
 
398
    (void)offset;
 
399
    (void)i;
 
400
    (void)ptr_struct;
 
401
    (void)ptr_buff;
 
402
 
 
403
    offset=30;
 
404
    adb2c_push_bits_to_buff(ptr_buff, offset, 2, (u_int32_t)ptr_struct->network_link_type);
 
405
 
 
406
}
 
407
 
 
408
void tools_vpi_settings_unpack(struct tools_vpi_settings *ptr_struct, const u_int8_t* ptr_buff){
 
409
    u_int32_t offset;
 
410
    int i=0;
 
411
    (void)offset;
 
412
    (void)i;
 
413
    (void)ptr_struct;
 
414
    (void)ptr_buff;
 
415
 
 
416
    offset=30;
 
417
    ptr_struct->network_link_type = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 2);
 
418
 
 
419
}
 
420
 
 
421
void tools_vpi_settings_print(const struct tools_vpi_settings *ptr_struct, FILE* file, int indent_level){
 
422
    adb2c_add_indentation(file, indent_level);
 
423
    fprintf(file, "======== vpi_settings ========\n");
 
424
    int i=0;
 
425
    (void)i;(void)ptr_struct;
 
426
    (void)file;
 
427
    (void)indent_level;
 
428
 
 
429
    adb2c_add_indentation(file, indent_level);
 
430
    fprintf(file, "network_link_type    : "UH_FMT"\n", ptr_struct->network_link_type);
 
431
 
 
432
}
 
433
 
 
434
int tools_vpi_settings_size(){
 
435
     return 4;
 
436
}
 
437
 
 
438
void tools_vpi_settings_dump(const struct tools_vpi_settings *ptr_struct, FILE* file) {
 
439
    tools_vpi_settings_print(ptr_struct, file, 0);
 
440
}
 
441
 
 
442
void tools_wol_pack(const struct tools_wol *ptr_struct, u_int8_t* ptr_buff){
 
443
    u_int32_t offset;
 
444
    int i=0;
 
445
    (void)offset;
 
446
    (void)i;
 
447
    (void)ptr_struct;
 
448
    (void)ptr_buff;
 
449
 
 
450
    offset=22;
 
451
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved0);
 
452
 
 
453
    offset=21;
 
454
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->en_wol_magic);
 
455
 
 
456
    offset=20;
 
457
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved1);
 
458
 
 
459
    offset=19;
 
460
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved2);
 
461
 
 
462
    offset=18;
 
463
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved3);
 
464
 
 
465
    offset=17;
 
466
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved4);
 
467
 
 
468
    offset=16;
 
469
    adb2c_push_bits_to_buff(ptr_buff, offset, 1, (u_int32_t)ptr_struct->reserved5);
 
470
 
 
471
}
 
472
 
 
473
void tools_wol_unpack(struct tools_wol *ptr_struct, const u_int8_t* ptr_buff){
 
474
    u_int32_t offset;
 
475
    int i=0;
 
476
    (void)offset;
 
477
    (void)i;
 
478
    (void)ptr_struct;
 
479
    (void)ptr_buff;
 
480
 
 
481
    offset=22;
 
482
    ptr_struct->reserved0 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
483
 
 
484
    offset=21;
 
485
    ptr_struct->en_wol_magic = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
486
 
 
487
    offset=20;
 
488
    ptr_struct->reserved1 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
489
 
 
490
    offset=19;
 
491
    ptr_struct->reserved2 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
492
 
 
493
    offset=18;
 
494
    ptr_struct->reserved3 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
495
 
 
496
    offset=17;
 
497
    ptr_struct->reserved4 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
498
 
 
499
    offset=16;
 
500
    ptr_struct->reserved5 = (u_int8_t)adb2c_pop_bits_from_buff(ptr_buff, offset, 1);
 
501
 
 
502
}
 
503
 
 
504
void tools_wol_print(const struct tools_wol *ptr_struct, FILE* file, int indent_level){
 
505
    adb2c_add_indentation(file, indent_level);
 
506
    fprintf(file, "======== wol ========\n");
 
507
    int i=0;
 
508
    (void)i;(void)ptr_struct;
 
509
    (void)file;
 
510
    (void)indent_level;
 
511
 
 
512
    adb2c_add_indentation(file, indent_level);
 
513
    fprintf(file, "reserved0   : "UH_FMT"\n", ptr_struct->reserved0);
 
514
 
 
515
    adb2c_add_indentation(file, indent_level);
 
516
    fprintf(file, "en_wol_magic         : "UH_FMT"\n", ptr_struct->en_wol_magic);
 
517
 
 
518
    adb2c_add_indentation(file, indent_level);
 
519
    fprintf(file, "reserved1           : "UH_FMT"\n", ptr_struct->reserved1);
 
520
 
 
521
    adb2c_add_indentation(file, indent_level);
 
522
    fprintf(file, "reserved2            : "UH_FMT"\n", ptr_struct->reserved2);
 
523
 
 
524
    adb2c_add_indentation(file, indent_level);
 
525
    fprintf(file, "reserved3            : "UH_FMT"\n", ptr_struct->reserved3);
 
526
 
 
527
    adb2c_add_indentation(file, indent_level);
 
528
    fprintf(file, "reserved4            : "UH_FMT"\n", ptr_struct->reserved4);
 
529
 
 
530
    adb2c_add_indentation(file, indent_level);
 
531
    fprintf(file, "reserved5           : "UH_FMT"\n", ptr_struct->reserved5);
 
532
 
 
533
}
 
534
 
 
535
int tools_wol_size(){
 
536
     return 8;
 
537
}
 
538
 
 
539
void tools_wol_dump(const struct tools_wol *ptr_struct, FILE* file) {
 
540
    tools_wol_print(ptr_struct, file, 0);
 
541
}
 
542