1  /* SPDX-License-Identifier: GPL-2.0-only */
  2  
  3  #if defined(__FreeBSD__)
  4  #include <fcntl.h>
  5  #include <unistd.h>
  6  #endif
  7  
  8  #include "common.h"
  9  #include "cmos_lowlevel.h"
 10  
 11  /* Hardware Abstraction Layer: lowlevel byte-wise write access */
 12  
 13  extern cmos_access_t cmos_hal, memory_hal;
 14  static cmos_access_t *current_access =
 15  #ifdef CMOS_HAL
 16  	&cmos_hal;
 17  #else
 18  	&memory_hal;
 19  #endif
 20  
 21  void select_hal(hal_t hal, void *data)
 22  {
 23  	switch(hal) {
 24  #ifdef CMOS_HAL
 25  	case HAL_CMOS:
 26  		current_access = &cmos_hal;
 27  		break;
 28  #endif
 29  	case HAL_MEMORY:
 30  	default:
 31  		current_access = &memory_hal;
 32  		break;
 33  	}
 34  	current_access->init(data);
 35  }
 36  
 37  /* Bit-level access */
 38  typedef struct {
 39  	unsigned byte_index;
 40  	unsigned bit_offset;
 41  } cmos_bit_op_location_t;
 42  
 43  static unsigned cmos_bit_op_strategy(unsigned bit, unsigned bits_left,
 44  				     cmos_bit_op_location_t * where);
 45  static unsigned char cmos_read_bits(const cmos_bit_op_location_t * where,
 46  				    unsigned nr_bits);
 47  static void cmos_write_bits(const cmos_bit_op_location_t * where,
 48  			    unsigned nr_bits, unsigned char value);
 49  static unsigned char get_bits(unsigned long long value, unsigned bit,
 50  			      unsigned nr_bits);
 51  static void put_bits(unsigned char value, unsigned bit, unsigned nr_bits,
 52  		     unsigned long long *result);
 53  
 54  /****************************************************************************
 55   * get_bits
 56   *
 57   * Extract a value 'nr_bits' bits wide starting at bit position 'bit' from
 58   * 'value' and return the result.  It is assumed that 'nr_bits' is at most 8.
 59   ****************************************************************************/
 60  static inline unsigned char get_bits(unsigned long long value, unsigned bit,
 61  				     unsigned nr_bits)
 62  {
 63  	return (value >> bit) & ((unsigned char)((1 << nr_bits) - 1));
 64  }
 65  
 66  /****************************************************************************
 67   * put_bits
 68   *
 69   * Extract the low order 'nr_bits' bits from 'value' and store them in the
 70   * value pointed to by 'result' starting at bit position 'bit'.  The bit
 71   * positions in 'result' where the result is stored are assumed to be
 72   * initially zero.
 73   ****************************************************************************/
 74  static inline void put_bits(unsigned char value, unsigned bit,
 75  			    unsigned nr_bits, unsigned long long *result)
 76  {
 77  	*result += ((unsigned long long)(value &
 78  				((unsigned char)((1 << nr_bits) - 1)))) << bit;
 79  }
 80  
 81  /****************************************************************************
 82   * cmos_read
 83   *
 84   * Read value from nonvolatile RAM at position given by 'bit' and 'length'
 85   * and return this value.  The I/O privilege level of the currently executing
 86   * process must be set appropriately.
 87   *
 88   * Returned value is either (unsigned long long), or malloc()'d (char *)
 89   * cast to (unsigned long long)
 90   ****************************************************************************/
 91  unsigned long long cmos_read(const cmos_entry_t * e)
 92  {
 93  	cmos_bit_op_location_t where;
 94  	unsigned bit = e->bit, length = e->length;
 95  	unsigned next_bit, bits_left, nr_bits;
 96  	unsigned long long result = 0;
 97  	unsigned char value;
 98  
 99  	assert(!verify_cmos_op(bit, length, e->config));
100  
101  	if (e->config == CMOS_ENTRY_STRING) {
102  		int strsz = (length + 7) / 8 + 1;
103  		char *newstring = malloc(strsz);
104  		unsigned usize = (8 * sizeof(unsigned long long));
105  
106  		if (!newstring) {
107  			out_of_memory();
108  		}
109  
110  		memset(newstring, 0, strsz);
111  
112  		for (next_bit = 0, bits_left = length;
113  		     bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
114  			nr_bits = cmos_bit_op_strategy(bit + next_bit,
115  				   bits_left > usize ? usize : bits_left, &where);
116  			value = cmos_read_bits(&where, nr_bits);
117  			put_bits(value, next_bit % usize, nr_bits,
118  				 &((unsigned long long *)newstring)[next_bit /
119  								    usize]);
120  			result = (unsigned long)newstring;
121  		}
122  	} else {
123  		for (next_bit = 0, bits_left = length;
124  		     bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
125  			nr_bits =
126  			    cmos_bit_op_strategy(bit + next_bit, bits_left,
127  						 &where);
128  			value = cmos_read_bits(&where, nr_bits);
129  			put_bits(value, next_bit, nr_bits, &result);
130  		}
131  	}
132  
133  	return result;
134  }
135  
136  /****************************************************************************
137   * cmos_write
138   *
139   * Write 'data' to nonvolatile RAM at position given by 'bit' and 'length'.
140   * The I/O privilege level of the currently executing process must be set
141   * appropriately.
142   ****************************************************************************/
143  void cmos_write(const cmos_entry_t * e, unsigned long long value)
144  {
145  	cmos_bit_op_location_t where;
146  	unsigned bit = e->bit, length = e->length;
147  	unsigned next_bit, bits_left, nr_bits;
148  
149  	assert(!verify_cmos_op(bit, length, e->config));
150  
151  	if (e->config == CMOS_ENTRY_STRING) {
152  		unsigned long long *data =
153  		    (unsigned long long *)(unsigned long)value;
154  		unsigned usize = (8 * sizeof(unsigned long long));
155  
156  		for (next_bit = 0, bits_left = length;
157  		     bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
158  			nr_bits = cmos_bit_op_strategy(bit + next_bit,
159  					bits_left > usize ? usize : bits_left,
160  					&where);
161  			value = data[next_bit / usize];
162  			cmos_write_bits(&where, nr_bits,
163  				get_bits(value, next_bit % usize, nr_bits));
164  		}
165  	} else {
166  		for (next_bit = 0, bits_left = length;
167  		     bits_left; next_bit += nr_bits, bits_left -= nr_bits) {
168  			nr_bits = cmos_bit_op_strategy(bit + next_bit,
169  					bits_left, &where);
170  			cmos_write_bits(&where, nr_bits,
171  					get_bits(value, next_bit, nr_bits));
172  		}
173  	}
174  }
175  
176  /****************************************************************************
177   * cmos_read_byte
178   *
179   * Read a byte from nonvolatile RAM at a position given by 'index' and return
180   * the result.  An 'index' value of 0 represents the first byte of
181   * nonvolatile RAM.
182   *
183   * Note: the first 14 bytes of nonvolatile RAM provide an interface to the
184   *       real time clock.
185   ****************************************************************************/
186  unsigned char cmos_read_byte(unsigned index)
187  {
188  	return current_access->read(index);
189  }
190  
191  /****************************************************************************
192   * cmos_write_byte
193   *
194   * Write 'value' to nonvolatile RAM at a position given by 'index'.  An
195   * 'index' of 0 represents the first byte of nonvolatile RAM.
196   *
197   * Note: the first 14 bytes of nonvolatile RAM provide an interface to the
198   *       real time clock.  Writing to any of these bytes will therefore
199   *       affect its functioning.
200   ****************************************************************************/
201  void cmos_write_byte(unsigned index, unsigned char value)
202  {
203  	current_access->write(index, value);
204  }
205  
206  /****************************************************************************
207   * cmos_read_all
208   *
209   * Read all contents of CMOS memory into array 'data'.  The first 14 bytes of
210   * 'data' are set to zero since this corresponds to the real time clock area.
211   ****************************************************************************/
212  void cmos_read_all(unsigned char data[])
213  {
214  	unsigned i;
215  
216  	for (i = 0; i < CMOS_RTC_AREA_SIZE; i++)
217  		data[i] = 0;
218  
219  	for (; i < CMOS_SIZE; i++)
220  		data[i] = cmos_read_byte(i);
221  }
222  
223  /****************************************************************************
224   * cmos_write_all
225   *
226   * Update all of CMOS memory with the contents of array 'data'.  The first 14
227   * bytes of 'data' are ignored since this corresponds to the real time clock
228   * area.
229   ****************************************************************************/
230  void cmos_write_all(unsigned char data[])
231  {
232  	unsigned i;
233  
234  	for (i = CMOS_RTC_AREA_SIZE; i < CMOS_SIZE; i++)
235  		cmos_write_byte(i, data[i]);
236  }
237  
238  /****************************************************************************
239   * set_iopl
240   *
241   * Set the I/O privilege level of the executing process.  Root privileges are
242   * required for performing this action.  A sufficient I/O privilege level
243   * allows the process to access x86 I/O address space and to disable/reenable
244   * interrupts while executing in user space.  Messing with the I/O privilege
245   * level is therefore somewhat dangerous.
246   ****************************************************************************/
247  void set_iopl(int level)
248  {
249  	current_access->set_iopl(level);
250  }
251  
252  /****************************************************************************
253   * verify_cmos_op
254   *
255   * 'bit' represents a bit position in the nonvolatile RAM.  The first bit
256   * (i.e. the lowest order bit of the first byte) of nonvolatile RAM is
257   * labeled as bit 0.  'length' represents the width in bits of a value we
258   * wish to read or write.  Perform sanity checking on 'bit' and 'length'.  If
259   * no problems were encountered, return OK.  Else return an error code.
260   ****************************************************************************/
261  int verify_cmos_op(unsigned bit, unsigned length, cmos_entry_config_t config)
262  {
263  	if ((bit >= (8 * CMOS_SIZE)) || ((bit + length) > (8 * CMOS_SIZE)))
264  		return CMOS_AREA_OUT_OF_RANGE;
265  
266  	if (bit < (8 * CMOS_RTC_AREA_SIZE))
267  		return CMOS_AREA_OVERLAPS_RTC;
268  
269  	if (config == CMOS_ENTRY_STRING)
270  		return OK;
271  
272  	if (length > (8 * sizeof(unsigned long long)))
273  		return CMOS_AREA_TOO_WIDE;
274  
275  	return OK;
276  }
277  
278  /****************************************************************************
279   * cmos_bit_op_strategy
280   *
281   * Helper function used by cmos_read() and cmos_write() to determine which
282   * bits to read or write next.
283   ****************************************************************************/
284  static unsigned cmos_bit_op_strategy(unsigned bit, unsigned bits_left,
285  				     cmos_bit_op_location_t * where)
286  {
287  	unsigned max_bits;
288  
289  	where->byte_index = bit >> 3;
290  	where->bit_offset = bit & 0x07;
291  	max_bits = 8 - where->bit_offset;
292  	return (bits_left > max_bits) ? max_bits : bits_left;
293  }
294  
295  /****************************************************************************
296   * cmos_read_bits
297   *
298   * Read a chunk of bits from a byte location within CMOS memory.  Return the
299   * value represented by the chunk of bits.
300   ****************************************************************************/
301  static unsigned char cmos_read_bits(const cmos_bit_op_location_t * where,
302  				    unsigned nr_bits)
303  {
304  	return (cmos_read_byte(where->byte_index) >> where->bit_offset) &
305  	    ((unsigned char)((1 << nr_bits) - 1));
306  }
307  
308  /****************************************************************************
309   * cmos_write_bits
310   *
311   * Write a chunk of bits (the low order 'nr_bits' bits of 'value') to an area
312   * within a particular byte of CMOS memory.
313   ****************************************************************************/
314  static void cmos_write_bits(const cmos_bit_op_location_t * where,
315  			    unsigned nr_bits, unsigned char value)
316  {
317  	unsigned char n, mask;
318  
319  	if (nr_bits == 8) {
320  		cmos_write_byte(where->byte_index, value);
321  		return;
322  	}
323  
324  	n = cmos_read_byte(where->byte_index);
325  	mask = ((unsigned char)((1 << nr_bits) - 1)) << where->bit_offset;
326  	n = (n & ~mask) + ((value << where->bit_offset) & mask);
327  	cmos_write_byte(where->byte_index, n);
328  }