351 lines · c
1// SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)2/* Copyright(c) 2015 - 2021 Intel Corporation */3#include <linux/bitfield.h>4#include <linux/spinlock.h>5#include <linux/types.h>6#include "adf_accel_devices.h"7#include "adf_common_drv.h"8#include "adf_pfvf_msg.h"9#include "adf_pfvf_pf_msg.h"10#include "adf_pfvf_pf_proto.h"11#include "adf_pfvf_utils.h"12 13typedef u8 (*pf2vf_blkmsg_data_getter_fn)(u8 const *blkmsg, u8 byte);14 15static const adf_pf2vf_blkmsg_provider pf2vf_blkmsg_providers[] = {16 NULL, /* no message type defined for value 0 */17 NULL, /* no message type defined for value 1 */18 adf_pf_capabilities_msg_provider, /* ADF_VF2PF_BLKMSG_REQ_CAP_SUMMARY */19 adf_pf_ring_to_svc_msg_provider, /* ADF_VF2PF_BLKMSG_REQ_RING_SVC_MAP */20};21 22/**23 * adf_send_pf2vf_msg() - send PF to VF message24 * @accel_dev: Pointer to acceleration device25 * @vf_nr: VF number to which the message will be sent26 * @msg: Message to send27 *28 * This function allows the PF to send a message to a specific VF.29 *30 * Return: 0 on success, error code otherwise.31 */32int adf_send_pf2vf_msg(struct adf_accel_dev *accel_dev, u8 vf_nr, struct pfvf_message msg)33{34 struct adf_pfvf_ops *pfvf_ops = GET_PFVF_OPS(accel_dev);35 u32 pfvf_offset = pfvf_ops->get_pf2vf_offset(vf_nr);36 37 return pfvf_ops->send_msg(accel_dev, msg, pfvf_offset,38 &accel_dev->pf.vf_info[vf_nr].pf2vf_lock);39}40 41/**42 * adf_recv_vf2pf_msg() - receive a VF to PF message43 * @accel_dev: Pointer to acceleration device44 * @vf_nr: Number of the VF from where the message will be received45 *46 * This function allows the PF to receive a message from a specific VF.47 *48 * Return: a valid message on success, zero otherwise.49 */50static struct pfvf_message adf_recv_vf2pf_msg(struct adf_accel_dev *accel_dev, u8 vf_nr)51{52 struct adf_accel_vf_info *vf_info = &accel_dev->pf.vf_info[vf_nr];53 struct adf_pfvf_ops *pfvf_ops = GET_PFVF_OPS(accel_dev);54 u32 pfvf_offset = pfvf_ops->get_vf2pf_offset(vf_nr);55 56 return pfvf_ops->recv_msg(accel_dev, pfvf_offset, vf_info->vf_compat_ver);57}58 59static adf_pf2vf_blkmsg_provider get_blkmsg_response_provider(u8 type)60{61 if (type >= ARRAY_SIZE(pf2vf_blkmsg_providers))62 return NULL;63 64 return pf2vf_blkmsg_providers[type];65}66 67/* Byte pf2vf_blkmsg_data_getter_fn callback */68static u8 adf_pf2vf_blkmsg_get_byte(u8 const *blkmsg, u8 index)69{70 return blkmsg[index];71}72 73/* CRC pf2vf_blkmsg_data_getter_fn callback */74static u8 adf_pf2vf_blkmsg_get_crc(u8 const *blkmsg, u8 count)75{76 /* count is 0-based, turn it into a length */77 return adf_pfvf_calc_blkmsg_crc(blkmsg, count + 1);78}79 80static int adf_pf2vf_blkmsg_get_data(struct adf_accel_vf_info *vf_info,81 u8 type, u8 byte, u8 max_size, u8 *data,82 pf2vf_blkmsg_data_getter_fn data_getter)83{84 u8 blkmsg[ADF_PFVF_BLKMSG_MSG_MAX_SIZE] = { 0 };85 struct adf_accel_dev *accel_dev = vf_info->accel_dev;86 adf_pf2vf_blkmsg_provider provider;87 u8 msg_size;88 89 provider = get_blkmsg_response_provider(type);90 91 if (unlikely(!provider)) {92 pr_err("QAT: No registered provider for message %d\n", type);93 *data = ADF_PF2VF_INVALID_BLOCK_TYPE;94 return -EINVAL;95 }96 97 if (unlikely((*provider)(accel_dev, blkmsg, vf_info->vf_compat_ver))) {98 pr_err("QAT: unknown error from provider for message %d\n", type);99 *data = ADF_PF2VF_UNSPECIFIED_ERROR;100 return -EINVAL;101 }102 103 msg_size = ADF_PFVF_BLKMSG_HEADER_SIZE + blkmsg[ADF_PFVF_BLKMSG_LEN_BYTE];104 105 if (unlikely(msg_size >= max_size)) {106 pr_err("QAT: Invalid size %d provided for message type %d\n",107 msg_size, type);108 *data = ADF_PF2VF_PAYLOAD_TRUNCATED;109 return -EINVAL;110 }111 112 if (unlikely(byte >= msg_size)) {113 pr_err("QAT: Out-of-bound byte number %d (msg size %d)\n",114 byte, msg_size);115 *data = ADF_PF2VF_INVALID_BYTE_NUM_REQ;116 return -EINVAL;117 }118 119 *data = data_getter(blkmsg, byte);120 return 0;121}122 123static struct pfvf_message handle_blkmsg_req(struct adf_accel_vf_info *vf_info,124 struct pfvf_message req)125{126 u8 resp_type = ADF_PF2VF_BLKMSG_RESP_TYPE_ERROR;127 struct pfvf_message resp = { 0 };128 u8 resp_data = 0;129 u8 blk_type;130 u8 blk_byte;131 u8 byte_max;132 133 switch (req.type) {134 case ADF_VF2PF_MSGTYPE_LARGE_BLOCK_REQ:135 blk_type = FIELD_GET(ADF_VF2PF_LARGE_BLOCK_TYPE_MASK, req.data)136 + ADF_VF2PF_MEDIUM_BLOCK_TYPE_MAX + 1;137 blk_byte = FIELD_GET(ADF_VF2PF_LARGE_BLOCK_BYTE_MASK, req.data);138 byte_max = ADF_VF2PF_LARGE_BLOCK_BYTE_MAX;139 break;140 case ADF_VF2PF_MSGTYPE_MEDIUM_BLOCK_REQ:141 blk_type = FIELD_GET(ADF_VF2PF_MEDIUM_BLOCK_TYPE_MASK, req.data)142 + ADF_VF2PF_SMALL_BLOCK_TYPE_MAX + 1;143 blk_byte = FIELD_GET(ADF_VF2PF_MEDIUM_BLOCK_BYTE_MASK, req.data);144 byte_max = ADF_VF2PF_MEDIUM_BLOCK_BYTE_MAX;145 break;146 case ADF_VF2PF_MSGTYPE_SMALL_BLOCK_REQ:147 blk_type = FIELD_GET(ADF_VF2PF_SMALL_BLOCK_TYPE_MASK, req.data);148 blk_byte = FIELD_GET(ADF_VF2PF_SMALL_BLOCK_BYTE_MASK, req.data);149 byte_max = ADF_VF2PF_SMALL_BLOCK_BYTE_MAX;150 break;151 }152 153 /* Is this a request for CRC or data? */154 if (FIELD_GET(ADF_VF2PF_BLOCK_CRC_REQ_MASK, req.data)) {155 dev_dbg(&GET_DEV(vf_info->accel_dev),156 "BlockMsg of type %d for CRC over %d bytes received from VF%d\n",157 blk_type, blk_byte + 1, vf_info->vf_nr);158 159 if (!adf_pf2vf_blkmsg_get_data(vf_info, blk_type, blk_byte,160 byte_max, &resp_data,161 adf_pf2vf_blkmsg_get_crc))162 resp_type = ADF_PF2VF_BLKMSG_RESP_TYPE_CRC;163 } else {164 dev_dbg(&GET_DEV(vf_info->accel_dev),165 "BlockMsg of type %d for data byte %d received from VF%d\n",166 blk_type, blk_byte, vf_info->vf_nr);167 168 if (!adf_pf2vf_blkmsg_get_data(vf_info, blk_type, blk_byte,169 byte_max, &resp_data,170 adf_pf2vf_blkmsg_get_byte))171 resp_type = ADF_PF2VF_BLKMSG_RESP_TYPE_DATA;172 }173 174 resp.type = ADF_PF2VF_MSGTYPE_BLKMSG_RESP;175 resp.data = FIELD_PREP(ADF_PF2VF_BLKMSG_RESP_TYPE_MASK, resp_type) |176 FIELD_PREP(ADF_PF2VF_BLKMSG_RESP_DATA_MASK, resp_data);177 178 return resp;179}180 181static struct pfvf_message handle_rp_reset_req(struct adf_accel_dev *accel_dev, u8 vf_nr,182 struct pfvf_message req)183{184 struct adf_hw_device_data *hw_data = accel_dev->hw_device;185 struct pfvf_message resp = {186 .type = ADF_PF2VF_MSGTYPE_RP_RESET_RESP,187 .data = RPRESET_SUCCESS188 };189 u32 bank_number;190 u32 rsvd_field;191 192 bank_number = FIELD_GET(ADF_VF2PF_RNG_RESET_RP_MASK, req.data);193 rsvd_field = FIELD_GET(ADF_VF2PF_RNG_RESET_RSVD_MASK, req.data);194 195 dev_dbg(&GET_DEV(accel_dev),196 "Ring Pair Reset Message received from VF%d for bank 0x%x\n",197 vf_nr, bank_number);198 199 if (!hw_data->ring_pair_reset || rsvd_field) {200 dev_dbg(&GET_DEV(accel_dev),201 "Ring Pair Reset for VF%d is not supported\n", vf_nr);202 resp.data = RPRESET_NOT_SUPPORTED;203 goto out;204 }205 206 if (bank_number >= hw_data->num_banks_per_vf) {207 dev_err(&GET_DEV(accel_dev),208 "Invalid bank number (0x%x) from VF%d for Ring Reset\n",209 bank_number, vf_nr);210 resp.data = RPRESET_INVAL_BANK;211 goto out;212 }213 214 /* Convert the VF provided value to PF bank number */215 bank_number = vf_nr * hw_data->num_banks_per_vf + bank_number;216 if (hw_data->ring_pair_reset(accel_dev, bank_number)) {217 dev_dbg(&GET_DEV(accel_dev),218 "Ring pair reset for VF%d failure\n", vf_nr);219 resp.data = RPRESET_TIMEOUT;220 goto out;221 }222 223 dev_dbg(&GET_DEV(accel_dev),224 "Ring pair reset for VF%d successfully\n", vf_nr);225 226out:227 return resp;228}229 230static int adf_handle_vf2pf_msg(struct adf_accel_dev *accel_dev, u8 vf_nr,231 struct pfvf_message msg, struct pfvf_message *resp)232{233 struct adf_accel_vf_info *vf_info = &accel_dev->pf.vf_info[vf_nr];234 235 switch (msg.type) {236 case ADF_VF2PF_MSGTYPE_COMPAT_VER_REQ:237 {238 u8 vf_compat_ver = msg.data;239 u8 compat;240 241 dev_dbg(&GET_DEV(accel_dev),242 "VersionRequest received from VF%d (vers %d) to PF (vers %d)\n",243 vf_nr, vf_compat_ver, ADF_PFVF_COMPAT_THIS_VERSION);244 245 compat = adf_vf_compat_checker(vf_compat_ver);246 vf_info->vf_compat_ver = vf_compat_ver;247 248 resp->type = ADF_PF2VF_MSGTYPE_VERSION_RESP;249 resp->data = FIELD_PREP(ADF_PF2VF_VERSION_RESP_VERS_MASK,250 ADF_PFVF_COMPAT_THIS_VERSION) |251 FIELD_PREP(ADF_PF2VF_VERSION_RESP_RESULT_MASK, compat);252 }253 break;254 case ADF_VF2PF_MSGTYPE_VERSION_REQ:255 {256 u8 compat;257 258 dev_dbg(&GET_DEV(accel_dev),259 "Legacy VersionRequest received from VF%d to PF (vers 1.1)\n",260 vf_nr);261 262 /* legacy driver, VF compat_ver is 0 */263 vf_info->vf_compat_ver = 0;264 265 /* PF always newer than legacy VF */266 compat = ADF_PF2VF_VF_COMPATIBLE;267 268 /* Set legacy major and minor version to the latest, 1.1 */269 resp->type = ADF_PF2VF_MSGTYPE_VERSION_RESP;270 resp->data = FIELD_PREP(ADF_PF2VF_VERSION_RESP_VERS_MASK, 0x11) |271 FIELD_PREP(ADF_PF2VF_VERSION_RESP_RESULT_MASK, compat);272 }273 break;274 case ADF_VF2PF_MSGTYPE_INIT:275 {276 dev_dbg(&GET_DEV(accel_dev),277 "Init message received from VF%d\n", vf_nr);278 vf_info->init = true;279 }280 break;281 case ADF_VF2PF_MSGTYPE_SHUTDOWN:282 {283 dev_dbg(&GET_DEV(accel_dev),284 "Shutdown message received from VF%d\n", vf_nr);285 vf_info->init = false;286 }287 break;288 case ADF_VF2PF_MSGTYPE_RESTARTING_COMPLETE:289 {290 dev_dbg(&GET_DEV(accel_dev),291 "Restarting Complete received from VF%d\n", vf_nr);292 vf_info->restarting = false;293 vf_info->init = false;294 }295 break;296 case ADF_VF2PF_MSGTYPE_LARGE_BLOCK_REQ:297 case ADF_VF2PF_MSGTYPE_MEDIUM_BLOCK_REQ:298 case ADF_VF2PF_MSGTYPE_SMALL_BLOCK_REQ:299 *resp = handle_blkmsg_req(vf_info, msg);300 break;301 case ADF_VF2PF_MSGTYPE_RP_RESET:302 *resp = handle_rp_reset_req(accel_dev, vf_nr, msg);303 break;304 default:305 dev_dbg(&GET_DEV(accel_dev),306 "Unknown message from VF%d (type 0x%.4x, data: 0x%.4x)\n",307 vf_nr, msg.type, msg.data);308 return -ENOMSG;309 }310 311 return 0;312}313 314bool adf_recv_and_handle_vf2pf_msg(struct adf_accel_dev *accel_dev, u32 vf_nr)315{316 struct pfvf_message req;317 struct pfvf_message resp = {0};318 319 req = adf_recv_vf2pf_msg(accel_dev, vf_nr);320 if (!req.type) /* Legacy or no message */321 return true;322 323 if (adf_handle_vf2pf_msg(accel_dev, vf_nr, req, &resp))324 return false;325 326 if (resp.type && adf_send_pf2vf_msg(accel_dev, vf_nr, resp))327 dev_err(&GET_DEV(accel_dev),328 "Failed to send response to VF%d\n", vf_nr);329 330 return true;331}332 333/**334 * adf_enable_pf2vf_comms() - Function enables communication from pf to vf335 *336 * @accel_dev: Pointer to acceleration device virtual function.337 *338 * This function carries out the necessary steps to setup and start the PFVF339 * communication channel, if any.340 *341 * Return: 0 on success, error code otherwise.342 */343int adf_enable_pf2vf_comms(struct adf_accel_dev *accel_dev)344{345 adf_pfvf_crc_init();346 spin_lock_init(&accel_dev->pf.vf2pf_ints_lock);347 348 return 0;349}350EXPORT_SYMBOL_GPL(adf_enable_pf2vf_comms);351