util/nvramtool/cmos_lowlevel.c

   1 /*****************************************************************************\
   2  * cmos_lowlevel.c
   3  *****************************************************************************
   4  *  Copyright (C) 2002-2005 The Regents of the University of California.
   5  *  Produced at the Lawrence Livermore National Laboratory.
   6  *  Written by David S. Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>.
   7  *  UCRL-CODE-2003-012
   8  *  All rights reserved.
   9  *
  10  *  This file is part of nvramtool, a utility for reading/writing coreboot
  11  *  parameters and displaying information from the coreboot table.
  12  *  For details, see http://coreboot.org/nvramtool.
  13  *
  14  *  Please also read the file DISCLAIMER which is included in this software
  15  *  distribution.
  16  *
  17  *  This program is free software; you can redistribute it and/or modify it
  18  *  under the terms of the GNU General Public License (as published by the
  19  *  Free Software Foundation) version 2, dated June 1991.
  20  *
  21  *  This program is distributed in the hope that it will be useful, but
  22  *  WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the terms and
  24  *  conditions of the GNU General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU General Public License along
  27  *  with this program; if not, write to the Free Software Foundation, Inc.,
  28  *  51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  29 \*****************************************************************************/
  30
  31 #if defined(__FreeBSD__)
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #endif
  35
  36 #include "common.h"
  37 #include "cmos_lowlevel.h"
  38
  39 /* Hardware Abstraction Layer: lowlevel byte-wise write access */
  40 typedef struct {
  41         void (*init)(void* data);
  42         unsigned char (*read)(unsigned addr);
  43         void (*write)(unsigned addr, unsigned char value);
  44 } cmos_access_t;
  45
  46 static void cmos_hal_init(void* data);
  47 static unsigned char cmos_hal_read(unsigned addr);
  48 static void cmos_hal_write(unsigned addr, unsigned char value);
  49
  50 static cmos_access_t cmos_hal = {
  51         .init = cmos_hal_init,
  52         .read = cmos_hal_read,
  53         .write = cmos_hal_write
  54 };
  55
  56 static cmos_access_t *current_access = &cmos_hal;
  57
  58 /* no need to initialize anything */
  59 static void cmos_hal_init(__attribute__((unused)) void *data)
  60 {
  61 }
  62
  63 static unsigned char cmos_hal_read(unsigned index)
  64 {
  65         unsigned short port_0, port_1;
  66
  67         assert(!verify_cmos_byte_index(index));
  68
  69         if (index < 128) {
  70                 port_0 = 0x70;
  71                 port_1 = 0x71;
  72         } else {
  73                 port_0 = 0x72;
  74                 port_1 = 0x73;
  75         }
  76
  77         OUTB(index, port_0);
  78         return INB(port_1);
  79 }
  80
  81 static void cmos_hal_write(unsigned index, unsigned char value)
  82 {
  83         unsigned short port_0, port_1;
  84
  85         assert(!verify_cmos_byte_index(index));
  86
  87         if (index < 128) {
  88                 port_0 = 0x70;
  89                 port_1 = 0x71;
  90         } else {
  91                 port_0 = 0x72;
  92                 port_1 = 0x73;
  93         }
  94
  95         OUTB(index, port_0);
  96         OUTB(value, port_1);
  97 }
  98
  99 /* Bit-level access */
 100 typedef struct {
 101         unsigned byte_index;
 102         unsigned bit_offset;
 103 } cmos_bit_op_location_t;
 104
 105 static unsigned cmos_bit_op_strategy(unsigned bit, unsigned bits_left,
 106                                      cmos_bit_op_location_t * where);
 107 static unsigned char cmos_read_bits(const cmos_bit_op_location_t * where,
 108                                     unsigned nr_bits);
 109 static void cmos_write_bits(const cmos_bit_op_location_t * where,
 110                             unsigned nr_bits, unsigned char value);
 111 static unsigned char get_bits(unsigned long long value, unsigned bit,
 112                               unsigned nr_bits);
 113 static void put_bits(unsigned char value, unsigned bit, unsigned nr_bits,
 114                      unsigned long long *result);
 115
 116 /****************************************************************************
 117  * get_bits
 118  *
 119  * Extract a value 'nr_bits' bits wide starting at bit position 'bit' from
 120  * 'value' and return the result.  It is assumed that 'nr_bits' is at most 8.
 121  ****************************************************************************/
 122 static inline unsigned char get_bits(unsigned long long value, unsigned bit,
 123                                      unsigned nr_bits)
 124 {
 125         return (value >> bit) & ((unsigned char)((1 << nr_bits) - 1));
 126 }
 127
 128 /****************************************************************************
 129  * put_bits
 130  *
 131  * Extract the low order 'nr_bits' bits from 'value' and store them in the
 132  * value pointed to by 'result' starting at bit position 'bit'.  The bit
 133  * positions in 'result' where the result is stored are assumed to be
 134  * initially zero.
 135  ****************************************************************************/
 136 static inline void put_bits(unsigned char value, unsigned bit,
 137                             unsigned nr_bits, unsigned long long *result)
 138 {
 139         *result += ((unsigned long long)(value &
 140                                 ((unsigned char)((1 << nr_bits) - 1)))) << bit;
 141 }
 142
 143 /****************************************************************************
 144  * cmos_read
 145  *
 146  * Read value from nonvolatile RAM at position given by 'bit' and 'length'
 147  * and return this value.  The I/O privilege level of the currently executing
 148  * process must be set appropriately.
 149  ****************************************************************************/
 150 unsigned long long cmos_read(const cmos_entry_t * e)
 151 {
 152         cmos_bit_op_location_t where;
 153         unsigned bit = e->bit, length = e->length;
 154         unsigned next_bit, bits_left, nr_bits;
 155         unsigned long long result = 0;
 156         unsigned char value;
 157
 158         assert(!verify_cmos_op(bit, length, e->config));
 159         result = 0;
 160
 161         if (e->config == CMOS_ENTRY_STRING) {
 162                 char *newstring = calloc(1, (length + 7) / 8);
 163                 unsigned usize = (8 * sizeof(unsigned long long));
 164
 165                 if (!newstring) {
 166                         out_of_memory();
 167                 }
 168
 169                 for (next_bit = 0, bits_left = length;
 170                      bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
 171                         nr_bits = cmos_bit_op_strategy(bit + next_bit,
 172                                    bits_left > usize ? usize : bits_left, &where);
 173                         value = cmos_read_bits(&where, nr_bits);
 174                         put_bits(value, next_bit % usize, nr_bits,
 175                                  &((unsigned long long *)newstring)[next_bit /
 176                                                                     usize]);
 177                         result = (unsigned long)newstring;
 178                 }
 179         } else {
 180                 for (next_bit = 0, bits_left = length;
 181                      bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
 182                         nr_bits =
 183                             cmos_bit_op_strategy(bit + next_bit, bits_left,
 184                                                  &where);
 185                         value = cmos_read_bits(&where, nr_bits);
 186                         put_bits(value, next_bit, nr_bits, &result);
 187                 }
 188         }
 189
 190         return result;
 191 }
 192
 193 /****************************************************************************
 194  * cmos_write
 195  *
 196  * Write 'data' to nonvolatile RAM at position given by 'bit' and 'length'.
 197  * The I/O privilege level of the currently executing process must be set
 198  * appropriately.
 199  ****************************************************************************/
 200 void cmos_write(const cmos_entry_t * e, unsigned long long value)
 201 {
 202         cmos_bit_op_location_t where;
 203         unsigned bit = e->bit, length = e->length;
 204         unsigned next_bit, bits_left, nr_bits;
 205
 206         assert(!verify_cmos_op(bit, length, e->config));
 207
 208         if (e->config == CMOS_ENTRY_STRING) {
 209                 unsigned long long *data =
 210                     (unsigned long long *)(unsigned long)value;
 211                 unsigned usize = (8 * sizeof(unsigned long long));
 212
 213                 for (next_bit = 0, bits_left = length;
 214                      bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
 215                         nr_bits = cmos_bit_op_strategy(bit + next_bit,
 216                                         bits_left > usize ? usize : bits_left,
 217                                         &where);
 218                         value = data[next_bit / usize];
 219                         cmos_write_bits(&where, nr_bits,
 220                                 get_bits(value, next_bit % usize, nr_bits));
 221                 }
 222         } else {
 223                 for (next_bit = 0, bits_left = length;
 224                      bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
 225                         nr_bits = cmos_bit_op_strategy(bit + next_bit,
 226                                         bits_left, &where);
 227                         cmos_write_bits(&where, nr_bits,
 228                                         get_bits(value, next_bit, nr_bits));
 229                 }
 230         }
 231 }
 232
 233 /****************************************************************************
 234  * cmos_read_byte
 235  *
 236  * Read a byte from nonvolatile RAM at a position given by 'index' and return
 237  * the result.  An 'index' value of 0 represents the first byte of
 238  * nonvolatile RAM.
 239  *
 240  * Note: the first 14 bytes of nonvolatile RAM provide an interface to the
 241  *       real time clock.
 242  ****************************************************************************/
 243 unsigned char cmos_read_byte(unsigned index)
 244 {
 245         return current_access->read(index);
 246 }
 247
 248 /****************************************************************************
 249  * cmos_write_byte
 250  *
 251  * Write 'value' to nonvolatile RAM at a position given by 'index'.  An
 252  * 'index' of 0 represents the first byte of nonvolatile RAM.
 253  *
 254  * Note: the first 14 bytes of nonvolatile RAM provide an interface to the
 255  *       real time clock.  Writing to any of these bytes will therefore
 256  *       affect its functioning.
 257  ****************************************************************************/
 258 void cmos_write_byte(unsigned index, unsigned char value)
 259 {
 260         current_access->write(index, value);
 261 }
 262
 263 /****************************************************************************
 264  * cmos_read_all
 265  *
 266  * Read all contents of CMOS memory into array 'data'.  The first 14 bytes of
 267  * 'data' are set to zero since this corresponds to the real time clock area.
 268  ****************************************************************************/
 269 void cmos_read_all(unsigned char data[])
 270 {
 271         unsigned i;
 272
 273         for (i = 0; i < CMOS_RTC_AREA_SIZE; i++)
 274                 data[i] = 0;
 275
 276         for (; i < CMOS_SIZE; i++)
 277                 data[i] = cmos_read_byte(i);
 278 }
 279
 280 /****************************************************************************
 281  * cmos_write_all
 282  *
 283  * Update all of CMOS memory with the contents of array 'data'.  The first 14
 284  * bytes of 'data' are ignored since this corresponds to the real time clock
 285  * area.
 286  ****************************************************************************/
 287 void cmos_write_all(unsigned char data[])
 288 {
 289         unsigned i;
 290
 291         for (i = CMOS_RTC_AREA_SIZE; i < CMOS_SIZE; i++)
 292                 cmos_write_byte(i, data[i]);
 293 }
 294
 295 /****************************************************************************
 296  * set_iopl
 297  *
 298  * Set the I/O privilege level of the executing process.  Root privileges are
 299  * required for performing this action.  A sufficient I/O privilege level
 300  * allows the process to access x86 I/O address space and to disable/reenable
 301  * interrupts while executing in user space.  Messing with the I/O privilege
 302  * level is therefore somewhat dangerous.
 303  ****************************************************************************/
 304 void set_iopl(int level)
 305 {
 306 #if defined(__FreeBSD__)
 307         static int io_fd = -1;
 308 #endif
 309
 310         assert((level >= 0) && (level <= 3));
 311
 312 #if defined(__FreeBSD__)
 313         if (level == 0) {
 314                 if (io_fd != -1) {
 315                         close(io_fd);
 316                         io_fd = -1;
 317                 }
 318         } else {
 319                 if (io_fd == -1) {
 320                         io_fd = open("/dev/io", O_RDWR);
 321                         if (io_fd < 0) {
 322                                 perror("/dev/io");
 323                                 exit(1);
 324                         }
 325                 }
 326         }
 327 #else
 328         if (iopl(level)) {
 329                 fprintf(stderr, "%s: iopl() system call failed.  "
 330                         "You must be root to do this.\n", prog_name);
 331                 exit(1);
 332         }
 333 #endif
 334 }
 335
 336 /****************************************************************************
 337  * verify_cmos_op
 338  *
 339  * 'bit' represents a bit position in the nonvolatile RAM.  The first bit
 340  * (i.e. the lowest order bit of the first byte) of nonvolatile RAM is
 341  * labeled as bit 0.  'length' represents the width in bits of a value we
 342  * wish to read or write.  Perform sanity checking on 'bit' and 'length'.  If
 343  * no problems were encountered, return OK.  Else return an error code.
 344  ****************************************************************************/
 345 int verify_cmos_op(unsigned bit, unsigned length, cmos_entry_config_t config)
 346 {
 347         if ((bit >= (8 * CMOS_SIZE)) || ((bit + length) > (8 * CMOS_SIZE)))
 348                 return CMOS_AREA_OUT_OF_RANGE;
 349
 350         if (bit < (8 * CMOS_RTC_AREA_SIZE))
 351                 return CMOS_AREA_OVERLAPS_RTC;
 352
 353         if (config == CMOS_ENTRY_STRING)
 354                 return OK;
 355
 356         if (length > (8 * sizeof(unsigned long long)))
 357                 return CMOS_AREA_TOO_WIDE;
 358
 359         return OK;
 360 }
 361
 362 /****************************************************************************
 363  * cmos_bit_op_strategy
 364  *
 365  * Helper function used by cmos_read() and cmos_write() to determine which
 366  * bits to read or write next.
 367  ****************************************************************************/
 368 static unsigned cmos_bit_op_strategy(unsigned bit, unsigned bits_left,
 369                                      cmos_bit_op_location_t * where)
 370 {
 371         unsigned max_bits;
 372
 373         where->byte_index = bit >> 3;
 374         where->bit_offset = bit & 0x07;
 375         max_bits = 8 - where->bit_offset;
 376         return (bits_left > max_bits) ? max_bits : bits_left;
 377 }
 378
 379 /****************************************************************************
 380  * cmos_read_bits
 381  *
 382  * Read a chunk of bits from a byte location within CMOS memory.  Return the
 383  * value represented by the chunk of bits.
 384  ****************************************************************************/
 385 static unsigned char cmos_read_bits(const cmos_bit_op_location_t * where,
 386                                     unsigned nr_bits)
 387 {
 388         return (cmos_read_byte(where->byte_index) >> where->bit_offset) &
 389             ((unsigned char)((1 << nr_bits) - 1));
 390 }
 391
 392 /****************************************************************************
 393  * cmos_write_bits
 394  *
 395  * Write a chunk of bits (the low order 'nr_bits' bits of 'value') to an area
 396  * within a particular byte of CMOS memory.
 397  ****************************************************************************/
 398 static void cmos_write_bits(const cmos_bit_op_location_t * where,
 399                             unsigned nr_bits, unsigned char value)
 400 {
 401         unsigned char n, mask;
 402
 403         if (nr_bits == 8) {
 404                 cmos_write_byte(where->byte_index, value);
 405                 return;
 406         }
 407
 408         n = cmos_read_byte(where->byte_index);
 409         mask = ((unsigned char)((1 << nr_bits) - 1)) << where->bit_offset;
 410         n = (n & ~mask) + ((value << where->bit_offset) & mask);
 411         cmos_write_byte(where->byte_index, n);
 412 }