drivers/fpga/dfl-afu-error.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for FPGA Accelerated Function Unit (AFU) Error Reporting
   4  *
   5  * Copyright 2019 Intel Corporation, Inc.
   6  *
   7  * Authors:
   8  *   Wu Hao <hao.wu@linux.intel.com>
   9  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
  10  *   Joseph Grecco <joe.grecco@intel.com>
  11  *   Enno Luebbers <enno.luebbers@intel.com>
  12  *   Tim Whisonant <tim.whisonant@intel.com>
  13  *   Ananda Ravuri <ananda.ravuri@intel.com>
  14  *   Mitchel Henry <henry.mitchel@intel.com>
  15  */
  16
  17 #include <linux/fpga-dfl.h>
  18 #include <linux/uaccess.h>
  19
  20 #include "dfl-afu.h"
  21
  22 #define PORT_ERROR_MASK         0x8
  23 #define PORT_ERROR              0x10
  24 #define PORT_FIRST_ERROR        0x18
  25 #define PORT_MALFORMED_REQ0     0x20
  26 #define PORT_MALFORMED_REQ1     0x28
  27
  28 #define ERROR_MASK              GENMASK_ULL(63, 0)
  29
  30 /* mask or unmask port errors by the error mask register. */
  31 static void __afu_port_err_mask(struct device *dev, bool mask)
  32 {
  33         void __iomem *base;
  34
  35         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
  36
  37         writeq(mask ? ERROR_MASK : 0, base + PORT_ERROR_MASK);
  38 }
  39
  40 static void afu_port_err_mask(struct device *dev, bool mask)
  41 {
  42         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
  43
  44         mutex_lock(&pdata->lock);
  45         __afu_port_err_mask(dev, mask);
  46         mutex_unlock(&pdata->lock);
  47 }
  48
  49 /* clear port errors. */
  50 static int afu_port_err_clear(struct device *dev, u64 err)
  51 {
  52         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
  53         struct platform_device *pdev = to_platform_device(dev);
  54         void __iomem *base_err, *base_hdr;
  55         int ret = -EBUSY;
  56         u64 v;
  57
  58         base_err = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
  59         base_hdr = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_HEADER);
  60
  61         mutex_lock(&pdata->lock);
  62
  63         /*
  64          * clear Port Errors
  65          *
  66          * - Check for AP6 State
  67          * - Halt Port by keeping Port in reset
  68          * - Set PORT Error mask to all 1 to mask errors
  69          * - Clear all errors
  70          * - Set Port mask to all 0 to enable errors
  71          * - All errors start capturing new errors
  72          * - Enable Port by pulling the port out of reset
  73          */
  74
  75         /* if device is still in AP6 power state, can not clear any error. */
  76         v = readq(base_hdr + PORT_HDR_STS);
  77         if (FIELD_GET(PORT_STS_PWR_STATE, v) == PORT_STS_PWR_STATE_AP6) {
  78                 dev_err(dev, "Could not clear errors, device in AP6 state.\n");
  79                 goto done;
  80         }
  81
  82         /* Halt Port by keeping Port in reset */
  83         ret = __afu_port_disable(pdev);
  84         if (ret)
  85                 goto done;
  86
  87         /* Mask all errors */
  88         __afu_port_err_mask(dev, true);
  89
  90         /* Clear errors if err input matches with current port errors.*/
  91         v = readq(base_err + PORT_ERROR);
  92
  93         if (v == err) {
  94                 writeq(v, base_err + PORT_ERROR);
  95
  96                 v = readq(base_err + PORT_FIRST_ERROR);
  97                 writeq(v, base_err + PORT_FIRST_ERROR);
  98         } else {
  99                 ret = -EINVAL;
 100         }
 101
 102         /* Clear mask */
 103         __afu_port_err_mask(dev, false);
 104
 105         /* Enable the Port by clear the reset */
 106         __afu_port_enable(pdev);
 107
 108 done:
 109         mutex_unlock(&pdata->lock);
 110         return ret;
 111 }
 112
 113 static ssize_t errors_show(struct device *dev, struct device_attribute *attr,
 114                            char *buf)
 115 {
 116         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
 117         void __iomem *base;
 118         u64 error;
 119
 120         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
 121
 122         mutex_lock(&pdata->lock);
 123         error = readq(base + PORT_ERROR);
 124         mutex_unlock(&pdata->lock);
 125
 126         return sprintf(buf, "0x%llx\n", (unsigned long long)error);
 127 }
 128
 129 static ssize_t errors_store(struct device *dev, struct device_attribute *attr,
 130                             const char *buff, size_t count)
 131 {
 132         u64 value;
 133         int ret;
 134
 135         if (kstrtou64(buff, 0, &value))
 136                 return -EINVAL;
 137
 138         ret = afu_port_err_clear(dev, value);
 139
 140         return ret ? ret : count;
 141 }
 142 static DEVICE_ATTR_RW(errors);
 143
 144 static ssize_t first_error_show(struct device *dev,
 145                                 struct device_attribute *attr, char *buf)
 146 {
 147         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
 148         void __iomem *base;
 149         u64 error;
 150
 151         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
 152
 153         mutex_lock(&pdata->lock);
 154         error = readq(base + PORT_FIRST_ERROR);
 155         mutex_unlock(&pdata->lock);
 156
 157         return sprintf(buf, "0x%llx\n", (unsigned long long)error);
 158 }
 159 static DEVICE_ATTR_RO(first_error);
 160
 161 static ssize_t first_malformed_req_show(struct device *dev,
 162                                         struct device_attribute *attr,
 163                                         char *buf)
 164 {
 165         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
 166         void __iomem *base;
 167         u64 req0, req1;
 168
 169         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
 170
 171         mutex_lock(&pdata->lock);
 172         req0 = readq(base + PORT_MALFORMED_REQ0);
 173         req1 = readq(base + PORT_MALFORMED_REQ1);
 174         mutex_unlock(&pdata->lock);
 175
 176         return sprintf(buf, "0x%016llx%016llx\n",
 177                        (unsigned long long)req1, (unsigned long long)req0);
 178 }
 179 static DEVICE_ATTR_RO(first_malformed_req);
 180
 181 static struct attribute *port_err_attrs[] = {
 182         &dev_attr_errors.attr,
 183         &dev_attr_first_error.attr,
 184         &dev_attr_first_malformed_req.attr,
 185         NULL,
 186 };
 187
 188 static umode_t port_err_attrs_visible(struct kobject *kobj,
 189                                       struct attribute *attr, int n)
 190 {
 191         struct device *dev = kobj_to_dev(kobj);
 192
 193         /*
 194          * sysfs entries are visible only if related private feature is
 195          * enumerated.
 196          */
 197         if (!dfl_get_feature_by_id(dev, PORT_FEATURE_ID_ERROR))
 198                 return 0;
 199
 200         return attr->mode;
 201 }
 202
 203 const struct attribute_group port_err_group = {
 204         .name       = "errors",
 205         .attrs      = port_err_attrs,
 206         .is_visible = port_err_attrs_visible,
 207 };
 208
 209 static int port_err_init(struct platform_device *pdev,
 210                          struct dfl_feature *feature)
 211 {
 212         afu_port_err_mask(&pdev->dev, false);
 213
 214         return 0;
 215 }
 216
 217 static void port_err_uinit(struct platform_device *pdev,
 218                            struct dfl_feature *feature)
 219 {
 220         afu_port_err_mask(&pdev->dev, true);
 221 }
 222
 223 static long
 224 port_err_ioctl(struct platform_device *pdev, struct dfl_feature *feature,
 225                unsigned int cmd, unsigned long arg)
 226 {
 227         switch (cmd) {
 228         case DFL_FPGA_PORT_ERR_GET_IRQ_NUM:
 229                 return dfl_feature_ioctl_get_num_irqs(pdev, feature, arg);
 230         case DFL_FPGA_PORT_ERR_SET_IRQ:
 231                 return dfl_feature_ioctl_set_irq(pdev, feature, arg);
 232         default:
 233                 dev_dbg(&pdev->dev, "%x cmd not handled", cmd);
 234                 return -ENODEV;
 235         }
 236 }
 237
 238 const struct dfl_feature_id port_err_id_table[] = {
 239         {.id = PORT_FEATURE_ID_ERROR,},
 240         {0,}
 241 };
 242
 243 const struct dfl_feature_ops port_err_ops = {
 244         .init = port_err_init,
 245         .uinit = port_err_uinit,
 246         .ioctl = port_err_ioctl,
 247 };