1 // SPDX-License-Identifier: GPL-2.0 2 3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. 4 * Copyright (C) 2018-2024 Linaro Ltd. 5 */ 6 7 #include <linux/delay.h> 8 #include <linux/io.h> 9 #include <linux/pm_runtime.h> 10 #include <linux/types.h> 11 12 #include "ipa.h" 13 #include "ipa_interrupt.h" 14 #include "ipa_power.h" 15 #include "ipa_reg.h" 16 #include "ipa_uc.h" 17 18 /** 19 * DOC: The IPA embedded microcontroller 20 * 21 * The IPA incorporates a microcontroller that is able to do some additional 22 * handling/offloading of network activity. The current code makes 23 * essentially no use of the microcontroller, but it still requires some 24 * initialization. It needs to be notified in the event the AP crashes. 25 * 26 * The microcontroller can generate two interrupts to the AP. One interrupt 27 * is used to indicate that a response to a request from the AP is available. 28 * The other is used to notify the AP of the occurrence of an event. In 29 * addition, the AP can interrupt the microcontroller by writing a register. 30 * 31 * A 128 byte block of structured memory within the IPA SRAM is used together 32 * with these interrupts to implement the communication interface between the 33 * AP and the IPA microcontroller. Each side writes data to the shared area 34 * before interrupting its peer, which will read the written data in response 35 * to the interrupt. Some information found in the shared area is currently 36 * unused. All remaining space in the shared area is reserved, and must not 37 * be read or written by the AP. 38 */ 39 /* Supports hardware interface version 0x2000 */ 40 41 /* Delay to allow a the microcontroller to save state when crashing */ 42 #define IPA_SEND_DELAY 100 /* microseconds */ 43 44 /** 45 * struct ipa_uc_mem_area - AP/microcontroller shared memory area 46 * @command: command code (AP->microcontroller) 47 * @reserved0: reserved bytes; avoid reading or writing 48 * @command_param: low 32 bits of command parameter (AP->microcontroller) 49 * @command_param_hi: high 32 bits of command parameter (AP->microcontroller) 50 * 51 * @response: response code (microcontroller->AP) 52 * @reserved1: reserved bytes; avoid reading or writing 53 * @response_param: response parameter (microcontroller->AP) 54 * 55 * @event: event code (microcontroller->AP) 56 * @reserved2: reserved bytes; avoid reading or writing 57 * @event_param: event parameter (microcontroller->AP) 58 * 59 * @first_error_address: address of first error-source on SNOC 60 * @hw_state: state of hardware (including error type information) 61 * @warning_counter: counter of non-fatal hardware errors 62 * @reserved3: reserved bytes; avoid reading or writing 63 * @interface_version: hardware-reported interface version 64 * @reserved4: reserved bytes; avoid reading or writing 65 * 66 * A shared memory area at the base of IPA resident memory is used for 67 * communication with the microcontroller. The region is 128 bytes in 68 * size, but only the first 40 bytes (structured this way) are used. 69 */ 70 struct ipa_uc_mem_area { 71 u8 command; /* enum ipa_uc_command */ 72 u8 reserved0[3]; 73 __le32 command_param; 74 __le32 command_param_hi; 75 u8 response; /* enum ipa_uc_response */ 76 u8 reserved1[3]; 77 __le32 response_param; 78 u8 event; /* enum ipa_uc_event */ 79 u8 reserved2[3]; 80 81 __le32 event_param; 82 __le32 first_error_address; 83 u8 hw_state; 84 u8 warning_counter; 85 __le16 reserved3; 86 __le16 interface_version; 87 __le16 reserved4; 88 }; 89 90 /** enum ipa_uc_command - commands from the AP to the microcontroller */ 91 enum ipa_uc_command { 92 IPA_UC_COMMAND_NO_OP = 0x0, 93 IPA_UC_COMMAND_UPDATE_FLAGS = 0x1, 94 IPA_UC_COMMAND_DEBUG_RUN_TEST = 0x2, 95 IPA_UC_COMMAND_DEBUG_GET_INFO = 0x3, 96 IPA_UC_COMMAND_ERR_FATAL = 0x4, 97 IPA_UC_COMMAND_CLK_GATE = 0x5, 98 IPA_UC_COMMAND_CLK_UNGATE = 0x6, 99 IPA_UC_COMMAND_MEMCPY = 0x7, 100 IPA_UC_COMMAND_RESET_PIPE = 0x8, 101 IPA_UC_COMMAND_REG_WRITE = 0x9, 102 IPA_UC_COMMAND_GSI_CH_EMPTY = 0xa, 103 }; 104 105 /** enum ipa_uc_response - microcontroller response codes */ 106 enum ipa_uc_response { 107 IPA_UC_RESPONSE_NO_OP = 0x0, 108 IPA_UC_RESPONSE_INIT_COMPLETED = 0x1, 109 IPA_UC_RESPONSE_CMD_COMPLETED = 0x2, 110 IPA_UC_RESPONSE_DEBUG_GET_INFO = 0x3, 111 }; 112 113 /** enum ipa_uc_event - common cpu events reported by the microcontroller */ 114 enum ipa_uc_event { 115 IPA_UC_EVENT_NO_OP = 0x0, 116 IPA_UC_EVENT_ERROR = 0x1, 117 IPA_UC_EVENT_LOG_INFO = 0x2, 118 }; 119 ipa_uc_shared(struct ipa * ipa)120 static struct ipa_uc_mem_area *ipa_uc_shared(struct ipa *ipa) 121 { 122 const struct ipa_mem *mem = ipa_mem_find(ipa, IPA_MEM_UC_SHARED); 123 u32 offset = ipa->mem_offset + mem->offset; 124 125 return ipa->mem_virt + offset; 126 } 127 128 /* Microcontroller event IPA interrupt handler */ ipa_uc_event_handler(struct ipa * ipa)129 static void ipa_uc_event_handler(struct ipa *ipa) 130 { 131 struct ipa_uc_mem_area *shared = ipa_uc_shared(ipa); 132 struct device *dev = ipa->dev; 133 134 if (shared->event == IPA_UC_EVENT_ERROR) 135 dev_err(dev, "microcontroller error event\n"); 136 else if (shared->event != IPA_UC_EVENT_LOG_INFO) 137 dev_err(dev, "unsupported microcontroller event %u\n", 138 shared->event); 139 /* The LOG_INFO event can be safely ignored */ 140 } 141 142 /* Microcontroller response IPA interrupt handler */ ipa_uc_response_hdlr(struct ipa * ipa)143 static void ipa_uc_response_hdlr(struct ipa *ipa) 144 { 145 struct ipa_uc_mem_area *shared = ipa_uc_shared(ipa); 146 struct device *dev = ipa->dev; 147 148 /* An INIT_COMPLETED response message is sent to the AP by the 149 * microcontroller when it is operational. Other than this, the AP 150 * should only receive responses from the microcontroller when it has 151 * sent it a request message. 152 * 153 * We can drop the power reference taken in ipa_uc_power() once we 154 * know the microcontroller has finished its initialization. 155 */ 156 switch (shared->response) { 157 case IPA_UC_RESPONSE_INIT_COMPLETED: 158 if (ipa->uc_powered) { 159 ipa->uc_loaded = true; 160 ipa_power_retention(ipa, true); 161 pm_runtime_mark_last_busy(dev); 162 (void)pm_runtime_put_autosuspend(dev); 163 ipa->uc_powered = false; 164 } else { 165 dev_warn(dev, "unexpected init_completed response\n"); 166 } 167 break; 168 default: 169 dev_warn(dev, "unsupported microcontroller response %u\n", 170 shared->response); 171 break; 172 } 173 } 174 ipa_uc_interrupt_handler(struct ipa * ipa,enum ipa_irq_id irq_id)175 void ipa_uc_interrupt_handler(struct ipa *ipa, enum ipa_irq_id irq_id) 176 { 177 /* Silently ignore anything unrecognized */ 178 if (irq_id == IPA_IRQ_UC_0) 179 ipa_uc_event_handler(ipa); 180 else if (irq_id == IPA_IRQ_UC_1) 181 ipa_uc_response_hdlr(ipa); 182 } 183 184 /* Configure the IPA microcontroller subsystem */ ipa_uc_config(struct ipa * ipa)185 void ipa_uc_config(struct ipa *ipa) 186 { 187 ipa->uc_powered = false; 188 ipa->uc_loaded = false; 189 ipa_interrupt_enable(ipa, IPA_IRQ_UC_0); 190 ipa_interrupt_enable(ipa, IPA_IRQ_UC_1); 191 } 192 193 /* Inverse of ipa_uc_config() */ ipa_uc_deconfig(struct ipa * ipa)194 void ipa_uc_deconfig(struct ipa *ipa) 195 { 196 struct device *dev = ipa->dev; 197 198 ipa_interrupt_disable(ipa, IPA_IRQ_UC_1); 199 ipa_interrupt_disable(ipa, IPA_IRQ_UC_0); 200 if (ipa->uc_loaded) 201 ipa_power_retention(ipa, false); 202 203 if (!ipa->uc_powered) 204 return; 205 206 pm_runtime_mark_last_busy(dev); 207 (void)pm_runtime_put_autosuspend(dev); 208 } 209 210 /* Take a proxy power reference for the microcontroller */ ipa_uc_power(struct ipa * ipa)211 void ipa_uc_power(struct ipa *ipa) 212 { 213 struct device *dev = ipa->dev; 214 static bool already; 215 int ret; 216 217 if (already) 218 return; 219 already = true; /* Only do this on first boot */ 220 221 /* This power reference dropped in ipa_uc_response_hdlr() above */ 222 ret = pm_runtime_get_sync(dev); 223 if (ret < 0) { 224 pm_runtime_put_noidle(dev); 225 dev_err(dev, "error %d getting proxy power\n", ret); 226 } else { 227 ipa->uc_powered = true; 228 } 229 } 230 231 /* Send a command to the microcontroller */ send_uc_command(struct ipa * ipa,u32 command,u32 command_param)232 static void send_uc_command(struct ipa *ipa, u32 command, u32 command_param) 233 { 234 struct ipa_uc_mem_area *shared = ipa_uc_shared(ipa); 235 const struct reg *reg; 236 u32 val; 237 238 /* Fill in the command data */ 239 shared->command = command; 240 shared->command_param = cpu_to_le32(command_param); 241 shared->command_param_hi = 0; 242 shared->response = 0; 243 shared->response_param = 0; 244 245 /* Use an interrupt to tell the microcontroller the command is ready */ 246 reg = ipa_reg(ipa, IPA_IRQ_UC); 247 val = reg_bit(reg, UC_INTR); 248 249 iowrite32(val, ipa->reg_virt + reg_offset(reg)); 250 } 251 252 /* Tell the microcontroller the AP is shutting down */ ipa_uc_panic_notifier(struct ipa * ipa)253 void ipa_uc_panic_notifier(struct ipa *ipa) 254 { 255 if (!ipa->uc_loaded) 256 return; 257 258 send_uc_command(ipa, IPA_UC_COMMAND_ERR_FATAL, 0); 259 260 /* give uc enough time to save state */ 261 udelay(IPA_SEND_DELAY); 262 } 263