← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to kern/ieee1275/ieee1275.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
kern/ieee1275/ieee1275.c
1
 
/* of.c - Access the Open Firmware client interface.  */
2
 
/*
3
 
 *  GRUB  --  GRand Unified Bootloader
4
 
 *  Copyright (C) 2003,2004,2005,2007,2008,2009  Free Software Foundation, Inc.
5
 
 *
6
 
 *  GRUB is free software: you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation, either version 3 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  GRUB is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
18
 
 */
19
 
 
20
 
#include <grub/ieee1275/ieee1275.h>
21
 
#include <grub/types.h>
22
 
 
23
 
#define IEEE1275_PHANDLE_INVALID  ((grub_ieee1275_cell_t) -1)
24
 
#define IEEE1275_IHANDLE_INVALID  ((grub_ieee1275_cell_t) 0)
25
 
#define IEEE1275_CELL_INVALID     ((grub_ieee1275_cell_t) -1)
26
 
 
27
 
 
28
 
 
29
 
int
30
 
grub_ieee1275_finddevice (char *name, grub_ieee1275_phandle_t *phandlep)
31
 
{
32
 
  struct find_device_args
33
 
  {
34
 
    struct grub_ieee1275_common_hdr common;
35
 
    grub_ieee1275_cell_t device;
36
 
    grub_ieee1275_cell_t phandle;
37
 
  }
38
 
  args;
39
 
 
40
 
  INIT_IEEE1275_COMMON (&args.common, "finddevice", 1, 1);
41
 
  args.device = (grub_ieee1275_cell_t) name;
42
 
 
43
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
44
 
    return -1;
45
 
  *phandlep = args.phandle;
46
 
  if (args.phandle == IEEE1275_PHANDLE_INVALID)
47
 
    return -1;
48
 
  return 0;
49
 
}
50
 
 
51
 
int
52
 
grub_ieee1275_get_property (grub_ieee1275_phandle_t phandle,
53
 
                            const char *property, void *buf,
54
 
                            grub_size_t size, grub_ssize_t *actual)
55
 
{
56
 
  struct get_property_args
57
 
  {
58
 
    struct grub_ieee1275_common_hdr common;
59
 
    grub_ieee1275_cell_t phandle;
60
 
    grub_ieee1275_cell_t prop;
61
 
    grub_ieee1275_cell_t buf;
62
 
    grub_ieee1275_cell_t buflen;
63
 
    grub_ieee1275_cell_t size;
64
 
  }
65
 
  args;
66
 
 
67
 
  INIT_IEEE1275_COMMON (&args.common, "getprop", 4, 1);
68
 
  args.phandle = phandle;
69
 
  args.prop = (grub_ieee1275_cell_t) property;
70
 
  args.buf = (grub_ieee1275_cell_t) buf;
71
 
  args.buflen = (grub_ieee1275_cell_t) size;
72
 
 
73
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
74
 
    return -1;
75
 
  if (actual)
76
 
    *actual = (grub_ssize_t) args.size;
77
 
  if (args.size == IEEE1275_CELL_INVALID)
78
 
    return -1;
79
 
  return 0;
80
 
}
81
 
 
82
 
int
83
 
grub_ieee1275_get_integer_property (grub_ieee1275_phandle_t phandle,
84
 
                                    const char *property, grub_uint32_t *buf,
85
 
                                    grub_size_t size, grub_ssize_t *actual)
86
 
{
87
 
  int ret;
88
 
  ret = grub_ieee1275_get_property (phandle, property, (void *) buf, size, actual);
89
 
#ifndef GRUB_CPU_WORDS_BIGENDIAN
90
 
  /* Integer properties are always in big endian.  */
91
 
  if (ret == 0)
92
 
    {
93
 
      unsigned int i;
94
 
      size /= sizeof (grub_uint32_t);
95
 
      for (i = 0; i < size; i++)
96
 
        buf[i] = grub_be_to_cpu32 (buf[i]);
97
 
    }
98
 
#endif
99
 
  return ret;
100
 
}
101
 
 
102
 
int
103
 
grub_ieee1275_next_property (grub_ieee1275_phandle_t phandle, char *prev_prop,
104
 
                             char *prop)
105
 
{
106
 
  struct get_property_args
107
 
  {
108
 
    struct grub_ieee1275_common_hdr common;
109
 
    grub_ieee1275_cell_t phandle;
110
 
    grub_ieee1275_cell_t prev_prop;
111
 
    grub_ieee1275_cell_t next_prop;
112
 
    grub_ieee1275_cell_t flags;
113
 
  }
114
 
  args;
115
 
 
116
 
  INIT_IEEE1275_COMMON (&args.common, "nextprop", 3, 1);
117
 
  args.phandle = phandle;
118
 
  args.prev_prop = (grub_ieee1275_cell_t) prev_prop;
119
 
  args.next_prop = (grub_ieee1275_cell_t) prop;
120
 
  args.flags = (grub_ieee1275_cell_t) -1;
121
 
 
122
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
123
 
    return -1;
124
 
  return (int) args.flags;
125
 
}
126
 
 
127
 
int
128
 
grub_ieee1275_get_property_length (grub_ieee1275_phandle_t phandle,
129
 
                                   const char *prop, grub_ssize_t *length)
130
 
{
131
 
  struct get_property_args
132
 
  {
133
 
    struct grub_ieee1275_common_hdr common;
134
 
    grub_ieee1275_cell_t phandle;
135
 
    grub_ieee1275_cell_t prop;
136
 
    grub_ieee1275_cell_t length;
137
 
  }
138
 
  args;
139
 
 
140
 
  INIT_IEEE1275_COMMON (&args.common, "getproplen", 2, 1);
141
 
  args.phandle = phandle;
142
 
  args.prop = (grub_ieee1275_cell_t) prop;
143
 
  args.length = (grub_ieee1275_cell_t) -1;
144
 
 
145
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
146
 
    return -1;
147
 
  *length = args.length;
148
 
  if (args.length == IEEE1275_CELL_INVALID)
149
 
    return -1;
150
 
  return 0;
151
 
}
152
 
 
153
 
int
154
 
grub_ieee1275_instance_to_package (grub_ieee1275_ihandle_t ihandle,
155
 
                                   grub_ieee1275_phandle_t *phandlep)
156
 
{
157
 
  struct instance_to_package_args
158
 
  {
159
 
    struct grub_ieee1275_common_hdr common;
160
 
    grub_ieee1275_cell_t ihandle;
161
 
    grub_ieee1275_cell_t phandle;
162
 
  }
163
 
  args;
164
 
 
165
 
  INIT_IEEE1275_COMMON (&args.common, "instance-to-package", 1, 1);
166
 
  args.ihandle = ihandle;
167
 
 
168
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
169
 
    return -1;
170
 
  *phandlep = args.phandle;
171
 
  if (args.phandle == IEEE1275_PHANDLE_INVALID)
172
 
    return -1;
173
 
  return 0;
174
 
}
175
 
 
176
 
int
177
 
grub_ieee1275_package_to_path (grub_ieee1275_phandle_t phandle,
178
 
                               char *path, grub_size_t len,
179
 
                               grub_ssize_t *actual)
180
 
{
181
 
  struct instance_to_package_args
182
 
  {
183
 
    struct grub_ieee1275_common_hdr common;
184
 
    grub_ieee1275_cell_t phandle;
185
 
    grub_ieee1275_cell_t buf;
186
 
    grub_ieee1275_cell_t buflen;
187
 
    grub_ieee1275_cell_t actual;
188
 
  }
189
 
  args;
190
 
 
191
 
  INIT_IEEE1275_COMMON (&args.common, "package-to-path", 3, 1);
192
 
  args.phandle = phandle;
193
 
  args.buf = (grub_ieee1275_cell_t) path;
194
 
  args.buflen = (grub_ieee1275_cell_t) len;
195
 
 
196
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
197
 
    return -1;
198
 
  if (actual)
199
 
    *actual = args.actual;
200
 
  if (args.actual == IEEE1275_CELL_INVALID)
201
 
    return -1;
202
 
  return 0;
203
 
}
204
 
 
205
 
int
206
 
grub_ieee1275_instance_to_path (grub_ieee1275_ihandle_t ihandle,
207
 
                                char *path, grub_size_t len,
208
 
                                grub_ssize_t *actual)
209
 
{
210
 
  struct instance_to_path_args
211
 
  {
212
 
    struct grub_ieee1275_common_hdr common;
213
 
    grub_ieee1275_cell_t ihandle;
214
 
    grub_ieee1275_cell_t buf;
215
 
    grub_ieee1275_cell_t buflen;
216
 
    grub_ieee1275_cell_t actual;
217
 
  }
218
 
  args;
219
 
 
220
 
  INIT_IEEE1275_COMMON (&args.common, "instance-to-path", 3, 1);
221
 
  args.ihandle = ihandle;
222
 
  args.buf = (grub_ieee1275_cell_t) path;
223
 
  args.buflen = (grub_ieee1275_cell_t) len;
224
 
 
225
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
226
 
    return -1;
227
 
  if (actual)
228
 
    *actual = args.actual;
229
 
  if (args.actual == IEEE1275_CELL_INVALID)
230
 
    return -1;
231
 
  return 0;
232
 
}
233
 
 
234
 
int
235
 
grub_ieee1275_write (grub_ieee1275_ihandle_t ihandle, void *buffer,
236
 
                     grub_size_t len, grub_ssize_t *actualp)
237
 
{
238
 
  struct write_args
239
 
  {
240
 
    struct grub_ieee1275_common_hdr common;
241
 
    grub_ieee1275_cell_t ihandle;
242
 
    grub_ieee1275_cell_t buf;
243
 
    grub_ieee1275_cell_t len;
244
 
    grub_ieee1275_cell_t actual;
245
 
  }
246
 
  args;
247
 
 
248
 
  INIT_IEEE1275_COMMON (&args.common, "write", 3, 1);
249
 
  args.ihandle = ihandle;
250
 
  args.buf = (grub_ieee1275_cell_t) buffer;
251
 
  args.len = (grub_ieee1275_cell_t) len;
252
 
 
253
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
254
 
    return -1;
255
 
  if (actualp)
256
 
    *actualp = args.actual;
257
 
  return 0;
258
 
}
259
 
 
260
 
int
261
 
grub_ieee1275_read (grub_ieee1275_ihandle_t ihandle, void *buffer,
262
 
                    grub_size_t len, grub_ssize_t *actualp)
263
 
{
264
 
  struct write_args
265
 
  {
266
 
    struct grub_ieee1275_common_hdr common;
267
 
    grub_ieee1275_cell_t ihandle;
268
 
    grub_ieee1275_cell_t buf;
269
 
    grub_ieee1275_cell_t len;
270
 
    grub_ieee1275_cell_t actual;
271
 
  }
272
 
  args;
273
 
 
274
 
  INIT_IEEE1275_COMMON (&args.common, "read", 3, 1);
275
 
  args.ihandle = ihandle;
276
 
  args.buf = (grub_ieee1275_cell_t) buffer;
277
 
  args.len = (grub_ieee1275_cell_t) len;
278
 
 
279
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
280
 
    return -1;
281
 
  if (actualp)
282
 
    *actualp = args.actual;
283
 
  return 0;
284
 
}
285
 
 
286
 
int
287
 
grub_ieee1275_seek (grub_ieee1275_ihandle_t ihandle, grub_disk_addr_t pos,
288
 
                    grub_ssize_t *result)
289
 
{
290
 
  struct write_args
291
 
  {
292
 
    struct grub_ieee1275_common_hdr common;
293
 
    grub_ieee1275_cell_t ihandle;
294
 
    grub_ieee1275_cell_t pos_hi;
295
 
    grub_ieee1275_cell_t pos_lo;
296
 
    grub_ieee1275_cell_t result;
297
 
  }
298
 
  args;
299
 
 
300
 
  INIT_IEEE1275_COMMON (&args.common, "seek", 3, 1);
301
 
  args.ihandle = ihandle;
302
 
  /* To prevent stupid gcc warning.  */
303
 
#if GRUB_IEEE1275_CELL_SIZEOF >= 8
304
 
  args.pos_hi = 0;
305
 
  args.pos_lo = pos;
306
 
#else
307
 
  args.pos_hi = (grub_ieee1275_cell_t) (pos >> (8 * GRUB_IEEE1275_CELL_SIZEOF));
308
 
  args.pos_lo = (grub_ieee1275_cell_t) 
309
 
    (pos & ((1ULL << (8 * GRUB_IEEE1275_CELL_SIZEOF)) - 1));
310
 
#endif
311
 
 
312
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
313
 
    return -1;
314
 
 
315
 
  if (result)
316
 
    *result = args.result;
317
 
  return 0;
318
 
}
319
 
 
320
 
int
321
 
grub_ieee1275_peer (grub_ieee1275_phandle_t node,
322
 
                    grub_ieee1275_phandle_t *result)
323
 
{
324
 
  struct peer_args
325
 
  {
326
 
    struct grub_ieee1275_common_hdr common;
327
 
    grub_ieee1275_cell_t node;
328
 
    grub_ieee1275_cell_t result;
329
 
  }
330
 
  args;
331
 
 
332
 
  INIT_IEEE1275_COMMON (&args.common, "peer", 1, 1);
333
 
  args.node = node;
334
 
 
335
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
336
 
    return -1;
337
 
  *result = args.result;
338
 
  if (args.result == 0)
339
 
    return -1;
340
 
  return 0;
341
 
}
342
 
 
343
 
int
344
 
grub_ieee1275_child (grub_ieee1275_phandle_t node,
345
 
                     grub_ieee1275_phandle_t *result)
346
 
{
347
 
  struct child_args
348
 
  {
349
 
    struct grub_ieee1275_common_hdr common;
350
 
    grub_ieee1275_cell_t node;
351
 
    grub_ieee1275_cell_t result;
352
 
  }
353
 
  args;
354
 
 
355
 
  INIT_IEEE1275_COMMON (&args.common, "child", 1, 1);
356
 
  args.node = node;
357
 
  args.result = IEEE1275_PHANDLE_INVALID;
358
 
 
359
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
360
 
    return -1;
361
 
  *result = args.result;
362
 
  if (args.result == 0)
363
 
    return -1;
364
 
  return 0;
365
 
}
366
 
 
367
 
int
368
 
grub_ieee1275_parent (grub_ieee1275_phandle_t node,
369
 
                      grub_ieee1275_phandle_t *result)
370
 
{
371
 
  struct parent_args
372
 
  {
373
 
    struct grub_ieee1275_common_hdr common;
374
 
    grub_ieee1275_cell_t node;
375
 
    grub_ieee1275_cell_t result;
376
 
  }
377
 
  args;
378
 
 
379
 
  INIT_IEEE1275_COMMON (&args.common, "parent", 1, 1);
380
 
  args.node = node;
381
 
  args.result = IEEE1275_PHANDLE_INVALID;
382
 
 
383
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
384
 
    return -1;
385
 
  *result = args.result;
386
 
  return 0;
387
 
}
388
 
 
389
 
int
390
 
grub_ieee1275_interpret (const char *command, grub_ieee1275_cell_t *catch)
391
 
{
392
 
  struct enter_args
393
 
  {
394
 
    struct grub_ieee1275_common_hdr common;
395
 
    grub_ieee1275_cell_t command;
396
 
    grub_ieee1275_cell_t catch;
397
 
  }
398
 
  args;
399
 
 
400
 
  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_CANNOT_INTERPRET))
401
 
    return -1;
402
 
 
403
 
  INIT_IEEE1275_COMMON (&args.common, "interpret", 1, 1);
404
 
  args.command = (grub_ieee1275_cell_t) command;
405
 
 
406
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
407
 
    return -1;
408
 
  if (catch)
409
 
    *catch = args.catch;
410
 
  return 0;
411
 
}
412
 
 
413
 
int
414
 
grub_ieee1275_enter (void)
415
 
{
416
 
  struct enter_args
417
 
  {
418
 
    struct grub_ieee1275_common_hdr common;
419
 
  }
420
 
  args;
421
 
 
422
 
  INIT_IEEE1275_COMMON (&args.common, "enter", 0, 0);
423
 
 
424
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
425
 
    return -1;
426
 
  return 0;
427
 
}
428
 
 
429
 
void
430
 
grub_ieee1275_exit (void)
431
 
{
432
 
  struct exit_args
433
 
  {
434
 
    struct grub_ieee1275_common_hdr common;
435
 
  }
436
 
  args;
437
 
 
438
 
  INIT_IEEE1275_COMMON (&args.common, "exit", 0, 0);
439
 
 
440
 
  IEEE1275_CALL_ENTRY_FN (&args);
441
 
  for (;;) ;
442
 
}
443
 
 
444
 
int
445
 
grub_ieee1275_open (const char *path, grub_ieee1275_ihandle_t *result)
446
 
{
447
 
  struct open_args
448
 
  {
449
 
    struct grub_ieee1275_common_hdr common;
450
 
    grub_ieee1275_cell_t path;
451
 
    grub_ieee1275_cell_t result;
452
 
  }
453
 
  args;
454
 
 
455
 
  INIT_IEEE1275_COMMON (&args.common, "open", 1, 1);
456
 
  args.path = (grub_ieee1275_cell_t) path;
457
 
 
458
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
459
 
    return -1;
460
 
  *result = args.result;
461
 
  if (args.result == IEEE1275_IHANDLE_INVALID)
462
 
    return -1;
463
 
  return 0;
464
 
}
465
 
 
466
 
int
467
 
grub_ieee1275_close (grub_ieee1275_ihandle_t ihandle)
468
 
{
469
 
  struct close_args
470
 
  {
471
 
    struct grub_ieee1275_common_hdr common;
472
 
    grub_ieee1275_cell_t ihandle;
473
 
  }
474
 
  args;
475
 
 
476
 
  INIT_IEEE1275_COMMON (&args.common, "close", 1, 0);
477
 
  args.ihandle = ihandle;
478
 
 
479
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
480
 
    return -1;
481
 
 
482
 
  return 0;
483
 
}
484
 
 
485
 
int
486
 
grub_ieee1275_claim (grub_addr_t addr, grub_size_t size, unsigned int align,
487
 
                     grub_addr_t *result)
488
 
{
489
 
  struct claim_args
490
 
  {
491
 
    struct grub_ieee1275_common_hdr common;
492
 
    grub_ieee1275_cell_t addr;
493
 
    grub_ieee1275_cell_t size;
494
 
    grub_ieee1275_cell_t align;
495
 
    grub_ieee1275_cell_t base;
496
 
  }
497
 
  args;
498
 
 
499
 
  INIT_IEEE1275_COMMON (&args.common, "claim", 3, 1);
500
 
  args.addr = (grub_ieee1275_cell_t) addr;
501
 
  args.size = (grub_ieee1275_cell_t) size;
502
 
  args.align = (grub_ieee1275_cell_t) align;
503
 
 
504
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
505
 
    return -1;
506
 
  if (result)
507
 
    *result = args.base;
508
 
  if (args.base == IEEE1275_CELL_INVALID)
509
 
    return -1;
510
 
  return 0;
511
 
}
512
 
 
513
 
int
514
 
grub_ieee1275_release (grub_addr_t addr, grub_size_t size)
515
 
{
516
 
 struct release_args
517
 
 {
518
 
    struct grub_ieee1275_common_hdr common;
519
 
    grub_ieee1275_cell_t addr;
520
 
    grub_ieee1275_cell_t size;
521
 
 }
522
 
 args;
523
 
 
524
 
  INIT_IEEE1275_COMMON (&args.common, "release", 2, 0);
525
 
  args.addr = addr;
526
 
  args.size = size;
527
 
 
528
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
529
 
    return -1;
530
 
  return 0;
531
 
}
532
 
 
533
 
int
534
 
grub_ieee1275_set_property (grub_ieee1275_phandle_t phandle,
535
 
                            const char *propname, void *buf,
536
 
                            grub_size_t size, grub_ssize_t *actual)
537
 
{
538
 
  struct set_property_args
539
 
  {
540
 
    struct grub_ieee1275_common_hdr common;
541
 
    grub_ieee1275_cell_t phandle;
542
 
    grub_ieee1275_cell_t propname;
543
 
    grub_ieee1275_cell_t buf;
544
 
    grub_ieee1275_cell_t size;
545
 
    grub_ieee1275_cell_t actual;
546
 
  }
547
 
  args;
548
 
 
549
 
  INIT_IEEE1275_COMMON (&args.common, "setprop", 4, 1);
550
 
  args.size = (grub_ieee1275_cell_t) size;
551
 
  args.buf = (grub_ieee1275_cell_t) buf;
552
 
  args.propname = (grub_ieee1275_cell_t) propname;
553
 
  args.phandle = (grub_ieee1275_cell_t) phandle;
554
 
 
555
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
556
 
    return -1;
557
 
  *actual = args.actual;
558
 
  if ((args.actual == IEEE1275_CELL_INVALID) || (args.actual != args.size))
559
 
    return -1;
560
 
  return 0;
561
 
}
562
 
 
563
 
int
564
 
grub_ieee1275_set_color (grub_ieee1275_ihandle_t ihandle,
565
 
                         int index, int r, int g, int b)
566
 
{
567
 
  struct set_color_args
568
 
  {
569
 
    struct grub_ieee1275_common_hdr common;
570
 
    grub_ieee1275_cell_t method;
571
 
    grub_ieee1275_cell_t ihandle;
572
 
    grub_ieee1275_cell_t index;
573
 
    grub_ieee1275_cell_t b;
574
 
    grub_ieee1275_cell_t g;
575
 
    grub_ieee1275_cell_t r;
576
 
    grub_ieee1275_cell_t catch_result;
577
 
  }
578
 
  args;
579
 
 
580
 
  INIT_IEEE1275_COMMON (&args.common, "call-method", 6, 1);
581
 
  args.method = (grub_ieee1275_cell_t) "color!";
582
 
  args.ihandle = ihandle;
583
 
  args.index = index;
584
 
  args.r = r;
585
 
  args.g = g;
586
 
  args.b = b;
587
 
 
588
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
589
 
    return -1;
590
 
  return args.catch_result;
591
 
}
592
 
 
593
 
int
594
 
grub_ieee1275_milliseconds (grub_uint32_t *msecs)
595
 
{
596
 
  struct milliseconds_args
597
 
  {
598
 
    struct grub_ieee1275_common_hdr common;
599
 
    grub_ieee1275_cell_t msecs;
600
 
  }
601
 
  args;
602
 
 
603
 
  INIT_IEEE1275_COMMON (&args.common, "milliseconds", 0, 1);
604
 
 
605
 
  if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
606
 
    return -1;
607
 
  *msecs = args.msecs;
608
 
  return 0;
609
 
}