xref: /openbmc/linux/drivers/misc/genwqe/card_sysfs.c (revision f7018c21)
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 /*
227  * Create device_attribute structures / params: name, mode, show, store
228  * additional flag if valid in VF
229  */
230 static struct attribute *genwqe_attributes[] = {
231 	&dev_attr_tempsens.attr,
232 	&dev_attr_next_bitstream.attr,
233 	&dev_attr_curr_bitstream.attr,
234 	&dev_attr_base_clock.attr,
235 	&dev_attr_driver.attr,
236 	&dev_attr_type.attr,
237 	&dev_attr_version.attr,
238 	&dev_attr_appid.attr,
239 	&dev_attr_status.attr,
240 	&dev_attr_freerunning_timer.attr,
241 	&dev_attr_queue_working_time.attr,
242 	NULL,
243 };
244 
245 static struct attribute *genwqe_normal_attributes[] = {
246 	&dev_attr_driver.attr,
247 	&dev_attr_type.attr,
248 	&dev_attr_version.attr,
249 	&dev_attr_appid.attr,
250 	&dev_attr_status.attr,
251 	&dev_attr_freerunning_timer.attr,
252 	&dev_attr_queue_working_time.attr,
253 	NULL,
254 };
255 
256 /**
257  * genwqe_is_visible() - Determine if sysfs attribute should be visible or not
258  *
259  * VFs have restricted mmio capabilities, so not all sysfs entries
260  * are allowed in VFs.
261  */
262 static umode_t genwqe_is_visible(struct kobject *kobj,
263 				 struct attribute *attr, int n)
264 {
265 	unsigned int j;
266 	struct device *dev = container_of(kobj, struct device, kobj);
267 	struct genwqe_dev *cd = dev_get_drvdata(dev);
268 	umode_t mode = attr->mode;
269 
270 	if (genwqe_is_privileged(cd))
271 		return mode;
272 
273 	for (j = 0; genwqe_normal_attributes[j] != NULL;  j++)
274 		if (genwqe_normal_attributes[j] == attr)
275 			return mode;
276 
277 	return 0;
278 }
279 
280 static struct attribute_group genwqe_attribute_group = {
281 	.is_visible = genwqe_is_visible,
282 	.attrs      = genwqe_attributes,
283 };
284 
285 const struct attribute_group *genwqe_attribute_groups[] = {
286 	&genwqe_attribute_group,
287 	NULL,
288 };
289