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