1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) Marvell International Ltd. and its affiliates 4 */ 5 6 #include <common.h> 7 #include <spl.h> 8 #include <asm/io.h> 9 #include <asm/arch/cpu.h> 10 #include <asm/arch/soc.h> 11 12 #include "seq_exec.h" 13 #include "sys_env_lib.h" 14 15 #ifdef CONFIG_ARMADA_38X 16 enum unit_id sys_env_soc_unit_nums[MAX_UNITS_ID][MAX_DEV_ID_NUM] = { 17 /* 6820 6810 6811 6828 */ 18 /* PEX_UNIT_ID */ { 4, 3, 3, 4}, 19 /* ETH_GIG_UNIT_ID */ { 3, 2, 3, 3}, 20 /* USB3H_UNIT_ID */ { 2, 2, 2, 2}, 21 /* USB3D_UNIT_ID */ { 1, 1, 1, 1}, 22 /* SATA_UNIT_ID */ { 2, 2, 2, 4}, 23 /* QSGMII_UNIT_ID */ { 1, 0, 0, 1}, 24 /* XAUI_UNIT_ID */ { 0, 0, 0, 0}, 25 /* RXAUI_UNIT_ID */ { 0, 0, 0, 0} 26 }; 27 #else /* if (CONFIG_ARMADA_39X) */ 28 enum unit_id sys_env_soc_unit_nums[MAX_UNITS_ID][MAX_DEV_ID_NUM] = { 29 /* 6920 6928 */ 30 /* PEX_UNIT_ID */ { 4, 4}, 31 /* ETH_GIG_UNIT_ID */ { 3, 4}, 32 /* USB3H_UNIT_ID */ { 1, 2}, 33 /* USB3D_UNIT_ID */ { 0, 1}, 34 /* SATA_UNIT_ID */ { 0, 4}, 35 /* QSGMII_UNIT_ID */ { 0, 1}, 36 /* XAUI_UNIT_ID */ { 1, 1}, 37 /* RXAUI_UNIT_ID */ { 1, 1} 38 }; 39 #endif 40 41 u32 g_dev_id = -1; 42 43 u32 mv_board_id_get(void) 44 { 45 #if defined(CONFIG_TARGET_DB_88F6820_GP) 46 return DB_GP_68XX_ID; 47 #else 48 /* 49 * Return 0 here for custom board as this should not be used 50 * for custom boards. 51 */ 52 return 0; 53 #endif 54 } 55 56 u32 mv_board_tclk_get(void) 57 { 58 u32 value; 59 60 value = (reg_read(DEVICE_SAMPLE_AT_RESET1_REG) >> 15) & 0x1; 61 62 switch (value) { 63 case (0x0): 64 return 250000000; 65 case (0x1): 66 return 200000000; 67 default: 68 return 0xffffffff; 69 } 70 } 71 72 u32 mv_board_id_index_get(u32 board_id) 73 { 74 /* 75 * Marvell Boards use 0x10 as base for Board ID: 76 * mask MSB to receive index for board ID 77 */ 78 return board_id & (MARVELL_BOARD_ID_MASK - 1); 79 } 80 81 /* 82 * sys_env_suspend_wakeup_check 83 * DESCRIPTION: Reads GPIO input for suspend-wakeup indication. 84 * INPUT: None. 85 * OUTPUT: 86 * RETURNS: u32 indicating suspend wakeup status: 87 * 0 - Not supported, 88 * 1 - supported: read magic word detect wakeup, 89 * 2 - detected wakeup from GPIO. 90 */ 91 enum suspend_wakeup_status sys_env_suspend_wakeup_check(void) 92 { 93 u32 reg, board_id_index, gpio; 94 struct board_wakeup_gpio board_gpio[] = MV_BOARD_WAKEUP_GPIO_INFO; 95 96 board_id_index = mv_board_id_index_get(mv_board_id_get()); 97 if (!(sizeof(board_gpio) / sizeof(struct board_wakeup_gpio) > 98 board_id_index)) { 99 printf("\n_failed loading Suspend-Wakeup information (invalid board ID)\n"); 100 return SUSPEND_WAKEUP_DISABLED; 101 } 102 103 /* 104 * - Detect if Suspend-Wakeup is supported on current board 105 * - Fetch the GPIO number for wakeup status input indication 106 */ 107 if (board_gpio[board_id_index].gpio_num == -1) { 108 /* Suspend to RAM is not supported */ 109 return SUSPEND_WAKEUP_DISABLED; 110 } else if (board_gpio[board_id_index].gpio_num == -2) { 111 /* 112 * Suspend to RAM is supported but GPIO indication is 113 * not implemented - Skip 114 */ 115 return SUSPEND_WAKEUP_ENABLED; 116 } else { 117 gpio = board_gpio[board_id_index].gpio_num; 118 } 119 120 /* Initialize MPP for GPIO (set MPP = 0x0) */ 121 reg = reg_read(MPP_CONTROL_REG(MPP_REG_NUM(gpio))); 122 /* reset MPP21 to 0x0, keep rest of MPP settings*/ 123 reg &= ~MPP_MASK(gpio); 124 reg_write(MPP_CONTROL_REG(MPP_REG_NUM(gpio)), reg); 125 126 /* Initialize GPIO as input */ 127 reg = reg_read(GPP_DATA_OUT_EN_REG(GPP_REG_NUM(gpio))); 128 reg |= GPP_MASK(gpio); 129 reg_write(GPP_DATA_OUT_EN_REG(GPP_REG_NUM(gpio)), reg); 130 131 /* 132 * Check GPP for input status from PIC: 0 - regular init, 133 * 1 - suspend wakeup 134 */ 135 reg = reg_read(GPP_DATA_IN_REG(GPP_REG_NUM(gpio))); 136 137 /* if GPIO is ON: wakeup from S2RAM indication detected */ 138 return (reg & GPP_MASK(gpio)) ? SUSPEND_WAKEUP_ENABLED_GPIO_DETECTED : 139 SUSPEND_WAKEUP_DISABLED; 140 } 141 142 /* 143 * mv_ctrl_dev_id_index_get 144 * 145 * DESCRIPTION: return SOC device index 146 * INPUT: None 147 * OUTPUT: None 148 * RETURN: 149 * return SOC device index 150 */ 151 u32 sys_env_id_index_get(u32 ctrl_model) 152 { 153 switch (ctrl_model) { 154 case MV_6820_DEV_ID: 155 return MV_6820_INDEX; 156 case MV_6810_DEV_ID: 157 return MV_6810_INDEX; 158 case MV_6811_DEV_ID: 159 return MV_6811_INDEX; 160 case MV_6828_DEV_ID: 161 return MV_6828_INDEX; 162 case MV_6920_DEV_ID: 163 return MV_6920_INDEX; 164 case MV_6928_DEV_ID: 165 return MV_6928_INDEX; 166 default: 167 return MV_6820_INDEX; 168 } 169 } 170 171 u32 sys_env_unit_max_num_get(enum unit_id unit) 172 { 173 u32 dev_id_index; 174 175 if (unit >= MAX_UNITS_ID) { 176 printf("%s: Error: Wrong unit type (%u)\n", __func__, unit); 177 return 0; 178 } 179 180 dev_id_index = sys_env_id_index_get(sys_env_model_get()); 181 return sys_env_soc_unit_nums[unit][dev_id_index]; 182 } 183 184 /* 185 * sys_env_model_get 186 * DESCRIPTION: Returns 16bit describing the device model (ID) as defined 187 * in Vendor ID configuration register 188 */ 189 u16 sys_env_model_get(void) 190 { 191 u32 default_ctrl_id, ctrl_id = reg_read(DEV_ID_REG); 192 ctrl_id = (ctrl_id & (DEV_ID_REG_DEVICE_ID_MASK)) >> 193 DEV_ID_REG_DEVICE_ID_OFFS; 194 195 switch (ctrl_id) { 196 case MV_6820_DEV_ID: 197 case MV_6810_DEV_ID: 198 case MV_6811_DEV_ID: 199 case MV_6828_DEV_ID: 200 case MV_6920_DEV_ID: 201 case MV_6928_DEV_ID: 202 return ctrl_id; 203 default: 204 /* Device ID Default for A38x: 6820 , for A39x: 6920 */ 205 #ifdef CONFIG_ARMADA_38X 206 default_ctrl_id = MV_6820_DEV_ID; 207 #else 208 default_ctrl_id = MV_6920_DEV_ID; 209 #endif 210 printf("%s: Error retrieving device ID (%x), using default ID = %x\n", 211 __func__, ctrl_id, default_ctrl_id); 212 return default_ctrl_id; 213 } 214 } 215 216 /* 217 * sys_env_device_id_get 218 * DESCRIPTION: Returns enum (0..7) index of the device model (ID) 219 */ 220 u32 sys_env_device_id_get(void) 221 { 222 char *device_id_str[7] = { 223 "6810", "6820", "6811", "6828", "NONE", "6920", "6928" 224 }; 225 226 if (g_dev_id != -1) 227 return g_dev_id; 228 229 g_dev_id = reg_read(DEVICE_SAMPLE_AT_RESET1_REG); 230 g_dev_id = g_dev_id >> SAR_DEV_ID_OFFS & SAR_DEV_ID_MASK; 231 printf("Detected Device ID %s\n", device_id_str[g_dev_id]); 232 233 return g_dev_id; 234 } 235 236 /* 237 * sys_env_device_rev_get - Get Marvell controller device revision number 238 * 239 * DESCRIPTION: 240 * This function returns 8bit describing the device revision as defined 241 * Revision ID Register. 242 * 243 * INPUT: 244 * None. 245 * 246 * OUTPUT: 247 * None. 248 * 249 * RETURN: 250 * 8bit desscribing Marvell controller revision number 251 */ 252 u8 sys_env_device_rev_get(void) 253 { 254 u32 value; 255 256 value = reg_read(DEV_VERSION_ID_REG); 257 return (value & (REVISON_ID_MASK)) >> REVISON_ID_OFFS; 258 } 259