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