drivers/misc/genwqe/card_sysfs.c

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