← Back to branch summary

~ubuntu-branches/ubuntu/wily/slof/wily

« back to all changes in this revision

Viewing changes to lib/libnvram/libnvram.code

  • Committer: Package Import Robot
  • Author(s): Aurelien Jarno
  • Date: 2012-09-16 23:05:23 UTC
  • Revision ID: package-import@ubuntu.com-20120916230523-r2ynulqmp2tyu2e5
Tags: upstream-20120217+dfsg
Import upstream version 20120217+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libnvram/libnvram.code
 
1
/******************************************************************************
 
2
 * Copyright (c) 2004, 2008 IBM Corporation
 
3
 * All rights reserved.
 
4
 * This program and the accompanying materials
 
5
 * are made available under the terms of the BSD License
 
6
 * which accompanies this distribution, and is available at
 
7
 * http://www.opensource.org/licenses/bsd-license.php
 
8
 *
 
9
 * Contributors:
 
10
 *     IBM Corporation - initial implementation
 
11
 *****************************************************************************/
 
12
#include <nvram.h>
 
13
 
 
14
#define STRING_INIT(str)        \
 
15
        char str[255];          \
 
16
        char * str##_address;   \
 
17
        int  str##_length;
 
18
 
 
19
#define STRING_FROM_STACK(str)                          \
 
20
        str##_length = TOS.u; POP;                              \
 
21
        str##_address = TOS.a; POP;                     \
 
22
        memcpy(str, str##_address, str##_length);       \
 
23
        memset(str + str##_length, 0, 255 - str##_length);
 
24
 
 
25
PRIM(nvram_X2d_c_X40)
 
26
        unsigned int offset = TOS.u;
 
27
        TOS.u=nvram_read_byte(offset);
 
28
MIRP
 
29
 
 
30
PRIM(nvram_X2d_w_X40)
 
31
        unsigned int offset = TOS.u;
 
32
        TOS.u=nvram_read_word(offset);
 
33
MIRP
 
34
 
 
35
PRIM(nvram_X2d_l_X40)
 
36
        unsigned int offset = TOS.u;
 
37
        TOS.u=nvram_read_dword(offset);
 
38
MIRP
 
39
 
 
40
PRIM(nvram_X2d_x_X40)
 
41
        unsigned int offset = TOS.u;
 
42
        TOS.u=nvram_read_qword(offset);
 
43
MIRP
 
44
 
 
45
PRIM(nvram_X2d_c_X21)
 
46
        nvram_write_byte(TOS.u, NOS.u);
 
47
        POP; POP;
 
48
MIRP
 
49
 
 
50
PRIM(nvram_X2d_w_X21)
 
51
        nvram_write_word(TOS.u, NOS.u);
 
52
        POP; POP;
 
53
MIRP
 
54
 
 
55
PRIM(nvram_X2d_l_X21)
 
56
        nvram_write_dword(TOS.u, NOS.u);
 
57
        POP; POP;
 
58
MIRP
 
59
 
 
60
PRIM(nvram_X2d_x_X21)
 
61
        nvram_write_qword(TOS.u, NOS.u);
 
62
        POP; POP;
 
63
MIRP
 
64
 
 
65
/* get-nvram-partition ( type -- addr len FAILED? ) */
 
66
PRIM(get_X2d_nvram_X2d_partition)
 
67
        partition_t partition;
 
68
        unsigned int ptype = TOS.u;
 
69
        partition = get_partition(ptype, NULL);
 
70
        if(partition.len && partition.len != -1) {
 
71
                TOS.u = partition.addr;
 
72
                PUSH;
 
73
                TOS.u = partition.len;
 
74
                PUSH;
 
75
                TOS.u = 0; // FALSE
 
76
        } else {
 
77
                TOS.u = -1; // TRUE
 
78
        }
 
79
MIRP
 
80
 
 
81
/* get-named-nvram-partition ( name.addr name.len -- addr len FAILED? ) */
 
82
PRIM(get_X2d_named_X2d_nvram_X2d_partition)
 
83
        STRING_INIT(name)
 
84
        partition_t partition;
 
85
 
 
86
        STRING_FROM_STACK(name)
 
87
        partition = get_partition(-1, name);
 
88
 
 
89
        if(partition.len && partition.len != -1) {
 
90
                PUSH;
 
91
                TOS.u = partition.addr;
 
92
                PUSH;
 
93
                TOS.u = partition.len;
 
94
                PUSH;
 
95
                TOS.u = 0; // FALSE
 
96
        } else {
 
97
                PUSH;
 
98
                TOS.u = -1; // TRUE
 
99
        }
 
100
MIRP
 
101
 
 
102
 
 
103
 
 
104
/* new-nvram-partition ( type name.addr name.len len -- part.offs part.len FALSE | TRUE) */
 
105
PRIM(new_X2d_nvram_X2d_partition)
 
106
        int type, len, i, slen;
 
107
        char name[12], *addr;
 
108
        partition_t partition;
 
109
 
 
110
        len = TOS.u; POP;
 
111
        slen = TOS.u; POP;
 
112
        addr = (char *)TOS.u; POP;
 
113
        type = TOS.u; POP;
 
114
 
 
115
        for (i=0; i<12; i++) {
 
116
                if(slen>i)
 
117
                        name[i]=addr[i];
 
118
                else
 
119
                        name[i]=0;
 
120
        }
 
121
 
 
122
        partition=new_nvram_partition(type, name, len);
 
123
 
 
124
        if(!partition.len) {
 
125
                PUSH; TOS.u = -1; // TRUE
 
126
        } else {
 
127
                PUSH; TOS.u = partition.addr;
 
128
                PUSH; TOS.u = partition.len;
 
129
                PUSH; TOS.u = 0; // FALSE
 
130
        }
 
131
MIRP
 
132
 
 
133
/* inrease-nvram-partition ( part.offs part.len new-len -- FALSE | TRUE ) */
 
134
PRIM(increase_X2d_nvram_X2d_partition)
 
135
        int len, ret;
 
136
        partition_t partition;
 
137
 
 
138
        // FIXME
 
139
        partition.addr = TOS.u; POP;
 
140
        partition.len  = TOS.u; POP;
 
141
        len = TOS.u; POP;
 
142
 
 
143
        ret=increase_nvram_partition_size(partition, len);
 
144
 
 
145
        PUSH;
 
146
 
 
147
        if(!ret) 
 
148
                TOS.u=-1; // TRUE
 
149
        else
 
150
                TOS.u=0; // FALSE
 
151
 
 
152
MIRP
 
153
 
 
154
PRIM(internal_X2d_reset_X2d_nvram)
 
155
        reset_nvram();
 
156
MIRP
 
157
 
 
158
PRIM(wipe_X2d_nvram)
 
159
        wipe_nvram();
 
160
MIRP
 
161
 
 
162
PRIM(nvram_X2d_debug)
 
163
        nvram_debug();
 
164
MIRP
 
165
 
 
166
// ( part.start part.len name.addr name.len -- var.addr var.len TRUE | false )
 
167
PRIM(internal_X2d_get_X2d_env)
 
168
        STRING_INIT(name)
 
169
        partition_t part;
 
170
        char *val;
 
171
 
 
172
        STRING_FROM_STACK(name)
 
173
        part.len = TOS.u; POP;
 
174
        part.addr = TOS.u; POP;
 
175
 
 
176
        val=get_env(part, name);
 
177
        if(val) {
 
178
                PUSH; TOS.a = val;
 
179
                PUSH; TOS.u = strlen(val);
 
180
                PUSH; TOS.u = -1; // TRUE
 
181
        } else {
 
182
                PUSH; TOS.u = 0; // FALSE
 
183
        }
 
184
MIRP
 
185
 
 
186
// ( part.start part.len name.addr name.len val.addr val.len -- FALSE|TRUE)
 
187
PRIM(internal_X2d_add_X2d_env)
 
188
        STRING_INIT(name)
 
189
        STRING_INIT(value)
 
190
        partition_t part;
 
191
        int ret;
 
192
 
 
193
        STRING_FROM_STACK(value)
 
194
        STRING_FROM_STACK(name)
 
195
        part.len = TOS.u; POP;
 
196
        part.addr = TOS.u; POP;
 
197
 
 
198
        ret=add_env(part, name, value);
 
199
        if(ret) {
 
200
                PUSH; TOS.u = -1; // TRUE
 
201
        } else {
 
202
                PUSH; TOS.u = 0; // FALSE
 
203
        }
 
204
MIRP
 
205
 
 
206
// ( part.addr part.len name.addr name.len -- FALSE|TRUE)
 
207
PRIM(internal_X2d_del_X2d_env)
 
208
        STRING_INIT(name)
 
209
        partition_t part;
 
210
        int ret;
 
211
 
 
212
        STRING_FROM_STACK(name);
 
213
        part.len = TOS.u; POP;
 
214
        part.addr = TOS.u; POP;
 
215
 
 
216
        ret=del_env(part, name);
 
217
        if(ret) {
 
218
                PUSH; TOS.u = -1; // TRUE
 
219
        } else {
 
220
                PUSH; TOS.u = 0; // FALSE
 
221
        }
 
222
 
 
223
MIRP
 
224
 
 
225
// internal-set-env ( part.addr part.len name.addr name.len val.addr val.len -- FALSE|TRUE)
 
226
PRIM(internal_X2d_set_X2d_env)
 
227
        STRING_INIT(name)
 
228
        STRING_INIT(value)
 
229
        partition_t part;
 
230
        int ret;
 
231
 
 
232
        STRING_FROM_STACK(value)
 
233
        STRING_FROM_STACK(name)
 
234
        part.len = TOS.u; POP;
 
235
        part.addr = TOS.u; POP;
 
236
 
 
237
        ret=set_env(part, name, value);
 
238
        if(ret) {
 
239
                PUSH; TOS.u = -1; // TRUE
 
240
        } else {
 
241
                PUSH; TOS.u = 0; // FALSE
 
242
        }
 
243
MIRP
 
244
 
 
245
// ( part.addr part.len -- FALSE|TRUE)
 
246
PRIM(erase_X2d_nvram_X2d_partition)
 
247
        partition_t part;
 
248
        int ret;
 
249
 
 
250
        part.len = TOS.u; POP;
 
251
        part.addr = TOS.u; POP;
 
252
 
 
253
        ret=clear_nvram_partition(part);
 
254
        if(ret) {
 
255
                PUSH; TOS.u = -1; // TRUE
 
256
        } else {
 
257
                PUSH; TOS.u = 0; // FALSE
 
258
        }
 
259
 
 
260
MIRP
 
261
 
 
262
// ( part.addr part.len -- FALSE|TRUE)
 
263
PRIM(delete_X2d_nvram_X2d_partition)
 
264
        partition_t part;
 
265
        int ret;
 
266
 
 
267
        part.len = TOS.u; POP;
 
268
        part.addr = TOS.u; POP;
 
269
 
 
270
        ret=delete_nvram_partition(part);
 
271
        if(ret) {
 
272
                PUSH; TOS.u = -1; // TRUE
 
273
        } else {
 
274
                PUSH; TOS.u = 0; // FALSE
 
275
        }
 
276
 
 
277
MIRP
 
278
 
 
279