1  /* SPDX-License-Identifier: GPL-2.0-only */
  2  
  3  #include <base3.h>
  4  #include <console/console.h>
  5  #include <delay.h>
  6  #include <gpio.h>
  7  
  8  static void _check_num(const char *name, int num)
  9  {
 10  	if ((num > 31) || (num < 1)) {
 11  		printk(BIOS_EMERG, "%s: %d ", name, num);
 12  		die("is an invalid number of GPIOs");
 13  	}
 14  }
 15  
 16  static uint32_t _gpio_base2_value(const gpio_t gpio[], int num_gpio)
 17  {
 18  	uint32_t result = 0;
 19  	int i;
 20  
 21  	/* Wait until signals become stable */
 22  	udelay(10);
 23  
 24  	for (i = 0; i < num_gpio; i++)
 25  		result |= gpio_get(gpio[i]) << i;
 26  
 27  	return result;
 28  }
 29  
 30  uint32_t gpio_base2_value(const gpio_t gpio[], int num_gpio)
 31  {
 32  	int i;
 33  
 34  	_check_num(__func__, num_gpio);
 35  	for (i = 0; i < num_gpio; i++)
 36  		gpio_input(gpio[i]);
 37  
 38  	return _gpio_base2_value(gpio, num_gpio);
 39  }
 40  
 41  uint32_t gpio_pulldown_base2_value(const gpio_t gpio[], int num_gpio)
 42  {
 43  	int i;
 44  
 45  	_check_num(__func__, num_gpio);
 46  	for (i = 0; i < num_gpio; i++)
 47  		gpio_input_pulldown(gpio[i]);
 48  
 49  	return _gpio_base2_value(gpio, num_gpio);
 50  }
 51  
 52  uint32_t gpio_pullup_base2_value(const gpio_t gpio[], int num_gpio)
 53  {
 54  	int i;
 55  
 56  	_check_num(__func__, num_gpio);
 57  	for (i = 0; i < num_gpio; i++)
 58  		gpio_input_pullup(gpio[i]);
 59  
 60  	return _gpio_base2_value(gpio, num_gpio);
 61  }
 62  
 63  uint32_t _gpio_base3_value(const gpio_t gpio[], int num_gpio, int binary_first)
 64  {
 65  	/*
 66  	 * GPIOs which are tied to stronger external pull up or pull down
 67  	 * will stay there regardless of the internal pull up or pull
 68  	 * down setting.
 69  	 *
 70  	 * GPIOs which are floating will go to whatever level they're
 71  	 * internally pulled to.
 72  	 */
 73  
 74  	static const char tristate_char[] = {[0] = '0', [1] = '1', [Z] = 'Z'};
 75  	uint32_t result = 0;
 76  	int has_z = 0;
 77  	int binary_below = 0;
 78  	int index;
 79  	int temp;
 80  	char value[32];
 81  
 82  	_check_num(__func__, num_gpio);
 83  
 84  	/* Enable internal pull up */
 85  	for (index = 0; index < num_gpio; ++index)
 86  		gpio_input_pullup(gpio[index]);
 87  
 88  	/* Wait until signals become stable */
 89  	udelay(10);
 90  
 91  	/* Get gpio values at internal pull up */
 92  	for (index = 0; index < num_gpio; ++index)
 93  		value[index] = gpio_get(gpio[index]);
 94  
 95  	/* Enable internal pull down */
 96  	for (index = 0; index < num_gpio; ++index)
 97  		gpio_input_pulldown(gpio[index]);
 98  
 99  	/* Wait until signals become stable */
100  	udelay(10);
101  
102  	/*
103  	 * Get gpio values at internal pull down.
104  	 * Compare with gpio pull up value and then
105  	 * determine a gpio final value/state:
106  	 *  0: pull down
107  	 *  1: pull up
108  	 *  2: floating
109  	 */
110  	printk(BIOS_DEBUG, "Reading tristate GPIOs: ");
111  	for (index = num_gpio - 1; index >= 0; --index) {
112  		temp = gpio_get(gpio[index]);
113  		temp |= ((value[index] ^ temp) << 1);
114  		printk(BIOS_DEBUG, "%c ", tristate_char[temp]);
115  		result = (result * 3) + temp;
116  
117  		/* Disable pull to avoid wasting power. For HiZ we leave the
118  		   pull-down enabled, since letting them float freely back and
119  		   forth may waste power in the SoC's GPIO input logic. */
120  		if (temp != Z)
121  			gpio_input(gpio[index]);
122  
123  		/*
124  		 * For binary_first we keep track of the normal ternary result
125  		 * and whether we found any pin that was a Z. We also determine
126  		 * the amount of numbers that can be represented with only
127  		 * binary digits (no Z) whose value in the normal ternary system
128  		 * is lower than the one we are parsing. Counting from the left,
129  		 * we add 2^i for any '1' digit to account for the binary
130  		 * numbers whose values would be below it if all following
131  		 * digits we parsed would be '0'. As soon as we find a '2' digit
132  		 * we can total the remaining binary numbers below as 2^(i+1)
133  		 * because we know that all binary representations counting only
134  		 * this and following digits must have values below our number
135  		 * (since 1xxx is always smaller than 2xxx).
136  		 *
137  		 * Example: 1 0 2 1 (counting from the left / most significant)
138  		 * '1' at 3^3: Add 2^3 = 8 to account for binaries 0000-0111
139  		 * '0' at 3^2: Ignore (not all binaries 1000-1100 are below us)
140  		 * '2' at 3^1: Add 2^(1+1) = 4 to account for binaries 1000-1011
141  		 * Stop adding for lower digits (3^0), all already accounted
142  		 * now. We know that there can be no binary numbers 1020-102X.
143  		 */
144  		if (binary_first && !has_z) {
145  			switch (temp) {
146  			case 0:	/* Ignore '0' digits. */
147  				break;
148  			case 1:	/* Account for binaries 0 to 2^index - 1. */
149  				binary_below += 1 << index;
150  				break;
151  			case 2:	/* Account for binaries 0 to 2^(index+1) - 1. */
152  				binary_below += 1 << (index + 1);
153  				has_z = 1;
154  			}
155  		}
156  	}
157  
158  	if (binary_first) {
159  		if (has_z)
160  			result = result + (1 << num_gpio) - binary_below;
161  		else /* binary_below is normal binary system value if !has_z. */
162  			result = binary_below;
163  	}
164  
165  	printk(BIOS_DEBUG, "= %d (%s base3 number system)\n", result,
166  	       binary_first ? "binary_first" : "standard");
167  
168  	return result;
169  }
170  
171  /* Default handler for ACPI path is to return NULL */
172  __weak const char *gpio_acpi_path(gpio_t gpio)
173  {
174  	return NULL;
175  }
176  
177  /* Default handler returns 0 because type of gpio_t is unknown */
178  __weak uint16_t gpio_acpi_pin(gpio_t gpio)
179  {
180  	return 0;
181  }