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 }; 304