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/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 tempsens_show(struct device *dev, struct device_attribute *attr, 95 char *buf) 96 { 97 u64 tempsens; 98 struct genwqe_dev *cd = dev_get_drvdata(dev); 99 100 tempsens = __genwqe_readq(cd, IO_SLU_TEMPERATURE_SENSOR); 101 return sprintf(buf, "%016llx\n", tempsens); 102 } 103 static DEVICE_ATTR_RO(tempsens); 104 105 static ssize_t freerunning_timer_show(struct device *dev, 106 struct device_attribute *attr, 107 char *buf) 108 { 109 u64 t; 110 struct genwqe_dev *cd = dev_get_drvdata(dev); 111 112 t = __genwqe_readq(cd, IO_SLC_FREE_RUNNING_TIMER); 113 return sprintf(buf, "%016llx\n", t); 114 } 115 static DEVICE_ATTR_RO(freerunning_timer); 116 117 static ssize_t queue_working_time_show(struct device *dev, 118 struct device_attribute *attr, 119 char *buf) 120 { 121 u64 t; 122 struct genwqe_dev *cd = dev_get_drvdata(dev); 123 124 t = __genwqe_readq(cd, IO_SLC_QUEUE_WTIME); 125 return sprintf(buf, "%016llx\n", t); 126 } 127 static DEVICE_ATTR_RO(queue_working_time); 128 129 static ssize_t base_clock_show(struct device *dev, 130 struct device_attribute *attr, 131 char *buf) 132 { 133 u64 base_clock; 134 struct genwqe_dev *cd = dev_get_drvdata(dev); 135 136 base_clock = genwqe_base_clock_frequency(cd); 137 return sprintf(buf, "%lld\n", base_clock); 138 } 139 static DEVICE_ATTR_RO(base_clock); 140 141 /** 142 * curr_bitstream_show() - Show the current bitstream id 143 * 144 * There is a bug in some old versions of the CPLD which selects the 145 * bitstream, which causes the IO_SLU_BITSTREAM register to report 146 * unreliable data in very rare cases. This makes this sysfs 147 * unreliable up to the point were a new CPLD version is being used. 148 * 149 * Unfortunately there is no automatic way yet to query the CPLD 150 * version, such that you need to manually ensure via programming 151 * tools that you have a recent version of the CPLD software. 152 * 153 * The proposed circumvention is to use a special recovery bitstream 154 * on the backup partition (0) to identify problems while loading the 155 * image. 156 */ 157 static ssize_t curr_bitstream_show(struct device *dev, 158 struct device_attribute *attr, char *buf) 159 { 160 int curr_bitstream; 161 struct genwqe_dev *cd = dev_get_drvdata(dev); 162 163 curr_bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM) & 0x1; 164 return sprintf(buf, "%d\n", curr_bitstream); 165 } 166 static DEVICE_ATTR_RO(curr_bitstream); 167 168 /** 169 * next_bitstream_show() - Show the next activated bitstream 170 * 171 * IO_SLC_CFGREG_SOFTRESET: This register can only be accessed by the PF. 172 */ 173 static ssize_t next_bitstream_show(struct device *dev, 174 struct device_attribute *attr, char *buf) 175 { 176 int next_bitstream; 177 struct genwqe_dev *cd = dev_get_drvdata(dev); 178 179 switch ((cd->softreset & 0xc) >> 2) { 180 case 0x2: 181 next_bitstream = 0; 182 break; 183 case 0x3: 184 next_bitstream = 1; 185 break; 186 default: 187 next_bitstream = -1; 188 break; /* error */ 189 } 190 return sprintf(buf, "%d\n", next_bitstream); 191 } 192 193 static ssize_t next_bitstream_store(struct device *dev, 194 struct device_attribute *attr, 195 const char *buf, size_t count) 196 { 197 int partition; 198 struct genwqe_dev *cd = dev_get_drvdata(dev); 199 200 if (kstrtoint(buf, 0, &partition) < 0) 201 return -EINVAL; 202 203 switch (partition) { 204 case 0x0: 205 cd->softreset = 0x78; 206 break; 207 case 0x1: 208 cd->softreset = 0x7c; 209 break; 210 default: 211 return -EINVAL; 212 } 213 214 __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, cd->softreset); 215 return count; 216 } 217 static DEVICE_ATTR_RW(next_bitstream); 218 219 static ssize_t reload_bitstream_store(struct device *dev, 220 struct device_attribute *attr, 221 const char *buf, size_t count) 222 { 223 int reload; 224 struct genwqe_dev *cd = dev_get_drvdata(dev); 225 226 if (kstrtoint(buf, 0, &reload) < 0) 227 return -EINVAL; 228 229 if (reload == 0x1) { 230 if (cd->card_state == GENWQE_CARD_UNUSED || 231 cd->card_state == GENWQE_CARD_USED) 232 cd->card_state = GENWQE_CARD_RELOAD_BITSTREAM; 233 else 234 return -EIO; 235 } else { 236 return -EINVAL; 237 } 238 239 return count; 240 } 241 static DEVICE_ATTR_WO(reload_bitstream); 242 243 /* 244 * Create device_attribute structures / params: name, mode, show, store 245 * additional flag if valid in VF 246 */ 247 static struct attribute *genwqe_attributes[] = { 248 &dev_attr_tempsens.attr, 249 &dev_attr_next_bitstream.attr, 250 &dev_attr_curr_bitstream.attr, 251 &dev_attr_base_clock.attr, 252 &dev_attr_type.attr, 253 &dev_attr_version.attr, 254 &dev_attr_appid.attr, 255 &dev_attr_status.attr, 256 &dev_attr_freerunning_timer.attr, 257 &dev_attr_queue_working_time.attr, 258 &dev_attr_reload_bitstream.attr, 259 NULL, 260 }; 261 262 static struct attribute *genwqe_normal_attributes[] = { 263 &dev_attr_type.attr, 264 &dev_attr_version.attr, 265 &dev_attr_appid.attr, 266 &dev_attr_status.attr, 267 &dev_attr_freerunning_timer.attr, 268 &dev_attr_queue_working_time.attr, 269 NULL, 270 }; 271 272 /** 273 * genwqe_is_visible() - Determine if sysfs attribute should be visible or not 274 * 275 * VFs have restricted mmio capabilities, so not all sysfs entries 276 * are allowed in VFs. 277 */ 278 static umode_t genwqe_is_visible(struct kobject *kobj, 279 struct attribute *attr, int n) 280 { 281 unsigned int j; 282 struct device *dev = container_of(kobj, struct device, kobj); 283 struct genwqe_dev *cd = dev_get_drvdata(dev); 284 umode_t mode = attr->mode; 285 286 if (genwqe_is_privileged(cd)) 287 return mode; 288 289 for (j = 0; genwqe_normal_attributes[j] != NULL; j++) 290 if (genwqe_normal_attributes[j] == attr) 291 return mode; 292 293 return 0; 294 } 295 296 static struct attribute_group genwqe_attribute_group = { 297 .is_visible = genwqe_is_visible, 298 .attrs = genwqe_attributes, 299 }; 300 301 const struct attribute_group *genwqe_attribute_groups[] = { 302 &genwqe_attribute_group, 303 NULL, 304 }; 305