← Back to branch summary

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

« back to all changes in this revision

Viewing changes to grub-core/video/video.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:
grub-core/video/video.c
 
1
/*
 
2
 *  GRUB  --  GRand Unified Bootloader
 
3
 *  Copyright (C) 2006,2007,2008,2009  Free Software Foundation, Inc.
 
4
 *
 
5
 *  GRUB is free software: you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation, either version 3 of the License, or
 
8
 *  (at your option) any later version.
 
9
 *
 
10
 *  GRUB is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#include <grub/video.h>
 
20
#include <grub/types.h>
 
21
#include <grub/dl.h>
 
22
#include <grub/misc.h>
 
23
#include <grub/mm.h>
 
24
 
 
25
/* The list of video adapters registered to system.  */
 
26
grub_video_adapter_t grub_video_adapter_list = NULL;
 
27
 
 
28
/* Active video adapter.  */
 
29
static grub_video_adapter_t grub_video_adapter_active;
 
30
 
 
31
/* Restore back to initial mode (where applicable).  */
 
32
grub_err_t
 
33
grub_video_restore (void)
 
34
{
 
35
  if (grub_video_adapter_active)
 
36
    {
 
37
      grub_video_adapter_active->fini ();
 
38
      if (grub_errno != GRUB_ERR_NONE)
 
39
        return grub_errno;
 
40
 
 
41
      grub_video_adapter_active = 0;
 
42
    }
 
43
  return GRUB_ERR_NONE;
 
44
}
 
45
 
 
46
/* Get information about active video mode.  */
 
47
grub_err_t
 
48
grub_video_get_info (struct grub_video_mode_info *mode_info)
 
49
{
 
50
  if (! grub_video_adapter_active)
 
51
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
52
 
 
53
  /* If mode_info is NULL just report that video adapter is active.  */
 
54
  if (! mode_info)
 
55
    {
 
56
      grub_errno = GRUB_ERR_NONE;
 
57
      return grub_errno;
 
58
    }
 
59
 
 
60
  return grub_video_adapter_active->get_info (mode_info);
 
61
}
 
62
 
 
63
grub_video_driver_id_t
 
64
grub_video_get_driver_id (void)
 
65
{
 
66
  if (! grub_video_adapter_active)
 
67
    return GRUB_VIDEO_DRIVER_NONE;
 
68
  return grub_video_adapter_active->id;
 
69
}
 
70
 
 
71
/* Get information about active video mode.  */
 
72
grub_err_t
 
73
grub_video_get_info_and_fini (struct grub_video_mode_info *mode_info,
 
74
                              void **framebuffer)
 
75
{
 
76
  grub_err_t err;
 
77
 
 
78
  if (! grub_video_adapter_active)
 
79
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
80
 
 
81
  err = grub_video_adapter_active->get_info_and_fini (mode_info, framebuffer);
 
82
  if (err)
 
83
    return err;
 
84
 
 
85
  grub_video_adapter_active = 0;
 
86
  return GRUB_ERR_NONE;
 
87
}
 
88
 
 
89
/* Determine optimized blitting formation for specified video mode info.  */
 
90
enum grub_video_blit_format
 
91
grub_video_get_blit_format (struct grub_video_mode_info *mode_info)
 
92
{
 
93
  /* Check if we have any known 32 bit modes.  */
 
94
  if (mode_info->bpp == 32)
 
95
    {
 
96
      if ((mode_info->red_mask_size == 8)
 
97
          && (mode_info->red_field_pos == 16)
 
98
          && (mode_info->green_mask_size == 8)
 
99
          && (mode_info->green_field_pos == 8)
 
100
          && (mode_info->blue_mask_size == 8)
 
101
          && (mode_info->blue_field_pos == 0))
 
102
        {
 
103
          return GRUB_VIDEO_BLIT_FORMAT_BGRA_8888;
 
104
        }
 
105
      else if ((mode_info->red_mask_size == 8)
 
106
               && (mode_info->red_field_pos == 0)
 
107
               && (mode_info->green_mask_size == 8)
 
108
               && (mode_info->green_field_pos == 8)
 
109
               && (mode_info->blue_mask_size == 8)
 
110
               && (mode_info->blue_field_pos == 16))
 
111
        {
 
112
          return GRUB_VIDEO_BLIT_FORMAT_RGBA_8888;
 
113
        }
 
114
    }
 
115
  /* Check if we have any known 24 bit modes.  */
 
116
  else if (mode_info->bpp == 24)
 
117
    {
 
118
      if ((mode_info->red_mask_size == 8)
 
119
          && (mode_info->red_field_pos == 16)
 
120
          && (mode_info->green_mask_size == 8)
 
121
          && (mode_info->green_field_pos == 8)
 
122
          && (mode_info->blue_mask_size == 8)
 
123
          && (mode_info->blue_field_pos == 0))
 
124
        {
 
125
          return GRUB_VIDEO_BLIT_FORMAT_BGR_888;
 
126
        }
 
127
      else if ((mode_info->red_mask_size == 8)
 
128
               && (mode_info->red_field_pos == 0)
 
129
               && (mode_info->green_mask_size == 8)
 
130
               && (mode_info->green_field_pos == 8)
 
131
               && (mode_info->blue_mask_size == 8)
 
132
               && (mode_info->blue_field_pos == 16))
 
133
        {
 
134
          return GRUB_VIDEO_BLIT_FORMAT_RGB_888;
 
135
        }
 
136
    }
 
137
  /* Check if we have any known 16 bit modes.  */
 
138
  else if (mode_info->bpp == 16)
 
139
    {
 
140
      if ((mode_info->red_mask_size == 5)
 
141
          && (mode_info->red_field_pos == 11)
 
142
          && (mode_info->green_mask_size == 6)
 
143
          && (mode_info->green_field_pos == 5)
 
144
          && (mode_info->blue_mask_size == 5)
 
145
          && (mode_info->blue_field_pos == 0))
 
146
        {
 
147
          return GRUB_VIDEO_BLIT_FORMAT_BGR_565;
 
148
        }
 
149
      else if ((mode_info->red_mask_size == 5)
 
150
               && (mode_info->red_field_pos == 0)
 
151
               && (mode_info->green_mask_size == 6)
 
152
               && (mode_info->green_field_pos == 5)
 
153
               && (mode_info->blue_mask_size == 5)
 
154
               && (mode_info->blue_field_pos == 11))
 
155
        {
 
156
          return GRUB_VIDEO_BLIT_FORMAT_RGB_565;
 
157
        }
 
158
    }
 
159
  else if (mode_info->bpp == 1)
 
160
    return GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED;
 
161
 
 
162
  /* Backup route.  Unknown format.  */
 
163
 
 
164
  /* If there are more than 8 bits per color, assume RGB(A) mode.  */
 
165
  if (mode_info->bpp > 8)
 
166
    {
 
167
      if (mode_info->reserved_mask_size > 0)
 
168
        {
 
169
          return GRUB_VIDEO_BLIT_FORMAT_RGBA;
 
170
        }
 
171
      else
 
172
        {
 
173
          return GRUB_VIDEO_BLIT_FORMAT_RGB;
 
174
        }
 
175
    }
 
176
 
 
177
  /* Assume as indexcolor mode.  */
 
178
  return GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR;
 
179
}
 
180
 
 
181
/* Set new indexed color palette entries.  */
 
182
grub_err_t
 
183
grub_video_set_palette (unsigned int start, unsigned int count,
 
184
                        struct grub_video_palette_data *palette_data)
 
185
{
 
186
  if (! grub_video_adapter_active)
 
187
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
188
 
 
189
  return grub_video_adapter_active->set_palette (start, count, palette_data);
 
190
}
 
191
 
 
192
/* Get indexed color palette entries.  */
 
193
grub_err_t
 
194
grub_video_get_palette (unsigned int start, unsigned int count,
 
195
                        struct grub_video_palette_data *palette_data)
 
196
{
 
197
  if (! grub_video_adapter_active)
 
198
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
199
 
 
200
  return grub_video_adapter_active->get_palette (start, count, palette_data);
 
201
}
 
202
 
 
203
/* Set viewport dimensions.  */
 
204
grub_err_t
 
205
grub_video_set_viewport (unsigned int x, unsigned int y,
 
206
                         unsigned int width, unsigned int height)
 
207
{
 
208
  if (! grub_video_adapter_active)
 
209
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
210
 
 
211
  return grub_video_adapter_active->set_viewport (x, y, width, height);
 
212
}
 
213
 
 
214
/* Get viewport dimensions.  */
 
215
grub_err_t
 
216
grub_video_get_viewport (unsigned int *x, unsigned int *y,
 
217
                         unsigned int *width, unsigned int *height)
 
218
{
 
219
  if (! grub_video_adapter_active)
 
220
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
221
 
 
222
  return grub_video_adapter_active->get_viewport (x, y, width, height);
 
223
}
 
224
 
 
225
/* Map color name to adapter specific color.  */
 
226
grub_video_color_t
 
227
grub_video_map_color (grub_uint32_t color_name)
 
228
{
 
229
  if (! grub_video_adapter_active)
 
230
    return 0;
 
231
 
 
232
  return grub_video_adapter_active->map_color (color_name);
 
233
}
 
234
 
 
235
/* Map RGB value to adapter specific color.  */
 
236
grub_video_color_t
 
237
grub_video_map_rgb (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue)
 
238
{
 
239
  if (! grub_video_adapter_active)
 
240
    return 0;
 
241
 
 
242
  return grub_video_adapter_active->map_rgb (red, green, blue);
 
243
}
 
244
 
 
245
/* Map RGBA value to adapter specific color.  */
 
246
grub_video_color_t
 
247
grub_video_map_rgba (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue,
 
248
                     grub_uint8_t alpha)
 
249
{
 
250
  if (! grub_video_adapter_active)
 
251
    return 0;
 
252
 
 
253
  return grub_video_adapter_active->map_rgba (red, green, blue, alpha);
 
254
}
 
255
 
 
256
/* Unmap video color back to RGBA components.  */
 
257
grub_err_t
 
258
grub_video_unmap_color (grub_video_color_t color, grub_uint8_t *red,
 
259
                        grub_uint8_t *green, grub_uint8_t *blue,
 
260
                        grub_uint8_t *alpha)
 
261
{
 
262
  if (! grub_video_adapter_active)
 
263
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
264
 
 
265
  return grub_video_adapter_active->unmap_color (color,
 
266
                                                 red,
 
267
                                                 green,
 
268
                                                 blue,
 
269
                                                 alpha);
 
270
}
 
271
 
 
272
/* Fill rectangle using specified color.  */
 
273
grub_err_t
 
274
grub_video_fill_rect (grub_video_color_t color, int x, int y,
 
275
                      unsigned int width, unsigned int height)
 
276
{
 
277
  if (! grub_video_adapter_active)
 
278
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
279
 
 
280
  return grub_video_adapter_active->fill_rect (color, x, y, width, height);
 
281
}
 
282
 
 
283
/* Blit bitmap to screen.  */
 
284
grub_err_t
 
285
grub_video_blit_bitmap (struct grub_video_bitmap *bitmap,
 
286
                        enum grub_video_blit_operators oper,
 
287
                        int x, int y, int offset_x, int offset_y,
 
288
                        unsigned int width, unsigned int height)
 
289
{
 
290
  if (! grub_video_adapter_active)
 
291
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
292
 
 
293
  return grub_video_adapter_active->blit_bitmap (bitmap, oper, x, y,
 
294
                                                 offset_x, offset_y,
 
295
                                                 width, height);
 
296
}
 
297
 
 
298
/* Blit render target to active render target.  */
 
299
grub_err_t
 
300
grub_video_blit_render_target (struct grub_video_render_target *target,
 
301
                               enum grub_video_blit_operators oper,
 
302
                               int x, int y, int offset_x, int offset_y,
 
303
                               unsigned int width, unsigned int height)
 
304
{
 
305
  if (! grub_video_adapter_active)
 
306
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
307
 
 
308
  return grub_video_adapter_active->blit_render_target (target, oper, x, y,
 
309
                                                        offset_x, offset_y,
 
310
                                                        width, height);
 
311
}
 
312
 
 
313
/* Scroll viewport and fill new areas with specified color.  */
 
314
grub_err_t
 
315
grub_video_scroll (grub_video_color_t color, int dx, int dy)
 
316
{
 
317
  if (! grub_video_adapter_active)
 
318
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
319
 
 
320
  return grub_video_adapter_active->scroll (color, dx, dy);
 
321
}
 
322
 
 
323
/* Swap buffers (swap active render target).  */
 
324
grub_err_t
 
325
grub_video_swap_buffers (void)
 
326
{
 
327
  if (! grub_video_adapter_active)
 
328
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
329
 
 
330
  return grub_video_adapter_active->swap_buffers ();
 
331
}
 
332
 
 
333
/* Create new render target.  */
 
334
grub_err_t
 
335
grub_video_create_render_target (struct grub_video_render_target **result,
 
336
                                 unsigned int width, unsigned int height,
 
337
                                 unsigned int mode_type)
 
338
{
 
339
  if (! grub_video_adapter_active)
 
340
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
341
 
 
342
  return grub_video_adapter_active->create_render_target (result,
 
343
                                                          width, height,
 
344
                                                          mode_type);
 
345
}
 
346
 
 
347
/* Delete render target.  */
 
348
grub_err_t
 
349
grub_video_delete_render_target (struct grub_video_render_target *target)
 
350
{
 
351
  if (! grub_video_adapter_active)
 
352
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
353
 
 
354
  return grub_video_adapter_active->delete_render_target (target);
 
355
}
 
356
 
 
357
/* Set active render target.  */
 
358
grub_err_t
 
359
grub_video_set_active_render_target (struct grub_video_render_target *target)
 
360
{
 
361
  if (! grub_video_adapter_active)
 
362
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
363
 
 
364
  return grub_video_adapter_active->set_active_render_target (target);
 
365
}
 
366
 
 
367
/* Get active render target.  */
 
368
grub_err_t
 
369
grub_video_get_active_render_target (struct grub_video_render_target **target)
 
370
{
 
371
  if (! grub_video_adapter_active)
 
372
    return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
 
373
 
 
374
  return grub_video_adapter_active->get_active_render_target (target);
 
375
}
 
376
 
 
377
/* Parse <width>x<height>[x<depth>]*/
 
378
static grub_err_t
 
379
parse_modespec (const char *current_mode, int *width, int *height, int *depth)
 
380
{
 
381
  const char *value;
 
382
  const char *param = current_mode;
 
383
 
 
384
  *width = *height = *depth = -1;
 
385
 
 
386
  if (grub_strcmp (param, "auto") == 0)
 
387
    {
 
388
      *width = *height = 0;
 
389
      return GRUB_ERR_NONE;
 
390
    }
 
391
 
 
392
  /* Find width value.  */
 
393
  value = param;
 
394
  param = grub_strchr(param, 'x');
 
395
  if (param == NULL)
 
396
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
397
                       "Invalid mode: %s\n",
 
398
                       current_mode);
 
399
 
 
400
  param++;
 
401
  
 
402
  *width = grub_strtoul (value, 0, 0);
 
403
  if (grub_errno != GRUB_ERR_NONE)
 
404
      return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
405
                         "Invalid mode: %s\n",
 
406
                         current_mode);
 
407
  
 
408
  /* Find height value.  */
 
409
  value = param;
 
410
  param = grub_strchr(param, 'x');
 
411
  if (param == NULL)
 
412
    {
 
413
      *height = grub_strtoul (value, 0, 0);
 
414
      if (grub_errno != GRUB_ERR_NONE)
 
415
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
416
                           "Invalid mode: %s\n",
 
417
                           current_mode);
 
418
    }
 
419
  else
 
420
    {
 
421
      /* We have optional color depth value.  */
 
422
      param++;
 
423
      
 
424
      *height = grub_strtoul (value, 0, 0);
 
425
      if (grub_errno != GRUB_ERR_NONE)
 
426
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
427
                           "Invalid mode: %s\n",
 
428
                           current_mode);
 
429
      
 
430
      /* Convert color depth value.  */
 
431
      value = param;
 
432
      *depth = grub_strtoul (value, 0, 0);
 
433
      if (grub_errno != GRUB_ERR_NONE)
 
434
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
435
                           "Invalid mode: %s\n",
 
436
                           current_mode);
 
437
    }
 
438
  return GRUB_ERR_NONE;
 
439
}
 
440
 
 
441
grub_err_t
 
442
grub_video_set_mode (const char *modestring,
 
443
                     unsigned int modemask,
 
444
                     unsigned int modevalue)
 
445
{
 
446
  char *tmp;
 
447
  char *next_mode;
 
448
  char *current_mode;
 
449
  char *modevar;
 
450
 
 
451
  modevalue &= modemask;
 
452
 
 
453
  /* Take copy of env.var. as we don't want to modify that.  */
 
454
  modevar = grub_strdup (modestring);
 
455
 
 
456
  /* Initialize next mode.  */
 
457
  next_mode = modevar;
 
458
 
 
459
  if (! modevar)
 
460
    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
 
461
                       "couldn't allocate space for local modevar copy");
 
462
 
 
463
  if (grub_memcmp (next_mode, "keep", sizeof ("keep")) == 0
 
464
      || grub_memcmp (next_mode, "keep,", sizeof ("keep,") - 1) == 0
 
465
      || grub_memcmp (next_mode, "keep;", sizeof ("keep;") - 1) == 0)
 
466
    {
 
467
      int suitable = 1;
 
468
      grub_err_t err;
 
469
 
 
470
      if (grub_video_adapter_active)
 
471
        {
 
472
          struct grub_video_mode_info mode_info;
 
473
          grub_memset (&mode_info, 0, sizeof (mode_info));
 
474
          err = grub_video_get_info (&mode_info);
 
475
          if (err)
 
476
            {
 
477
              suitable = 0;
 
478
              grub_errno = GRUB_ERR_NONE;
 
479
            }
 
480
          if ((mode_info.mode_type & modemask) != modevalue)
 
481
            suitable = 0;
 
482
        }
 
483
      else if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
 
484
               && ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
 
485
        suitable = 0;
 
486
 
 
487
      if (suitable)
 
488
        {
 
489
          grub_free (modevar);
 
490
          return GRUB_ERR_NONE;
 
491
        }
 
492
      next_mode += sizeof ("keep") - 1;
 
493
      if (! *next_mode)
 
494
        {
 
495
          grub_free (modevar);
 
496
 
 
497
          return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
498
                             "no suitable mode found");
 
499
        }
 
500
 
 
501
      /* Skip separator. */
 
502
      next_mode++;
 
503
    }
 
504
 
 
505
  /* De-activate last set video adapter.  */
 
506
  if (grub_video_adapter_active)
 
507
    {
 
508
      /* Finalize adapter.  */
 
509
      grub_video_adapter_active->fini ();
 
510
      if (grub_errno != GRUB_ERR_NONE)
 
511
        grub_errno = GRUB_ERR_NONE;
 
512
 
 
513
      /* Mark active adapter as not set.  */
 
514
      grub_video_adapter_active = 0;
 
515
    }
 
516
 
 
517
  /* Loop until all modes has been tested out.  */
 
518
  while (next_mode != NULL)
 
519
    {
 
520
      int width = -1;
 
521
      int height = -1;
 
522
      int depth = -1;
 
523
      grub_err_t err;
 
524
      unsigned int flags = modevalue;
 
525
      unsigned int flagmask = modemask;
 
526
 
 
527
      /* Use last next_mode as current mode.  */
 
528
      tmp = next_mode;
 
529
 
 
530
      /* Save position of next mode and separate modes.  */
 
531
      for (; *next_mode; next_mode++)
 
532
        if (*next_mode == ',' || *next_mode == ';')
 
533
          break;
 
534
      if (*next_mode)
 
535
        {
 
536
          *next_mode = 0;
 
537
          next_mode++;
 
538
        }
 
539
      else
 
540
        next_mode = 0;
 
541
 
 
542
      /* Skip whitespace.  */
 
543
      while (grub_isspace (*tmp))
 
544
        tmp++;
 
545
 
 
546
      /* Initialize token holders.  */
 
547
      current_mode = tmp;
 
548
 
 
549
      /* XXX: we assume that we're in pure text mode if
 
550
         no video mode is initialized. Is it always true? */
 
551
      if (grub_strcmp (current_mode, "text") == 0)
 
552
        {
 
553
          struct grub_video_mode_info mode_info;
 
554
 
 
555
          grub_memset (&mode_info, 0, sizeof (mode_info));
 
556
          if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) == 0)
 
557
              || ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) != 0))
 
558
            {
 
559
              /* Valid mode found from adapter, and it has been activated.
 
560
                 Specify it as active adapter.  */
 
561
              grub_video_adapter_active = NULL;
 
562
 
 
563
              /* Free memory.  */
 
564
              grub_free (modevar);
 
565
 
 
566
              return GRUB_ERR_NONE;
 
567
            }
 
568
        }
 
569
 
 
570
      err = parse_modespec (current_mode, &width, &height, &depth);
 
571
      if (err)
 
572
        {
 
573
          /* Free memory before returning.  */
 
574
          grub_free (modevar);
 
575
 
 
576
          return err;
 
577
        }
 
578
 
 
579
      /* Try out video mode.  */
 
580
 
 
581
      /* If user requested specific depth check if this depth is supported.  */
 
582
      if (depth != -1 && (flagmask & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
 
583
          &&
 
584
          (((flags & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
 
585
            != ((depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
 
586
                & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK))))
 
587
        continue;
 
588
 
 
589
      if (depth != -1)
 
590
        {
 
591
          flags |= (depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
 
592
            & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
 
593
          flagmask |= GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
 
594
        }
 
595
 
 
596
      /* Try to initialize requested mode.  Ignore any errors.  */
 
597
      grub_video_adapter_t p;
 
598
 
 
599
      /* Loop thru all possible video adapter trying to find requested mode.  */
 
600
      for (p = grub_video_adapter_list; p; p = p->next)
 
601
        {
 
602
          struct grub_video_mode_info mode_info;
 
603
 
 
604
          grub_memset (&mode_info, 0, sizeof (mode_info));
 
605
 
 
606
          /* Try to initialize adapter, if it fails, skip to next adapter.  */
 
607
          err = p->init ();
 
608
          if (err != GRUB_ERR_NONE)
 
609
            {
 
610
              grub_errno = GRUB_ERR_NONE;
 
611
              continue;
 
612
            }
 
613
 
 
614
          /* Try to initialize video mode.  */
 
615
          err = p->setup (width, height, flags, flagmask);
 
616
          if (err != GRUB_ERR_NONE)
 
617
            {
 
618
              p->fini ();
 
619
              grub_errno = GRUB_ERR_NONE;
 
620
              continue;
 
621
            }
 
622
 
 
623
          err = p->get_info (&mode_info);
 
624
          if (err != GRUB_ERR_NONE)
 
625
            {
 
626
              p->fini ();
 
627
              grub_errno = GRUB_ERR_NONE;
 
628
              continue;
 
629
            }
 
630
 
 
631
          flags = mode_info.mode_type & ~GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
 
632
          flags |= (mode_info.bpp << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
 
633
            & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
 
634
 
 
635
          /* Check that mode is suitable for upper layer.  */
 
636
          if ((flags & GRUB_VIDEO_MODE_TYPE_PURE_TEXT)
 
637
              ? (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
 
638
                 && ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
 
639
              : ((flags & modemask) != modevalue))
 
640
            {
 
641
              p->fini ();
 
642
              grub_errno = GRUB_ERR_NONE;
 
643
              continue;
 
644
            }
 
645
 
 
646
          /* Valid mode found from adapter, and it has been activated.
 
647
             Specify it as active adapter.  */
 
648
          grub_video_adapter_active = p;
 
649
 
 
650
          /* Free memory.  */
 
651
          grub_free (modevar);
 
652
 
 
653
          return GRUB_ERR_NONE;
 
654
        }
 
655
 
 
656
    }
 
657
 
 
658
  /* Free memory.  */
 
659
  grub_free (modevar);
 
660
 
 
661
  return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
662
                     "no suitable mode found");
 
663
}
 
664
 
 
665
/* Initialize Video API module.  */
 
666
GRUB_MOD_INIT(video)
 
667
{
 
668
}
 
669
 
 
670
/* Finalize Video API module.  */
 
671
GRUB_MOD_FINI(video)
 
672
{
 
673
}