commands/memrw.c

   1 /* memrw.c - command to read / write physical memory  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 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/dl.h>
  21 #include <grub/misc.h>
  22 #include <grub/extcmd.h>
  23 #include <grub/env.h>
  24 #include <grub/i18n.h>
  25
  26 static grub_extcmd_t cmd_read_byte, cmd_read_word, cmd_read_dword;
  27 static grub_command_t cmd_write_byte, cmd_write_word, cmd_write_dword;
  28
  29 static const struct grub_arg_option options[] =
  30   {
  31     {0, 'v', 0, N_("Save read value into variable VARNAME."),
  32      "VARNAME", ARG_TYPE_STRING},
  33     {0, 0, 0, 0, 0, 0}
  34   };
  35
  36
  37 static grub_err_t
  38 grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
  39 {
  40   grub_target_addr_t addr;
  41   grub_uint32_t value = 0;
  42   char buf[sizeof ("XXXXXXXX")];
  43
  44   if (argc != 1)
  45     return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid number of arguments");
  46
  47   addr = grub_strtoul (argv[0], 0, 0);
  48   switch (cmd->cmd->name[sizeof ("read_") - 1])
  49     {
  50     case 'd':
  51       value = *((volatile grub_uint32_t *) addr);
  52       break;
  53
  54     case 'w':
  55       value = *((volatile grub_uint16_t *) addr);
  56       break;
  57
  58     case 'b':
  59       value = *((volatile grub_uint8_t *) addr);
  60       break;
  61     }
  62
  63   if (cmd->state[0].set)
  64     {
  65       grub_sprintf (buf, "%x", value);
  66       grub_env_set (cmd->state[0].arg, buf);
  67     }
  68   else
  69     grub_printf ("0x%x\n", value);
  70
  71   return 0;
  72 }
  73
  74 static grub_err_t
  75 grub_cmd_write (grub_command_t cmd, int argc, char **argv)
  76 {
  77   grub_target_addr_t addr;
  78   grub_uint32_t value;
  79   grub_uint32_t mask = 0xffffffff;
  80
  81   if (argc != 2 && argc != 3)
  82     return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid number of arguments");
  83
  84   addr = grub_strtoul (argv[0], 0, 0);
  85   value = grub_strtoul (argv[1], 0, 0);
  86   if (argc == 3)
  87     mask = grub_strtoul (argv[2], 0, 0);
  88   value &= mask;
  89   switch (cmd->name[sizeof ("write_") - 1])
  90     {
  91     case 'd':
  92       if (mask != 0xffffffff)
  93         *((volatile grub_uint32_t *) addr)
  94           = (*((volatile grub_uint32_t *) addr) & ~mask) | value;
  95       else
  96         *((volatile grub_uint32_t *) addr) = value;
  97       break;
  98
  99     case 'w':
 100       if ((mask & 0xffff) != 0xffff)
 101         *((volatile grub_uint16_t *) addr)
 102           = (*((volatile grub_uint16_t *) addr) & ~mask) | value;
 103       else
 104         *((volatile grub_uint16_t *) addr) = value;
 105       break;
 106
 107     case 'b':
 108       if ((mask & 0xff) != 0xff)
 109         *((volatile grub_uint8_t *) addr)
 110           = (*((volatile grub_uint8_t *) addr) & ~mask) | value;
 111       else
 112         *((volatile grub_uint8_t *) addr) = value;
 113       break;
 114     }
 115
 116   return 0;
 117 }
 118
 119 GRUB_MOD_INIT(memrw)
 120 {
 121   cmd_read_byte =
 122     grub_register_extcmd ("read_byte", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
 123                           N_("ADDR"), N_("Read byte from ADDR."), options);
 124   cmd_read_word =
 125     grub_register_extcmd ("read_word", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
 126                           N_("ADDR"), N_("Read word from ADDR."), options);
 127   cmd_read_dword =
 128     grub_register_extcmd ("read_dword", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
 129                           N_("ADDR"), N_("Read dword from ADDR."), options);
 130   cmd_write_byte =
 131     grub_register_command ("write_byte", grub_cmd_write,
 132                            N_("ADDR VALUE [MASK]"), N_("Write byte VALUE to ADDR."));
 133   cmd_write_word =
 134     grub_register_command ("write_word", grub_cmd_write,
 135                            N_("ADDR VALUE [MASK]"), N_("Write word VALUE to ADDR."));
 136   cmd_write_dword =
 137     grub_register_command ("write_dword", grub_cmd_write,
 138                            N_("ADDR VALUE [MASK]"), N_("Write dword VALUE to ADDR."));
 139 }
 140
 141 GRUB_MOD_FINI(memrw)
 142 {
 143   grub_unregister_extcmd (cmd_read_byte);
 144   grub_unregister_extcmd (cmd_read_word);
 145   grub_unregister_extcmd (cmd_read_dword);
 146   grub_unregister_command (cmd_write_byte);
 147   grub_unregister_command (cmd_write_word);
 148   grub_unregister_command (cmd_write_dword);
 149 }