1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2015 Samsung Electronics 4 * Przemyslaw Marczak <p.marczak@samsung.com> 5 */ 6 7 #include <common.h> 8 #include <adc.h> 9 #include <dm.h> 10 #include <errno.h> 11 #include <fdtdec.h> 12 #include <power/pmic.h> 13 #include <power/regulator.h> 14 #include <power/s2mps11.h> 15 #include <samsung/exynos5-dt-types.h> 16 #include <samsung/misc.h> 17 18 DECLARE_GLOBAL_DATA_PTR; 19 20 static const struct udevice_id board_ids[] = { 21 { .compatible = "samsung,odroidxu3", .data = EXYNOS5_BOARD_ODROID_XU3 }, 22 { .compatible = "samsung,exynos5", .data = EXYNOS5_BOARD_GENERIC }, 23 { }, 24 }; 25 26 /** 27 * Odroix XU3/XU4/HC1/HC2 board revisions (from HC1+_HC2_MAIN_REV0.1_20171017.pdf): 28 * Rev ADCmax Board 29 * 0.1 0 XU3 0.1 30 * 0.2 372 XU3 0.2 | XU3L - no DISPLAYPORT (probe I2C0:0x40 / INA231) 31 * 0.3 1280 XU4 0.1 32 * 0.4 739 XU4 0.2 33 * 0.5 1016 XU4+Air0.1 (Passive cooling) 34 * 0.6 1309 XU4-HC1 0.1 35 * 0.7 1470 XU4-HC1+ 0.1 (HC2) 36 * Use +1% for ADC value tolerance in the array below, the code loops until 37 * the measured ADC value is lower than then ADCmax from the array. 38 */ 39 struct odroid_rev_info odroid_info[] = { 40 { EXYNOS5_BOARD_ODROID_XU3_REV01, 1, 10, "xu3" }, 41 { EXYNOS5_BOARD_ODROID_XU3_REV02, 2, 375, "xu3" }, 42 { EXYNOS5_BOARD_ODROID_XU4_REV01, 1, 1293, "xu4" }, 43 { EXYNOS5_BOARD_ODROID_HC1_REV01, 1, 1322, "hc1" }, 44 { EXYNOS5_BOARD_ODROID_HC2_REV01, 1, 1484, "hc1" }, 45 { EXYNOS5_BOARD_ODROID_UNKNOWN, 0, 4095, "unknown" }, 46 }; 47 48 static unsigned int odroid_get_rev(void) 49 { 50 int i; 51 52 for (i = 0; i < ARRAY_SIZE(odroid_info); i++) { 53 if (odroid_info[i].board_type == gd->board_type) 54 return odroid_info[i].board_rev; 55 } 56 57 return 0; 58 } 59 60 /* 61 * Read ADC at least twice and check the resuls. If regulator providing voltage 62 * on to measured point was just turned on, first reads might require time 63 * to stabilize. 64 */ 65 static int odroid_get_adc_val(unsigned int *adcval) 66 { 67 unsigned int adcval_prev = 0; 68 int ret, retries = 20; 69 70 ret = adc_channel_single_shot("adc", CONFIG_ODROID_REV_AIN, 71 &adcval_prev); 72 if (ret) 73 return ret; 74 75 while (retries--) { 76 mdelay(5); 77 78 ret = adc_channel_single_shot("adc", CONFIG_ODROID_REV_AIN, 79 adcval); 80 if (ret) 81 return ret; 82 83 /* 84 * If difference between ADC reads is less than 3%, 85 * accept the result 86 */ 87 if ((100 * abs(*adcval - adcval_prev) / adcval_prev) < 3) 88 return ret; 89 90 adcval_prev = *adcval; 91 } 92 93 return ret; 94 } 95 96 static int odroid_get_board_type(void) 97 { 98 unsigned int adcval; 99 int ret, i; 100 101 ret = odroid_get_adc_val(&adcval); 102 if (ret) 103 goto rev_default; 104 105 for (i = 0; i < ARRAY_SIZE(odroid_info); i++) { 106 /* ADC tolerance: +1% */ 107 if (adcval < odroid_info[i].adc_val) 108 return odroid_info[i].board_type; 109 } 110 111 rev_default: 112 return EXYNOS5_BOARD_ODROID_XU3; 113 } 114 115 /** 116 * odroid_get_type_str - returns pointer to one of the board type string. 117 * Board types: "xu3", "xu3-lite", "xu4". However the "xu3lite" can be 118 * detected only when the i2c controller is ready to use. Fortunately, 119 * XU3 and XU3L are compatible, and the information about board lite 120 * revision is needed before booting the linux, to set proper environment 121 * variable: $fdtfile. 122 */ 123 static const char *odroid_get_type_str(void) 124 { 125 const char *type_xu3l = "xu3-lite"; 126 struct udevice *dev, *chip; 127 int i, ret; 128 129 if (gd->board_type != EXYNOS5_BOARD_ODROID_XU3_REV02) 130 goto exit; 131 132 ret = pmic_get("s2mps11", &dev); 133 if (ret) 134 goto exit; 135 136 /* Enable LDO26: 3.0V */ 137 ret = pmic_reg_write(dev, S2MPS11_REG_L26CTRL, 138 S2MPS11_LDO26_ENABLE); 139 if (ret) 140 goto exit; 141 142 /* Check XU3Lite by probe INA231 I2C0:0x40 */ 143 ret = uclass_get_device(UCLASS_I2C, 0, &dev); 144 if (ret) 145 goto exit; 146 147 ret = dm_i2c_probe(dev, 0x40, 0x0, &chip); 148 if (ret) 149 return type_xu3l; 150 151 exit: 152 for (i = 0; i < ARRAY_SIZE(odroid_info); i++) { 153 if (odroid_info[i].board_type == gd->board_type) 154 return odroid_info[i].name; 155 } 156 157 return NULL; 158 } 159 160 bool board_is_odroidxu3(void) 161 { 162 if (gd->board_type >= EXYNOS5_BOARD_ODROID_XU3 && 163 gd->board_type <= EXYNOS5_BOARD_ODROID_XU3_REV02) 164 return true; 165 166 return false; 167 } 168 169 bool board_is_odroidxu4(void) 170 { 171 if (gd->board_type == EXYNOS5_BOARD_ODROID_XU4_REV01) 172 return true; 173 174 return false; 175 } 176 177 bool board_is_odroidhc1(void) 178 { 179 if (gd->board_type == EXYNOS5_BOARD_ODROID_HC1_REV01) 180 return true; 181 182 return false; 183 } 184 185 bool board_is_odroidhc2(void) 186 { 187 if (gd->board_type == EXYNOS5_BOARD_ODROID_HC2_REV01) 188 return true; 189 190 return false; 191 } 192 193 bool board_is_generic(void) 194 { 195 if (gd->board_type == EXYNOS5_BOARD_GENERIC) 196 return true; 197 198 return false; 199 } 200 201 /** 202 * get_board_rev() - return detected board revision. 203 * 204 * @return: return board revision number for XU3 or 0 for generic 205 */ 206 u32 get_board_rev(void) 207 { 208 if (board_is_generic()) 209 return 0; 210 211 return odroid_get_rev(); 212 } 213 214 /** 215 * get_board_type() - returns board type string. 216 * 217 * @return: return board type string for XU3 or empty string for generic 218 */ 219 const char *get_board_type(void) 220 { 221 const char *generic = ""; 222 223 if (board_is_generic()) 224 return generic; 225 226 return odroid_get_type_str(); 227 } 228 229 /** 230 * set_board_type() - set board type in gd->board_type. 231 * As default type set EXYNOS5_BOARD_GENERIC. If Odroid is detected, 232 * set its proper type based on device tree. 233 * 234 * This might be called early when some more specific ways to detect revision 235 * are not yet available. 236 */ 237 void set_board_type(void) 238 { 239 const struct udevice_id *of_match = board_ids; 240 int ret; 241 242 gd->board_type = EXYNOS5_BOARD_GENERIC; 243 244 while (of_match->compatible) { 245 ret = fdt_node_check_compatible(gd->fdt_blob, 0, 246 of_match->compatible); 247 if (ret) 248 of_match++; 249 250 gd->board_type = of_match->data; 251 break; 252 } 253 } 254 255 /** 256 * set_board_revision() - set detailed board type in gd->board_type. 257 * Should be called when resources (e.g. regulators) are available 258 * so ADC can be used to detect the specific revision of a board. 259 */ 260 void set_board_revision(void) 261 { 262 if (board_is_odroidxu3()) 263 gd->board_type = odroid_get_board_type(); 264 } 265