drivers/net/ethernet/amd/pds_core/auxbus.c

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