Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 1 | /* |
Michal Simek | 2a47faa | 2023-04-14 08:43:51 +0200 | [diff] [blame] | 2 | * Copyright (c) 2013-2020, Arm Limited and Contributors. All rights reserved. |
Rajan Vaja | 566b2f9 | 2022-08-31 12:54:38 +0200 | [diff] [blame] | 3 | * Copyright (c) 2019-2022, Xilinx, Inc. All rights reserved. |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 4 | * Copyright (c) 2022-2023, Advanced Micro Devices, Inc. All rights reserved. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 5 | * |
dp-arm | fa3cf0b | 2017-05-03 09:38:09 +0100 | [diff] [blame] | 6 | * SPDX-License-Identifier: BSD-3-Clause |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 7 | */ |
| 8 | |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 9 | |
Isla Mitchell | e363146 | 2017-07-14 10:46:32 +0100 | [diff] [blame] | 10 | #include <arch_helpers.h> |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 11 | #include <lib/bakery_lock.h> |
| 12 | #include <lib/mmio.h> |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 13 | #include <lib/spinlock.h> |
Jolly Shah | c2583ab | 2019-01-08 11:31:49 -0800 | [diff] [blame] | 14 | #include <ipi.h> |
Jolly Shah | 4c17237 | 2019-01-08 11:21:29 -0800 | [diff] [blame] | 15 | #include <plat_ipi.h> |
Jolly Shah | 0bfd700 | 2019-01-08 11:10:47 -0800 | [diff] [blame] | 16 | #include <plat_private.h> |
Antonio Nino Diaz | e0f9063 | 2018-12-14 00:18:21 +0000 | [diff] [blame] | 17 | #include <plat/common/platform.h> |
| 18 | |
Rajan Vaja | 566b2f9 | 2022-08-31 12:54:38 +0200 | [diff] [blame] | 19 | #include "pm_defs.h" |
Isla Mitchell | e363146 | 2017-07-14 10:46:32 +0100 | [diff] [blame] | 20 | #include "pm_ipi.h" |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 21 | |
HariBabu Gattem | 9f9db61 | 2022-09-15 22:35:11 -0700 | [diff] [blame] | 22 | #define ERROR_CODE_MASK (0xFFFFU) |
HariBabu Gattem | aa81171 | 2022-10-07 00:07:49 -0700 | [diff] [blame] | 23 | #define PM_OFFSET (0U) |
Ravi Patel | 6512371 | 2020-11-23 04:19:08 -0800 | [diff] [blame] | 24 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 25 | /* |
| 26 | * ARM v8.2, the cache will turn off automatically when cpu |
| 27 | * power down. Therefore, there is no doubt to use the spin_lock here. |
| 28 | */ |
| 29 | #if !HW_ASSISTED_COHERENCY |
Stefan Krsmanovic | c5e9f66 | 2016-05-20 15:51:08 +0200 | [diff] [blame] | 30 | DEFINE_BAKERY_LOCK(pm_secure_lock); |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 31 | static inline void pm_ipi_lock_get(void) |
| 32 | { |
| 33 | bakery_lock_get(&pm_secure_lock); |
| 34 | } |
| 35 | |
| 36 | static inline void pm_ipi_lock_release(void) |
| 37 | { |
| 38 | bakery_lock_release(&pm_secure_lock); |
| 39 | } |
| 40 | #else |
| 41 | spinlock_t pm_secure_lock; |
| 42 | static inline void pm_ipi_lock_get(void) |
| 43 | { |
| 44 | spin_lock(&pm_secure_lock); |
| 45 | } |
| 46 | |
| 47 | static inline void pm_ipi_lock_release(void) |
| 48 | { |
| 49 | spin_unlock(&pm_secure_lock); |
| 50 | } |
| 51 | #endif |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 52 | |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 53 | /** |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 54 | * pm_ipi_init() - Initialize IPI peripheral for communication with |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 55 | * remote processor. |
| 56 | * @proc: Pointer to the processor who is initiating request. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 57 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 58 | * Return: On success, the initialization function must return 0. |
| 59 | * Any other return value will cause the framework to ignore |
| 60 | * the service. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 61 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 62 | * Called from pm_setup initialization function. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 63 | */ |
HariBabu Gattem | aa81171 | 2022-10-07 00:07:49 -0700 | [diff] [blame] | 64 | void pm_ipi_init(const struct pm_proc *proc) |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 65 | { |
Jolly Shah | 36c930b | 2019-01-07 12:51:40 -0800 | [diff] [blame] | 66 | ipi_mb_open(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | /** |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 70 | * pm_ipi_send_common() - Sends IPI request to the remote processor. |
| 71 | * @proc: Pointer to the processor who is initiating request. |
| 72 | * @payload: API id and call arguments to be written in IPI buffer. |
| 73 | * @is_blocking: if to trigger the notification in blocking mode or not. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 74 | * |
| 75 | * Send an IPI request to the power controller. Caller needs to hold |
| 76 | * the 'pm_secure_lock' lock. |
| 77 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 78 | * Return: Returns status, either success or error+reason. |
| 79 | * |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 80 | */ |
| 81 | static enum pm_ret_status pm_ipi_send_common(const struct pm_proc *proc, |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 82 | uint32_t payload[PAYLOAD_ARG_CNT], |
| 83 | uint32_t is_blocking) |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 84 | { |
HariBabu Gattem | aa81171 | 2022-10-07 00:07:49 -0700 | [diff] [blame] | 85 | uint32_t offset = PM_OFFSET; |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 86 | uintptr_t buffer_base = proc->ipi->buffer_base + |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 87 | IPI_BUFFER_TARGET_REMOTE_OFFSET + |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 88 | IPI_BUFFER_REQ_OFFSET; |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 89 | #if IPI_CRC_CHECK |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 90 | payload[PAYLOAD_CRC_POS] = calculate_crc(payload, IPI_W0_TO_W6_SIZE); |
| 91 | #endif |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 92 | |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 93 | /* Write payload into IPI buffer */ |
| 94 | for (size_t i = 0; i < PAYLOAD_ARG_CNT; i++) { |
| 95 | mmio_write_32(buffer_base + offset, payload[i]); |
| 96 | offset += PAYLOAD_ARG_SIZE; |
| 97 | } |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 98 | |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 99 | /* Generate IPI to remote processor */ |
Venkatesh Yadav Abbarapu | efa1d32 | 2021-08-04 21:33:15 -0600 | [diff] [blame] | 100 | ipi_mb_notify(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id, |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 101 | is_blocking); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 102 | |
Venkatesh Yadav Abbarapu | efa1d32 | 2021-08-04 21:33:15 -0600 | [diff] [blame] | 103 | return PM_RET_SUCCESS; |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | /** |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 107 | * pm_ipi_send_non_blocking() - Sends IPI request to the remote processor |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 108 | * without blocking notification. |
| 109 | * @proc: Pointer to the processor who is initiating request. |
| 110 | * @payload: API id and call arguments to be written in IPI buffer. |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 111 | * |
| 112 | * Send an IPI request to the power controller. |
| 113 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 114 | * Return: Returns status, either success or error+reason. |
| 115 | * |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 116 | */ |
| 117 | enum pm_ret_status pm_ipi_send_non_blocking(const struct pm_proc *proc, |
| 118 | uint32_t payload[PAYLOAD_ARG_CNT]) |
| 119 | { |
| 120 | enum pm_ret_status ret; |
| 121 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 122 | pm_ipi_lock_get(); |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 123 | |
| 124 | ret = pm_ipi_send_common(proc, payload, IPI_NON_BLOCKING); |
| 125 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 126 | pm_ipi_lock_release(); |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 127 | |
| 128 | return ret; |
| 129 | } |
| 130 | |
| 131 | /** |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 132 | * pm_ipi_send() - Sends IPI request to the remote processor. |
| 133 | * @proc: Pointer to the processor who is initiating request. |
| 134 | * @payload: API id and call arguments to be written in IPI buffer. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 135 | * |
| 136 | * Send an IPI request to the power controller. |
| 137 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 138 | * Return: Returns status, either success or error+reason. |
| 139 | * |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 140 | */ |
| 141 | enum pm_ret_status pm_ipi_send(const struct pm_proc *proc, |
| 142 | uint32_t payload[PAYLOAD_ARG_CNT]) |
| 143 | { |
| 144 | enum pm_ret_status ret; |
| 145 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 146 | pm_ipi_lock_get(); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 147 | |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 148 | ret = pm_ipi_send_common(proc, payload, IPI_BLOCKING); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 149 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 150 | pm_ipi_lock_release(); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 151 | |
| 152 | return ret; |
| 153 | } |
| 154 | |
| 155 | |
| 156 | /** |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 157 | * pm_ipi_buff_read() - Reads IPI response after remote processor has handled |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 158 | * interrupt. |
| 159 | * @proc: Pointer to the processor who is waiting and reading response. |
| 160 | * @value: Used to return value from IPI buffer element (optional). |
| 161 | * @count: Number of values to return in @value. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 162 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 163 | * Return: Returns status, either success or error+reason. |
| 164 | * |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 165 | */ |
| 166 | static enum pm_ret_status pm_ipi_buff_read(const struct pm_proc *proc, |
Venkatesh Yadav Abbarapu | e7c4538 | 2022-05-19 14:49:49 +0530 | [diff] [blame] | 167 | uint32_t *value, size_t count) |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 168 | { |
Soren Brinkmann | d6c9e03 | 2016-09-22 11:35:47 -0700 | [diff] [blame] | 169 | size_t i; |
Naman Trivedi Manojbhai | c0dfba8 | 2023-03-07 12:41:11 +0530 | [diff] [blame] | 170 | enum pm_ret_status ret; |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 171 | #if IPI_CRC_CHECK |
Naman Trivedi Manojbhai | c0dfba8 | 2023-03-07 12:41:11 +0530 | [diff] [blame] | 172 | uint32_t *payload_ptr = value; |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 173 | size_t j; |
Venkatesh Yadav Abbarapu | e7c4538 | 2022-05-19 14:49:49 +0530 | [diff] [blame] | 174 | uint32_t response_payload[PAYLOAD_ARG_CNT]; |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 175 | #endif |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 176 | uintptr_t buffer_base = proc->ipi->buffer_base + |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 177 | IPI_BUFFER_TARGET_REMOTE_OFFSET + |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 178 | IPI_BUFFER_RESP_OFFSET; |
| 179 | |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 180 | /* |
| 181 | * Read response from IPI buffer |
| 182 | * buf-0: success or error+reason |
| 183 | * buf-1: value |
| 184 | * buf-2: unused |
| 185 | * buf-3: unused |
| 186 | */ |
Soren Brinkmann | d6c9e03 | 2016-09-22 11:35:47 -0700 | [diff] [blame] | 187 | for (i = 1; i <= count; i++) { |
| 188 | *value = mmio_read_32(buffer_base + (i * PAYLOAD_ARG_SIZE)); |
| 189 | value++; |
| 190 | } |
Naman Trivedi Manojbhai | c0dfba8 | 2023-03-07 12:41:11 +0530 | [diff] [blame] | 191 | |
| 192 | ret = mmio_read_32(buffer_base); |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 193 | #if IPI_CRC_CHECK |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 194 | for (j = 0; j < PAYLOAD_ARG_CNT; j++) { |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 195 | response_payload[j] = mmio_read_32(buffer_base + |
| 196 | (j * PAYLOAD_ARG_SIZE)); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 197 | } |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 198 | |
| 199 | if (response_payload[PAYLOAD_CRC_POS] != |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 200 | calculate_crc(response_payload, IPI_W0_TO_W6_SIZE)) { |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 201 | NOTICE("ERROR in CRC response payload value:0x%x\n", |
| 202 | response_payload[PAYLOAD_CRC_POS]); |
Naman Trivedi Manojbhai | c0dfba8 | 2023-03-07 12:41:11 +0530 | [diff] [blame] | 203 | ret = PM_RET_ERROR_INVALID_CRC; |
| 204 | /* Payload data is invalid as CRC validation failed |
| 205 | * Clear the payload to avoid leakage of data to upper layers |
| 206 | */ |
| 207 | memset(payload_ptr, 0, count); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 208 | } |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 209 | #endif |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 210 | |
Naman Trivedi Manojbhai | c0dfba8 | 2023-03-07 12:41:11 +0530 | [diff] [blame] | 211 | return ret; |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | /** |
Naman Patel | e975642 | 2023-02-15 01:01:21 -0800 | [diff] [blame] | 215 | * pm_ipi_buff_read_callb() - Callback function that reads value from |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 216 | * ipi response buffer. |
| 217 | * @value: Used to return value from IPI buffer element. |
| 218 | * @count: Number of values to return in @value. |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 219 | * |
Naman Patel | e975642 | 2023-02-15 01:01:21 -0800 | [diff] [blame] | 220 | * This callback function fills requested data in @value from ipi response |
| 221 | * buffer. |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 222 | * |
| 223 | * Return: Returns status, either success or error. |
| 224 | * |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 225 | */ |
Naman Trivedi Manojbhai | beec83f | 2023-03-07 12:41:12 +0530 | [diff] [blame] | 226 | enum pm_ret_status pm_ipi_buff_read_callb(uint32_t *value, size_t count) |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 227 | { |
| 228 | size_t i; |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 229 | #if IPI_CRC_CHECK |
Naman Trivedi Manojbhai | beec83f | 2023-03-07 12:41:12 +0530 | [diff] [blame] | 230 | uint32_t *payload_ptr = value; |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 231 | size_t j; |
HariBabu Gattem | aa81171 | 2022-10-07 00:07:49 -0700 | [diff] [blame] | 232 | unsigned int response_payload[PAYLOAD_ARG_CNT] = {0}; |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 233 | #endif |
Jolly Shah | 9bb628d | 2019-01-07 12:53:32 -0800 | [diff] [blame] | 234 | uintptr_t buffer_base = IPI_BUFFER_REMOTE_BASE + |
| 235 | IPI_BUFFER_TARGET_LOCAL_OFFSET + |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 236 | IPI_BUFFER_REQ_OFFSET; |
Naman Trivedi Manojbhai | beec83f | 2023-03-07 12:41:12 +0530 | [diff] [blame] | 237 | enum pm_ret_status ret = PM_RET_SUCCESS; |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 238 | |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 239 | if (count > IPI_BUFFER_MAX_WORDS) { |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 240 | count = IPI_BUFFER_MAX_WORDS; |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 241 | } |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 242 | |
| 243 | for (i = 0; i <= count; i++) { |
| 244 | *value = mmio_read_32(buffer_base + (i * PAYLOAD_ARG_SIZE)); |
| 245 | value++; |
| 246 | } |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 247 | #if IPI_CRC_CHECK |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 248 | for (j = 0; j < PAYLOAD_ARG_CNT; j++) { |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 249 | response_payload[j] = mmio_read_32(buffer_base + |
| 250 | (j * PAYLOAD_ARG_SIZE)); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 251 | } |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 252 | |
| 253 | if (response_payload[PAYLOAD_CRC_POS] != |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 254 | calculate_crc(response_payload, IPI_W0_TO_W6_SIZE)) { |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 255 | NOTICE("ERROR in CRC response payload value:0x%x\n", |
| 256 | response_payload[PAYLOAD_CRC_POS]); |
Naman Trivedi Manojbhai | beec83f | 2023-03-07 12:41:12 +0530 | [diff] [blame] | 257 | ret = PM_RET_ERROR_INVALID_CRC; |
| 258 | /* Payload data is invalid as CRC validation failed |
| 259 | * Clear the payload to avoid leakage of data to upper layers |
| 260 | */ |
| 261 | memset(payload_ptr, 0, count); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 262 | } |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 263 | #endif |
Naman Trivedi Manojbhai | beec83f | 2023-03-07 12:41:12 +0530 | [diff] [blame] | 264 | return ret; |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | /** |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 268 | * pm_ipi_send_sync() - Sends IPI request to the remote processor. |
| 269 | * @proc: Pointer to the processor who is initiating request. |
| 270 | * @payload: API id and call arguments to be written in IPI buffer. |
| 271 | * @value: Used to return value from IPI buffer element (optional). |
| 272 | * @count: Number of values to return in @value. |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 273 | * |
| 274 | * Send an IPI request to the power controller and wait for it to be handled. |
| 275 | * |
Prasad Kummari | 7d0623a | 2023-06-09 14:32:00 +0530 | [diff] [blame^] | 276 | * Return: Returns status, either success or error+reason and, optionally, |
| 277 | * @value. |
| 278 | * |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 279 | */ |
| 280 | enum pm_ret_status pm_ipi_send_sync(const struct pm_proc *proc, |
| 281 | uint32_t payload[PAYLOAD_ARG_CNT], |
Venkatesh Yadav Abbarapu | e7c4538 | 2022-05-19 14:49:49 +0530 | [diff] [blame] | 282 | uint32_t *value, size_t count) |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 283 | { |
| 284 | enum pm_ret_status ret; |
| 285 | |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 286 | pm_ipi_lock_get(); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 287 | |
Tejas Patel | af4b10e | 2018-02-09 02:42:59 -0800 | [diff] [blame] | 288 | ret = pm_ipi_send_common(proc, payload, IPI_BLOCKING); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 289 | if (ret != PM_RET_SUCCESS) { |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 290 | goto unlock; |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 291 | } |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 292 | |
Ravi Patel | 6512371 | 2020-11-23 04:19:08 -0800 | [diff] [blame] | 293 | ret = ERROR_CODE_MASK & (pm_ipi_buff_read(proc, value, count)); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 294 | |
| 295 | unlock: |
Jay Buddhabhatti | c6d624b | 2023-03-02 02:47:36 -0800 | [diff] [blame] | 296 | pm_ipi_lock_release(); |
Soren Brinkmann | 76fcae3 | 2016-03-06 20:16:27 -0800 | [diff] [blame] | 297 | |
| 298 | return ret; |
| 299 | } |
Soren Brinkmann | a1b0a90 | 2016-09-30 11:30:21 -0700 | [diff] [blame] | 300 | |
Wendy Liang | 328105c | 2017-10-03 23:21:11 -0700 | [diff] [blame] | 301 | void pm_ipi_irq_enable(const struct pm_proc *proc) |
Soren Brinkmann | a1b0a90 | 2016-09-30 11:30:21 -0700 | [diff] [blame] | 302 | { |
Jolly Shah | 36c930b | 2019-01-07 12:51:40 -0800 | [diff] [blame] | 303 | ipi_mb_enable_irq(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id); |
Soren Brinkmann | a1b0a90 | 2016-09-30 11:30:21 -0700 | [diff] [blame] | 304 | } |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 305 | |
Wendy Liang | 328105c | 2017-10-03 23:21:11 -0700 | [diff] [blame] | 306 | void pm_ipi_irq_clear(const struct pm_proc *proc) |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 307 | { |
Jolly Shah | 36c930b | 2019-01-07 12:51:40 -0800 | [diff] [blame] | 308 | ipi_mb_ack(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id); |
Soren Brinkmann | 84f0af4 | 2016-09-30 14:24:25 -0700 | [diff] [blame] | 309 | } |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 310 | |
| 311 | uint32_t pm_ipi_irq_status(const struct pm_proc *proc) |
| 312 | { |
Venkatesh Yadav Abbarapu | e7c4538 | 2022-05-19 14:49:49 +0530 | [diff] [blame] | 313 | int32_t ret; |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 314 | |
| 315 | ret = ipi_mb_enquire_status(proc->ipi->local_ipi_id, |
| 316 | proc->ipi->remote_ipi_id); |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 317 | if (ret & IPI_MB_STATUS_RECV_PENDING) { |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 318 | return 1; |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 319 | } else { |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 320 | return 0; |
Venkatesh Yadav Abbarapu | 987fad3 | 2022-04-29 13:52:00 +0530 | [diff] [blame] | 321 | } |
Jolly Shah | 259afe5 | 2019-01-09 12:37:57 -0800 | [diff] [blame] | 322 | } |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 323 | |
Venkatesh Yadav Abbarapu | bfa2a2a | 2021-02-19 01:40:14 -0700 | [diff] [blame] | 324 | #if IPI_CRC_CHECK |
Venkatesh Yadav Abbarapu | 28b7759 | 2022-04-11 09:25:44 +0530 | [diff] [blame] | 325 | uint32_t calculate_crc(uint32_t payload[PAYLOAD_ARG_CNT], uint32_t bufsize) |
Venkatesh Yadav Abbarapu | 35a8be9 | 2019-04-04 14:23:32 +0530 | [diff] [blame] | 326 | { |
| 327 | uint32_t crcinit = CRC_INIT_VALUE; |
| 328 | uint32_t order = CRC_ORDER; |
| 329 | uint32_t polynom = CRC_POLYNOM; |
| 330 | uint32_t i, j, c, bit, datain, crcmask, crchighbit; |
| 331 | uint32_t crc = crcinit; |
| 332 | |
| 333 | crcmask = ((uint32_t)((1U << (order - 1U)) - 1U) << 1U) | 1U; |
| 334 | crchighbit = (uint32_t)(1U << (order - 1U)); |
| 335 | |
| 336 | for (i = 0U; i < bufsize; i++) { |
| 337 | datain = mmio_read_8((unsigned long)payload + i); |
| 338 | c = datain; |
| 339 | j = 0x80U; |
| 340 | while (j != 0U) { |
| 341 | bit = crc & crchighbit; |
| 342 | crc <<= 1U; |
| 343 | if (0U != (c & j)) |
| 344 | bit ^= crchighbit; |
| 345 | if (bit != 0U) |
| 346 | crc ^= polynom; |
| 347 | j >>= 1U; |
| 348 | } |
| 349 | crc &= crcmask; |
| 350 | } |
| 351 | return crc; |
| 352 | } |
| 353 | #endif |