root/drivers/misc/genwqe/card_sysfs.c

DEFINITIONS

1. status_show
2. appid_show
3. version_show
4. type_show
5. tempsens_show
6. freerunning_timer_show
7. queue_working_time_show
8. base_clock_show
9. curr_bitstream_show
10. next_bitstream_show
11. next_bitstream_store
12. reload_bitstream_store
13. genwqe_is_visible

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /**
   3  * IBM Accelerator Family 'GenWQE'
   4  *
   5  * (C) Copyright IBM Corp. 2013
   6  *
   7  * Author: Frank Haverkamp <haver@linux.vnet.ibm.com>
   8  * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com>
   9  * Author: Michael Jung <mijung@gmx.net>
  10  * Author: Michael Ruettger <michael@ibmra.de>
  11  */
  12 
  13 /*
  14  * Sysfs interfaces for the GenWQE card. There are attributes to query
  15  * the version of the bitstream as well as some for the driver. For
  16  * debugging, please also see the debugfs interfaces of this driver.
  17  */
  18 
  19 #include <linux/kernel.h>
  20 #include <linux/types.h>
  21 #include <linux/module.h>
  22 #include <linux/pci.h>
  23 #include <linux/string.h>
  24 #include <linux/fs.h>
  25 #include <linux/sysfs.h>
  26 #include <linux/ctype.h>
  27 #include <linux/device.h>
  28 
  29 #include "card_base.h"
  30 #include "card_ddcb.h"
  31 
  32 static const char * const genwqe_types[] = {
  33         [GENWQE_TYPE_ALTERA_230] = "GenWQE4-230",
  34         [GENWQE_TYPE_ALTERA_530] = "GenWQE4-530",
  35         [GENWQE_TYPE_ALTERA_A4]  = "GenWQE5-A4",
  36         [GENWQE_TYPE_ALTERA_A7]  = "GenWQE5-A7",
  37 };
  38 
  39 static ssize_t status_show(struct device *dev, struct device_attribute *attr,
  40                            char *buf)
  41 {
  42         struct genwqe_dev *cd = dev_get_drvdata(dev);
  43         const char *cs[GENWQE_CARD_STATE_MAX] = { "unused", "used", "error" };
  44 
  45         return sprintf(buf, "%s\n", cs[cd->card_state]);
  46 }
  47 static DEVICE_ATTR_RO(status);
  48 
  49 static ssize_t appid_show(struct device *dev, struct device_attribute *attr,
  50                           char *buf)
  51 {
  52         char app_name[5];
  53         struct genwqe_dev *cd = dev_get_drvdata(dev);
  54 
  55         genwqe_read_app_id(cd, app_name, sizeof(app_name));
  56         return sprintf(buf, "%s\n", app_name);
  57 }
  58 static DEVICE_ATTR_RO(appid);
  59 
  60 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
  61                             char *buf)
  62 {
  63         u64 slu_id, app_id;
  64         struct genwqe_dev *cd = dev_get_drvdata(dev);
  65 
  66         slu_id = __genwqe_readq(cd, IO_SLU_UNITCFG);
  67         app_id = __genwqe_readq(cd, IO_APP_UNITCFG);
  68 
  69         return sprintf(buf, "%016llx.%016llx\n", slu_id, app_id);
  70 }
  71 static DEVICE_ATTR_RO(version);
  72 
  73 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
  74                          char *buf)
  75 {
  76         u8 card_type;
  77         struct genwqe_dev *cd = dev_get_drvdata(dev);
  78 
  79         card_type = genwqe_card_type(cd);
  80         return sprintf(buf, "%s\n", (card_type >= ARRAY_SIZE(genwqe_types)) ?
  81                        "invalid" : genwqe_types[card_type]);
  82 }
  83 static DEVICE_ATTR_RO(type);
  84 
  85 static ssize_t tempsens_show(struct device *dev, struct device_attribute *attr,
  86                              char *buf)
  87 {
  88         u64 tempsens;
  89         struct genwqe_dev *cd = dev_get_drvdata(dev);
  90 
  91         tempsens = __genwqe_readq(cd, IO_SLU_TEMPERATURE_SENSOR);
  92         return sprintf(buf, "%016llx\n", tempsens);
  93 }
  94 static DEVICE_ATTR_RO(tempsens);
  95 
  96 static ssize_t freerunning_timer_show(struct device *dev,
  97                                       struct device_attribute *attr,
  98                                       char *buf)
  99 {
 100         u64 t;
 101         struct genwqe_dev *cd = dev_get_drvdata(dev);
 102 
 103         t = __genwqe_readq(cd, IO_SLC_FREE_RUNNING_TIMER);
 104         return sprintf(buf, "%016llx\n", t);
 105 }
 106 static DEVICE_ATTR_RO(freerunning_timer);
 107 
 108 static ssize_t queue_working_time_show(struct device *dev,
 109                                        struct device_attribute *attr,
 110                                        char *buf)
 111 {
 112         u64 t;
 113         struct genwqe_dev *cd = dev_get_drvdata(dev);
 114 
 115         t = __genwqe_readq(cd, IO_SLC_QUEUE_WTIME);
 116         return sprintf(buf, "%016llx\n", t);
 117 }
 118 static DEVICE_ATTR_RO(queue_working_time);
 119 
 120 static ssize_t base_clock_show(struct device *dev,
 121                                struct device_attribute *attr,
 122                                char *buf)
 123 {
 124         u64 base_clock;
 125         struct genwqe_dev *cd = dev_get_drvdata(dev);
 126 
 127         base_clock = genwqe_base_clock_frequency(cd);
 128         return sprintf(buf, "%lld\n", base_clock);
 129 }
 130 static DEVICE_ATTR_RO(base_clock);
 131 
 132 /**
 133  * curr_bitstream_show() - Show the current bitstream id
 134  *
 135  * There is a bug in some old versions of the CPLD which selects the
 136  * bitstream, which causes the IO_SLU_BITSTREAM register to report
 137  * unreliable data in very rare cases. This makes this sysfs
 138  * unreliable up to the point were a new CPLD version is being used.
 139  *
 140  * Unfortunately there is no automatic way yet to query the CPLD
 141  * version, such that you need to manually ensure via programming
 142  * tools that you have a recent version of the CPLD software.
 143  *
 144  * The proposed circumvention is to use a special recovery bitstream
 145  * on the backup partition (0) to identify problems while loading the
 146  * image.
 147  */
 148 static ssize_t curr_bitstream_show(struct device *dev,
 149                                    struct device_attribute *attr, char *buf)
 150 {
 151         int curr_bitstream;
 152         struct genwqe_dev *cd = dev_get_drvdata(dev);
 153 
 154         curr_bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM) & 0x1;
 155         return sprintf(buf, "%d\n", curr_bitstream);
 156 }
 157 static DEVICE_ATTR_RO(curr_bitstream);
 158 
 159 /**
 160  * next_bitstream_show() - Show the next activated bitstream
 161  *
 162  * IO_SLC_CFGREG_SOFTRESET: This register can only be accessed by the PF.
 163  */
 164 static ssize_t next_bitstream_show(struct device *dev,
 165                                    struct device_attribute *attr, char *buf)
 166 {
 167         int next_bitstream;
 168         struct genwqe_dev *cd = dev_get_drvdata(dev);
 169 
 170         switch ((cd->softreset & 0xc) >> 2) {
 171         case 0x2:
 172                 next_bitstream =  0;
 173                 break;
 174         case 0x3:
 175                 next_bitstream =  1;
 176                 break;
 177         default:
 178                 next_bitstream = -1;
 179                 break;          /* error */
 180         }
 181         return sprintf(buf, "%d\n", next_bitstream);
 182 }
 183 
 184 static ssize_t next_bitstream_store(struct device *dev,
 185                                     struct device_attribute *attr,
 186                                     const char *buf, size_t count)
 187 {
 188         int partition;
 189         struct genwqe_dev *cd = dev_get_drvdata(dev);
 190 
 191         if (kstrtoint(buf, 0, &partition) < 0)
 192                 return -EINVAL;
 193 
 194         switch (partition) {
 195         case 0x0:
 196                 cd->softreset = 0x78;
 197                 break;
 198         case 0x1:
 199                 cd->softreset = 0x7c;
 200                 break;
 201         default:
 202                 return -EINVAL;
 203         }
 204 
 205         __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, cd->softreset);
 206         return count;
 207 }
 208 static DEVICE_ATTR_RW(next_bitstream);
 209 
 210 static ssize_t reload_bitstream_store(struct device *dev,
 211                                 struct device_attribute *attr,
 212                                 const char *buf, size_t count)
 213 {
 214         int reload;
 215         struct genwqe_dev *cd = dev_get_drvdata(dev);
 216 
 217         if (kstrtoint(buf, 0, &reload) < 0)
 218                 return -EINVAL;
 219 
 220         if (reload == 0x1) {
 221                 if (cd->card_state == GENWQE_CARD_UNUSED ||
 222                     cd->card_state == GENWQE_CARD_USED)
 223                         cd->card_state = GENWQE_CARD_RELOAD_BITSTREAM;
 224                 else
 225                         return -EIO;
 226         } else {
 227                 return -EINVAL;
 228         }
 229 
 230         return count;
 231 }
 232 static DEVICE_ATTR_WO(reload_bitstream);
 233 
 234 /*
 235  * Create device_attribute structures / params: name, mode, show, store
 236  * additional flag if valid in VF
 237  */
 238 static struct attribute *genwqe_attributes[] = {
 239         &dev_attr_tempsens.attr,
 240         &dev_attr_next_bitstream.attr,
 241         &dev_attr_curr_bitstream.attr,
 242         &dev_attr_base_clock.attr,
 243         &dev_attr_type.attr,
 244         &dev_attr_version.attr,
 245         &dev_attr_appid.attr,
 246         &dev_attr_status.attr,
 247         &dev_attr_freerunning_timer.attr,
 248         &dev_attr_queue_working_time.attr,
 249         &dev_attr_reload_bitstream.attr,
 250         NULL,
 251 };
 252 
 253 static struct attribute *genwqe_normal_attributes[] = {
 254         &dev_attr_type.attr,
 255         &dev_attr_version.attr,
 256         &dev_attr_appid.attr,
 257         &dev_attr_status.attr,
 258         &dev_attr_freerunning_timer.attr,
 259         &dev_attr_queue_working_time.attr,
 260         NULL,
 261 };
 262 
 263 /**
 264  * genwqe_is_visible() - Determine if sysfs attribute should be visible or not
 265  *
 266  * VFs have restricted mmio capabilities, so not all sysfs entries
 267  * are allowed in VFs.
 268  */
 269 static umode_t genwqe_is_visible(struct kobject *kobj,
 270                                  struct attribute *attr, int n)
 271 {
 272         unsigned int j;
 273         struct device *dev = kobj_to_dev(kobj);
 274         struct genwqe_dev *cd = dev_get_drvdata(dev);
 275         umode_t mode = attr->mode;
 276 
 277         if (genwqe_is_privileged(cd))
 278                 return mode;
 279 
 280         for (j = 0; genwqe_normal_attributes[j] != NULL;  j++)
 281                 if (genwqe_normal_attributes[j] == attr)
 282                         return mode;
 283 
 284         return 0;
 285 }
 286 
 287 static struct attribute_group genwqe_attribute_group = {
 288         .is_visible = genwqe_is_visible,
 289         .attrs      = genwqe_attributes,
 290 };
 291 
 292 const struct attribute_group *genwqe_attribute_groups[] = {
 293         &genwqe_attribute_group,
 294         NULL,
 295 };