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