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