263 lines · c
1// SPDX-License-Identifier: GPL-2.02 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 microcontroller20 *21 * The IPA incorporates a microcontroller that is able to do some additional22 * handling/offloading of network activity. The current code makes23 * essentially no use of the microcontroller, but it still requires some24 * initialization. It needs to be notified in the event the AP crashes.25 *26 * The microcontroller can generate two interrupts to the AP. One interrupt27 * 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. In29 * 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 together32 * with these interrupts to implement the communication interface between the33 * AP and the IPA microcontroller. Each side writes data to the shared area34 * before interrupting its peer, which will read the written data in response35 * to the interrupt. Some information found in the shared area is currently36 * unused. All remaining space in the shared area is reserved, and must not37 * 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 area46 * @command: command code (AP->microcontroller)47 * @reserved0: reserved bytes; avoid reading or writing48 * @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 writing53 * @response_param: response parameter (microcontroller->AP)54 *55 * @event: event code (microcontroller->AP)56 * @reserved2: reserved bytes; avoid reading or writing57 * @event_param: event parameter (microcontroller->AP)58 *59 * @first_error_address: address of first error-source on SNOC60 * @hw_state: state of hardware (including error type information)61 * @warning_counter: counter of non-fatal hardware errors62 * @reserved3: reserved bytes; avoid reading or writing63 * @interface_version: hardware-reported interface version64 * @reserved4: reserved bytes; avoid reading or writing65 *66 * A shared memory area at the base of IPA resident memory is used for67 * communication with the microcontroller. The region is 128 bytes in68 * size, but only the first 40 bytes (structured this way) are used.69 */70struct 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 */91enum 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 */106enum 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 */114enum 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 120static 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 */129static 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 */143static 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 the149 * microcontroller when it is operational. Other than this, the AP150 * should only receive responses from the microcontroller when it has151 * sent it a request message.152 *153 * We can drop the power reference taken in ipa_uc_power() once we154 * 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 175void 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 */185void 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() */194void 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 */211void 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 */232static 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 */253void 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