/*
 *  VasEBoot  --  GRand Unified Bootloader
 *  Copyright (C) 2012  Free Software Foundation, Inc.
 *
 *  VasEBoot is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VasEBoot is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VasEBoot.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <VasEBoot/types.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/efi/api.h>
#include <VasEBoot/efi/edid.h>
#include <VasEBoot/efi/pci.h>
#include <VasEBoot/efi/efi.h>
#include <VasEBoot/efi/uga_draw.h>
#include <VasEBoot/efi/graphics_output.h>
#include <VasEBoot/efi/console_control.h>
#include <VasEBoot/command.h>

VasEBoot_MOD_LICENSE ("GPLv3+");

struct known_protocol
{
  VasEBoot_efi_guid_t guid;
  const char *name;
} known_protocols[] = 
  {
    { VasEBoot_EFI_DISK_IO_GUID, "disk" },
    { VasEBoot_EFI_BLOCK_IO_GUID, "block" },
    { VasEBoot_EFI_SERIAL_IO_GUID, "serial" },
    { VasEBoot_EFI_SIMPLE_NETWORK_GUID, "network" },
    { VasEBoot_EFI_PXE_GUID, "pxe" },
    { VasEBoot_EFI_DEVICE_PATH_GUID, "device path" },
    { VasEBoot_EFI_PCI_IO_GUID, "PCI" },
    { VasEBoot_EFI_PCI_ROOT_IO_GUID, "PCI root" },
    { VasEBoot_EFI_EDID_ACTIVE_GUID, "active EDID" },
    { VasEBoot_EFI_EDID_DISCOVERED_GUID, "discovered EDID" },
    { VasEBoot_EFI_EDID_OVERRIDE_GUID, "override EDID" },
    { VasEBoot_EFI_GOP_GUID, "GOP" },
    { VasEBoot_EFI_UGA_DRAW_GUID, "UGA draw" },
    { VasEBoot_EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, "simple text output" },
    { VasEBoot_EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, "simple text input" },
    { VasEBoot_EFI_SIMPLE_POINTER_PROTOCOL_GUID, "simple pointer" },
    { VasEBoot_EFI_CONSOLE_CONTROL_GUID, "console control" },
    { VasEBoot_EFI_ABSOLUTE_POINTER_PROTOCOL_GUID, "absolute pointer" },
    { VasEBoot_EFI_DRIVER_BINDING_PROTOCOL_GUID, "EFI driver binding" },
    { VasEBoot_EFI_LOAD_FILE_PROTOCOL_GUID, "load file" },
    { VasEBoot_EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, "simple FS" },
    { VasEBoot_EFI_TAPE_IO_PROTOCOL_GUID, "tape I/O" },
    { VasEBoot_EFI_UNICODE_COLLATION_PROTOCOL_GUID, "unicode collation" },
    { VasEBoot_EFI_SCSI_IO_PROTOCOL_GUID, "SCSI I/O" },
    { VasEBoot_EFI_USB2_HC_PROTOCOL_GUID, "USB host" },
    { VasEBoot_EFI_DEBUG_SUPPORT_PROTOCOL_GUID, "debug support" },
    { VasEBoot_EFI_DEBUGPORT_PROTOCOL_GUID, "debug port" },
    { VasEBoot_EFI_DECOMPRESS_PROTOCOL_GUID, "decompress" },
    { VasEBoot_EFI_LOADED_IMAGE_PROTOCOL_GUID, "loaded image" },
    { VasEBoot_EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID, "device path to text" },
    { VasEBoot_EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID, "device path utilities" },
    { VasEBoot_EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID, "device path from text" },
    { VasEBoot_EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID, "HII config routing" },
    { VasEBoot_EFI_HII_DATABASE_PROTOCOL_GUID, "HII database" },
    { VasEBoot_EFI_HII_STRING_PROTOCOL_GUID, "HII string" },
    { VasEBoot_EFI_HII_IMAGE_PROTOCOL_GUID, "HII image" },
    { VasEBoot_EFI_HII_FONT_PROTOCOL_GUID, "HII font" },
    { VasEBoot_EFI_COMPONENT_NAME2_PROTOCOL_GUID, "component name 2" },
    { VasEBoot_EFI_HII_CONFIGURATION_ACCESS_PROTOCOL_GUID,
      "HII configuration access" },
    { VasEBoot_EFI_USB_IO_PROTOCOL_GUID, "USB I/O" },
  };

static VasEBoot_err_t
VasEBoot_cmd_lsefi (VasEBoot_command_t cmd __attribute__ ((unused)),
		int argc __attribute__ ((unused)),
		char **args __attribute__ ((unused)))
{
  VasEBoot_efi_handle_t *handles;
  VasEBoot_efi_uintn_t num_handles;
  unsigned i, j, k;

  handles = VasEBoot_efi_locate_handle (VasEBoot_EFI_ALL_HANDLES,
				    NULL, NULL, &num_handles);

  for (i = 0; i < num_handles; i++)
    {
      VasEBoot_efi_handle_t handle = handles[i];
      VasEBoot_efi_status_t status;
      VasEBoot_efi_uintn_t num_protocols;
      VasEBoot_efi_packed_guid_t **protocols;
      VasEBoot_efi_device_path_t *dp;

      VasEBoot_printf ("Handle %p\n", handle);

      dp = VasEBoot_efi_get_device_path (handle);
      if (dp)
	{
	  VasEBoot_printf ("  ");
	  VasEBoot_efi_print_device_path (dp);
	}

      status = efi_call_3 (VasEBoot_efi_system_table->boot_services->protocols_per_handle,
			   handle, &protocols, &num_protocols);
      if (status != VasEBoot_EFI_SUCCESS)
	VasEBoot_printf ("Unable to retrieve protocols\n");
      for (j = 0; j < num_protocols; j++)
	{
	  for (k = 0; k < ARRAY_SIZE (known_protocols); k++)
	    if (VasEBoot_memcmp (protocols[j], &known_protocols[k].guid,
			     sizeof (known_protocols[k].guid)) == 0)
		break;
	  if (k < ARRAY_SIZE (known_protocols))
	    VasEBoot_printf ("  %s\n", known_protocols[k].name);
	  else
	    VasEBoot_printf ("  %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
			 protocols[j]->data1,
			 protocols[j]->data2,
			 protocols[j]->data3,
			 (unsigned) protocols[j]->data4[0],
			 (unsigned) protocols[j]->data4[1],
			 (unsigned) protocols[j]->data4[2],
			 (unsigned) protocols[j]->data4[3],
			 (unsigned) protocols[j]->data4[4],
			 (unsigned) protocols[j]->data4[5],
			 (unsigned) protocols[j]->data4[6],
			 (unsigned) protocols[j]->data4[7]);
	}

    }

  return 0;
}

static VasEBoot_command_t cmd;

VasEBoot_MOD_INIT(lsefi)
{
  cmd = VasEBoot_register_command ("lsefi", VasEBoot_cmd_lsefi,
			       NULL, "Display EFI handles.");
}

VasEBoot_MOD_FINI(lsefi)
{
  VasEBoot_unregister_command (cmd);
}