1// SPDX-License-Identifier: GPL-2.0 2/* Copyright(c) 2023 Advanced Micro Devices, Inc */ 3 4#include <linux/pci.h> 5 6#include "core.h" 7#include <linux/pds/pds_auxbus.h> 8 9/** 10 * pds_client_register - Link the client to the firmware 11 * @pf: ptr to the PF driver's private data struct 12 * @devname: name that includes service into, e.g. pds_core.vDPA 13 * 14 * Return: positive client ID (ci) on success, or 15 * negative for error 16 */ 17int pds_client_register(struct pdsc *pf, char *devname) 18{ 19 union pds_core_adminq_comp comp = {}; 20 union pds_core_adminq_cmd cmd = {}; 21 int err; 22 u16 ci; 23 24 cmd.client_reg.opcode = PDS_AQ_CMD_CLIENT_REG; 25 strscpy(cmd.client_reg.devname, devname, 26 sizeof(cmd.client_reg.devname)); 27 28 err = pdsc_adminq_post(pf, &cmd, &comp, false); 29 if (err) { 30 dev_info(pf->dev, "register dev_name %s with DSC failed, status %d: %pe\n", 31 devname, comp.status, ERR_PTR(err)); 32 return err; 33 } 34 35 ci = le16_to_cpu(comp.client_reg.client_id); 36 if (!ci) { 37 dev_err(pf->dev, "%s: device returned null client_id\n", 38 __func__); 39 return -EIO; 40 } 41 42 dev_dbg(pf->dev, "%s: device returned client_id %d for %s\n", 43 __func__, ci, devname); 44 45 return ci; 46} 47EXPORT_SYMBOL_GPL(pds_client_register); 48 49/** 50 * pds_client_unregister - Unlink the client from the firmware 51 * @pf: ptr to the PF driver's private data struct 52 * @client_id: id returned from pds_client_register() 53 * 54 * Return: 0 on success, or 55 * negative for error 56 */ 57int pds_client_unregister(struct pdsc *pf, u16 client_id) 58{ 59 union pds_core_adminq_comp comp = {}; 60 union pds_core_adminq_cmd cmd = {}; 61 int err; 62 63 cmd.client_unreg.opcode = PDS_AQ_CMD_CLIENT_UNREG; 64 cmd.client_unreg.client_id = cpu_to_le16(client_id); 65 66 err = pdsc_adminq_post(pf, &cmd, &comp, false); 67 if (err) 68 dev_info(pf->dev, "unregister client_id %d failed, status %d: %pe\n", 69 client_id, comp.status, ERR_PTR(err)); 70 71 return err; 72} 73EXPORT_SYMBOL_GPL(pds_client_unregister); 74 75/** 76 * pds_client_adminq_cmd - Process an adminq request for the client 77 * @padev: ptr to the client device 78 * @req: ptr to buffer with request 79 * @req_len: length of actual struct used for request 80 * @resp: ptr to buffer where answer is to be copied 81 * @flags: optional flags from pds_core_adminq_flags 82 * 83 * Return: 0 on success, or 84 * negative for error 85 * 86 * Client sends pointers to request and response buffers 87 * Core copies request data into pds_core_client_request_cmd 88 * Core sets other fields as needed 89 * Core posts to AdminQ 90 * Core copies completion data into response buffer 91 */ 92int pds_client_adminq_cmd(struct pds_auxiliary_dev *padev, 93 union pds_core_adminq_cmd *req, 94 size_t req_len, 95 union pds_core_adminq_comp *resp, 96 u64 flags) 97{ 98 union pds_core_adminq_cmd cmd = {}; 99 struct pci_dev *pf_pdev; 100 struct pdsc *pf; 101 size_t cp_len; 102 int err; 103 104 pf_pdev = pci_physfn(padev->vf_pdev); 105 pf = pci_get_drvdata(pf_pdev); 106 107 dev_dbg(pf->dev, "%s: %s opcode %d\n", 108 __func__, dev_name(&padev->aux_dev.dev), req->opcode); 109 110 if (pf->state) 111 return -ENXIO; 112 113 /* Wrap the client's request */ 114 cmd.client_request.opcode = PDS_AQ_CMD_CLIENT_CMD; 115 cmd.client_request.client_id = cpu_to_le16(padev->client_id); 116 cp_len = min_t(size_t, req_len, sizeof(cmd.client_request.client_cmd)); 117 memcpy(cmd.client_request.client_cmd, req, cp_len); 118 119 err = pdsc_adminq_post(pf, &cmd, resp, 120 !!(flags & PDS_AQ_FLAG_FASTPOLL)); 121 if (err && err != -EAGAIN) 122 dev_info(pf->dev, "client admin cmd failed: %pe\n", 123 ERR_PTR(err)); 124 125 return err; 126} 127EXPORT_SYMBOL_GPL(pds_client_adminq_cmd); 128 129static void pdsc_auxbus_dev_release(struct device *dev) 130{ 131 struct pds_auxiliary_dev *padev = 132 container_of(dev, struct pds_auxiliary_dev, aux_dev.dev); 133 134 kfree(padev); 135} 136 137static struct pds_auxiliary_dev *pdsc_auxbus_dev_register(struct pdsc *cf, 138 struct pdsc *pf, 139 u16 client_id, 140 char *name) 141{ 142 struct auxiliary_device *aux_dev; 143 struct pds_auxiliary_dev *padev; 144 int err; 145 146 padev = kzalloc(sizeof(*padev), GFP_KERNEL); 147 if (!padev) 148 return ERR_PTR(-ENOMEM); 149 150 padev->vf_pdev = cf->pdev; 151 padev->client_id = client_id; 152 153 aux_dev = &padev->aux_dev; 154 aux_dev->name = name; 155 aux_dev->id = cf->uid; 156 aux_dev->dev.parent = cf->dev; 157 aux_dev->dev.release = pdsc_auxbus_dev_release; 158 159 err = auxiliary_device_init(aux_dev); 160 if (err < 0) { 161 dev_warn(cf->dev, "auxiliary_device_init of %s failed: %pe\n", 162 name, ERR_PTR(err)); 163 kfree(padev); 164 return ERR_PTR(err); 165 } 166 167 err = auxiliary_device_add(aux_dev); 168 if (err) { 169 dev_warn(cf->dev, "auxiliary_device_add of %s failed: %pe\n", 170 name, ERR_PTR(err)); 171 auxiliary_device_uninit(aux_dev); 172 return ERR_PTR(err); 173 } 174 175 return padev; 176} 177 178int pdsc_auxbus_dev_del(struct pdsc *cf, struct pdsc *pf) 179{ 180 struct pds_auxiliary_dev *padev; 181 int err = 0; 182 183 if (!cf) 184 return -ENODEV; 185 186 mutex_lock(&pf->config_lock); 187 188 padev = pf->vfs[cf->vf_id].padev; 189 if (padev) { 190 pds_client_unregister(pf, padev->client_id); 191 auxiliary_device_delete(&padev->aux_dev); 192 auxiliary_device_uninit(&padev->aux_dev); 193 padev->client_id = 0; 194 } 195 pf->vfs[cf->vf_id].padev = NULL; 196 197 mutex_unlock(&pf->config_lock); 198 return err; 199} 200 201int pdsc_auxbus_dev_add(struct pdsc *cf, struct pdsc *pf) 202{ 203 struct pds_auxiliary_dev *padev; 204 char devname[PDS_DEVNAME_LEN]; 205 enum pds_core_vif_types vt; 206 unsigned long mask; 207 u16 vt_support; 208 int client_id; 209 int err = 0; 210 211 if (!cf) 212 return -ENODEV; 213 214 mutex_lock(&pf->config_lock); 215 216 mask = BIT_ULL(PDSC_S_FW_DEAD) | 217 BIT_ULL(PDSC_S_STOPPING_DRIVER); 218 if (cf->state & mask) { 219 dev_err(pf->dev, "%s: can't add dev, VF client in bad state %#lx\n", 220 __func__, cf->state); 221 err = -ENXIO; 222 goto out_unlock; 223 } 224 225 /* We only support vDPA so far, so it is the only one to 226 * be verified that it is available in the Core device and 227 * enabled in the devlink param. In the future this might 228 * become a loop for several VIF types. 229 */ 230 231 /* Verify that the type is supported and enabled. It is not 232 * an error if there is no auxbus device support for this 233 * VF, it just means something else needs to happen with it. 234 */ 235 vt = PDS_DEV_TYPE_VDPA; 236 vt_support = !!le16_to_cpu(pf->dev_ident.vif_types[vt]); 237 if (!(vt_support && 238 pf->viftype_status[vt].supported && 239 pf->viftype_status[vt].enabled)) 240 goto out_unlock; 241 242 /* Need to register with FW and get the client_id before 243 * creating the aux device so that the aux client can run 244 * adminq commands as part its probe 245 */ 246 snprintf(devname, sizeof(devname), "%s.%s.%d", 247 PDS_CORE_DRV_NAME, pf->viftype_status[vt].name, cf->uid); 248 client_id = pds_client_register(pf, devname); 249 if (client_id < 0) { 250 err = client_id; 251 goto out_unlock; 252 } 253 254 padev = pdsc_auxbus_dev_register(cf, pf, client_id, 255 pf->viftype_status[vt].name); 256 if (IS_ERR(padev)) { 257 pds_client_unregister(pf, client_id); 258 err = PTR_ERR(padev); 259 goto out_unlock; 260 } 261 pf->vfs[cf->vf_id].padev = padev; 262 263out_unlock: 264 mutex_unlock(&pf->config_lock); 265 return err; 266} 267