xref: /openbmc/linux/drivers/s390/net/ctcm_sysfs.c (revision b6dcefde)
1 /*
2  * drivers/s390/net/ctcm_sysfs.c
3  *
4  * Copyright IBM Corp. 2007, 2007
5  * Authors:	Peter Tiedemann (ptiedem@de.ibm.com)
6  *
7  */
8 
9 #undef DEBUG
10 #undef DEBUGDATA
11 #undef DEBUGCCW
12 
13 #define KMSG_COMPONENT "ctcm"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15 
16 #include <linux/sysfs.h>
17 #include "ctcm_main.h"
18 
19 /*
20  * sysfs attributes
21  */
22 
23 static ssize_t ctcm_buffer_show(struct device *dev,
24 				struct device_attribute *attr, char *buf)
25 {
26 	struct ctcm_priv *priv = dev_get_drvdata(dev);
27 
28 	if (!priv)
29 		return -ENODEV;
30 	return sprintf(buf, "%d\n", priv->buffer_size);
31 }
32 
33 static ssize_t ctcm_buffer_write(struct device *dev,
34 		struct device_attribute *attr, const char *buf, size_t count)
35 {
36 	struct net_device *ndev;
37 	int bs1;
38 	struct ctcm_priv *priv = dev_get_drvdata(dev);
39 
40 	if (!(priv && priv->channel[READ] &&
41 			(ndev = priv->channel[READ]->netdev))) {
42 		CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
43 		return -ENODEV;
44 	}
45 
46 	sscanf(buf, "%u", &bs1);
47 	if (bs1 > CTCM_BUFSIZE_LIMIT)
48 					goto einval;
49 	if (bs1 < (576 + LL_HEADER_LENGTH + 2))
50 					goto einval;
51 	priv->buffer_size = bs1;	/* just to overwrite the default */
52 
53 	if ((ndev->flags & IFF_RUNNING) &&
54 	    (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
55 					goto einval;
56 
57 	priv->channel[READ]->max_bufsize = bs1;
58 	priv->channel[WRITE]->max_bufsize = bs1;
59 	if (!(ndev->flags & IFF_RUNNING))
60 		ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
61 	priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
62 	priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
63 
64 	CTCM_DBF_DEV(SETUP, ndev, buf);
65 	return count;
66 
67 einval:
68 	CTCM_DBF_DEV(SETUP, ndev, "buff_err");
69 	return -EINVAL;
70 }
71 
72 static void ctcm_print_statistics(struct ctcm_priv *priv)
73 {
74 	char *sbuf;
75 	char *p;
76 
77 	if (!priv)
78 		return;
79 	sbuf = kmalloc(2048, GFP_KERNEL);
80 	if (sbuf == NULL)
81 		return;
82 	p = sbuf;
83 
84 	p += sprintf(p, "  Device FSM state: %s\n",
85 		     fsm_getstate_str(priv->fsm));
86 	p += sprintf(p, "  RX channel FSM state: %s\n",
87 		     fsm_getstate_str(priv->channel[READ]->fsm));
88 	p += sprintf(p, "  TX channel FSM state: %s\n",
89 		     fsm_getstate_str(priv->channel[WRITE]->fsm));
90 	p += sprintf(p, "  Max. TX buffer used: %ld\n",
91 		     priv->channel[WRITE]->prof.maxmulti);
92 	p += sprintf(p, "  Max. chained SKBs: %ld\n",
93 		     priv->channel[WRITE]->prof.maxcqueue);
94 	p += sprintf(p, "  TX single write ops: %ld\n",
95 		     priv->channel[WRITE]->prof.doios_single);
96 	p += sprintf(p, "  TX multi write ops: %ld\n",
97 		     priv->channel[WRITE]->prof.doios_multi);
98 	p += sprintf(p, "  Netto bytes written: %ld\n",
99 		     priv->channel[WRITE]->prof.txlen);
100 	p += sprintf(p, "  Max. TX IO-time: %ld\n",
101 		     priv->channel[WRITE]->prof.tx_time);
102 
103 	printk(KERN_INFO "Statistics for %s:\n%s",
104 				priv->channel[WRITE]->netdev->name, sbuf);
105 	kfree(sbuf);
106 	return;
107 }
108 
109 static ssize_t stats_show(struct device *dev,
110 				struct device_attribute *attr, char *buf)
111 {
112 	struct ctcm_priv *priv = dev_get_drvdata(dev);
113 	if (!priv)
114 		return -ENODEV;
115 	ctcm_print_statistics(priv);
116 	return sprintf(buf, "0\n");
117 }
118 
119 static ssize_t stats_write(struct device *dev, struct device_attribute *attr,
120 				const char *buf, size_t count)
121 {
122 	struct ctcm_priv *priv = dev_get_drvdata(dev);
123 	if (!priv)
124 		return -ENODEV;
125 	/* Reset statistics */
126 	memset(&priv->channel[WRITE]->prof, 0,
127 				sizeof(priv->channel[WRITE]->prof));
128 	return count;
129 }
130 
131 static ssize_t ctcm_proto_show(struct device *dev,
132 				struct device_attribute *attr, char *buf)
133 {
134 	struct ctcm_priv *priv = dev_get_drvdata(dev);
135 	if (!priv)
136 		return -ENODEV;
137 
138 	return sprintf(buf, "%d\n", priv->protocol);
139 }
140 
141 static ssize_t ctcm_proto_store(struct device *dev,
142 		struct device_attribute *attr, const char *buf, size_t count)
143 {
144 	int value;
145 	struct ctcm_priv *priv = dev_get_drvdata(dev);
146 
147 	if (!priv)
148 		return -ENODEV;
149 	sscanf(buf, "%u", &value);
150 	if (!((value == CTCM_PROTO_S390)  ||
151 	      (value == CTCM_PROTO_LINUX) ||
152 	      (value == CTCM_PROTO_MPC) ||
153 	      (value == CTCM_PROTO_OS390)))
154 		return -EINVAL;
155 	priv->protocol = value;
156 	CTCM_DBF_DEV(SETUP, dev, buf);
157 
158 	return count;
159 }
160 
161 const char *ctcm_type[] = {
162 	"not a channel",
163 	"CTC/A",
164 	"FICON channel",
165 	"ESCON channel",
166 	"unknown channel type",
167 	"unsupported channel type",
168 };
169 
170 static ssize_t ctcm_type_show(struct device *dev,
171 				struct device_attribute *attr, char *buf)
172 {
173 	struct ccwgroup_device *cgdev;
174 
175 	cgdev = to_ccwgroupdev(dev);
176 	if (!cgdev)
177 		return -ENODEV;
178 
179 	return sprintf(buf, "%s\n",
180 			ctcm_type[cgdev->cdev[0]->id.driver_info]);
181 }
182 
183 static DEVICE_ATTR(buffer, 0644, ctcm_buffer_show, ctcm_buffer_write);
184 static DEVICE_ATTR(protocol, 0644, ctcm_proto_show, ctcm_proto_store);
185 static DEVICE_ATTR(type, 0444, ctcm_type_show, NULL);
186 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
187 
188 static struct attribute *ctcm_attr[] = {
189 	&dev_attr_protocol.attr,
190 	&dev_attr_type.attr,
191 	&dev_attr_buffer.attr,
192 	NULL,
193 };
194 
195 static struct attribute_group ctcm_attr_group = {
196 	.attrs = ctcm_attr,
197 };
198 
199 int ctcm_add_attributes(struct device *dev)
200 {
201 	int rc;
202 
203 	rc = device_create_file(dev, &dev_attr_stats);
204 
205 	return rc;
206 }
207 
208 void ctcm_remove_attributes(struct device *dev)
209 {
210 	device_remove_file(dev, &dev_attr_stats);
211 }
212 
213 int ctcm_add_files(struct device *dev)
214 {
215 	return sysfs_create_group(&dev->kobj, &ctcm_attr_group);
216 }
217 
218 void ctcm_remove_files(struct device *dev)
219 {
220 	sysfs_remove_group(&dev->kobj, &ctcm_attr_group);
221 }
222 
223