blob: 406be169173ce914db9dd593f6d70e5b52427961 [file] [log] [blame]
Greg Kroah-Hartmanab9953f2017-11-14 18:38:04 +01001// SPDX-License-Identifier: GPL-2.0
Frank Blaschka4a71df52008-02-15 09:19:42 +01002/*
Frank Blaschka4a71df52008-02-15 09:19:42 +01003 * Copyright IBM Corp. 2007
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
8 */
9
Ursula Braunfe7a2622010-03-08 20:36:53 +000010#define KMSG_COMPONENT "qeth"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
Frank Blaschka4a71df52008-02-15 09:19:42 +010013#include <linux/list.h>
14#include <linux/rwsem.h>
15#include <asm/ebcdic.h>
16
17#include "qeth_core.h"
18
19static ssize_t qeth_dev_state_show(struct device *dev,
20 struct device_attribute *attr, char *buf)
21{
22 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +010023
24 switch (card->state) {
25 case CARD_STATE_DOWN:
26 return sprintf(buf, "DOWN\n");
Frank Blaschka4a71df52008-02-15 09:19:42 +010027 case CARD_STATE_SOFTSETUP:
Julian Wiedmann0f7aedbd2019-02-28 18:59:44 +010028 if (card->dev->flags & IFF_UP)
29 return sprintf(buf, "UP (LAN %s)\n",
30 netif_carrier_ok(card->dev) ? "ONLINE" :
31 "OFFLINE");
Frank Blaschka4a71df52008-02-15 09:19:42 +010032 return sprintf(buf, "SOFTSETUP\n");
Frank Blaschka4a71df52008-02-15 09:19:42 +010033 default:
34 return sprintf(buf, "UNKNOWN\n");
35 }
36}
37
38static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
39
40static ssize_t qeth_dev_chpid_show(struct device *dev,
41 struct device_attribute *attr, char *buf)
42{
43 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +010044
45 return sprintf(buf, "%02X\n", card->info.chpid);
46}
47
48static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
49
50static ssize_t qeth_dev_if_name_show(struct device *dev,
51 struct device_attribute *attr, char *buf)
52{
53 struct qeth_card *card = dev_get_drvdata(dev);
Julian Wiedmann0b81c6c2019-11-14 11:19:24 +010054
Julian Wiedmann84c91482020-10-01 19:11:34 +020055 return sprintf(buf, "%s\n", netdev_name(card->dev));
Frank Blaschka4a71df52008-02-15 09:19:42 +010056}
57
58static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
59
60static ssize_t qeth_dev_card_type_show(struct device *dev,
61 struct device_attribute *attr, char *buf)
62{
63 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +010064
65 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
66}
67
68static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
69
Julian Wiedmanncef6ff222017-08-15 17:02:46 +020070static const char *qeth_get_bufsize_str(struct qeth_card *card)
Frank Blaschka4a71df52008-02-15 09:19:42 +010071{
72 if (card->qdio.in_buf_size == 16384)
73 return "16k";
74 else if (card->qdio.in_buf_size == 24576)
75 return "24k";
76 else if (card->qdio.in_buf_size == 32768)
77 return "32k";
78 else if (card->qdio.in_buf_size == 40960)
79 return "40k";
80 else
81 return "64k";
82}
83
84static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
85 struct device_attribute *attr, char *buf)
86{
87 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +010088
89 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
90}
91
92static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
93
94static ssize_t qeth_dev_portno_show(struct device *dev,
95 struct device_attribute *attr, char *buf)
96{
97 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +010098
Julian Wiedmann92d27202018-07-19 12:43:52 +020099 return sprintf(buf, "%i\n", card->dev->dev_port);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100100}
101
102static ssize_t qeth_dev_portno_store(struct device *dev,
103 struct device_attribute *attr, const char *buf, size_t count)
104{
105 struct qeth_card *card = dev_get_drvdata(dev);
Ursula Braun76b11f82010-01-11 02:50:50 +0000106 unsigned int portno, limit;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000107 int rc = 0;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100108
Julian Wiedmannab29c482020-09-23 10:36:55 +0200109 rc = kstrtouint(buf, 16, &portno);
110 if (rc)
111 return rc;
112 if (portno > QETH_MAX_PORTNO)
113 return -EINVAL;
114
Frank Blaschkac4949f02010-05-11 19:34:47 +0000115 mutex_lock(&card->conf_mutex);
Julian Wiedmannd7d543f2019-02-28 18:59:36 +0100116 if (card->state != CARD_STATE_DOWN) {
Frank Blaschkac4949f02010-05-11 19:34:47 +0000117 rc = -EPERM;
118 goto out;
119 }
Frank Blaschka4a71df52008-02-15 09:19:42 +0100120
Ursula Braun76b11f82010-01-11 02:50:50 +0000121 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
Frank Blaschkac4949f02010-05-11 19:34:47 +0000122 if (portno > limit) {
123 rc = -EINVAL;
124 goto out;
125 }
Julian Wiedmannd3d1b202018-07-19 12:43:51 +0200126 card->dev->dev_port = portno;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000127out:
128 mutex_unlock(&card->conf_mutex);
129 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100130}
131
132static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
133
134static ssize_t qeth_dev_portname_show(struct device *dev,
135 struct device_attribute *attr, char *buf)
136{
Ursula Braun239ff402015-09-18 16:06:50 +0200137 return sprintf(buf, "no portname required\n");
Frank Blaschka4a71df52008-02-15 09:19:42 +0100138}
139
140static ssize_t qeth_dev_portname_store(struct device *dev,
141 struct device_attribute *attr, const char *buf, size_t count)
142{
143 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100144
Ursula Braun239ff402015-09-18 16:06:50 +0200145 dev_warn_once(&card->gdev->dev,
146 "portname is deprecated and is ignored\n");
147 return count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100148}
149
150static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
151 qeth_dev_portname_store);
152
153static ssize_t qeth_dev_prioqing_show(struct device *dev,
154 struct device_attribute *attr, char *buf)
155{
156 struct qeth_card *card = dev_get_drvdata(dev);
157
Frank Blaschka4a71df52008-02-15 09:19:42 +0100158 switch (card->qdio.do_prio_queueing) {
159 case QETH_PRIO_Q_ING_PREC:
160 return sprintf(buf, "%s\n", "by precedence");
161 case QETH_PRIO_Q_ING_TOS:
162 return sprintf(buf, "%s\n", "by type of service");
Stefan Raspld66cb372014-04-28 10:05:09 +0200163 case QETH_PRIO_Q_ING_SKB:
164 return sprintf(buf, "%s\n", "by skb-priority");
165 case QETH_PRIO_Q_ING_VLAN:
166 return sprintf(buf, "%s\n", "by VLAN headers");
Julian Wiedmann949bbf42020-10-01 19:11:32 +0200167 case QETH_PRIO_Q_ING_FIXED:
Frank Blaschka4a71df52008-02-15 09:19:42 +0100168 return sprintf(buf, "always queue %i\n",
169 card->qdio.default_out_queue);
Julian Wiedmann949bbf42020-10-01 19:11:32 +0200170 default:
171 return sprintf(buf, "disabled\n");
Frank Blaschka4a71df52008-02-15 09:19:42 +0100172 }
173}
174
175static ssize_t qeth_dev_prioqing_store(struct device *dev,
176 struct device_attribute *attr, const char *buf, size_t count)
177{
178 struct qeth_card *card = dev_get_drvdata(dev);
Frank Blaschkac4949f02010-05-11 19:34:47 +0000179 int rc = 0;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100180
Julian Wiedmann1c103cf2020-03-18 13:54:47 +0100181 if (IS_IQD(card) || IS_VM_NIC(card))
Julian Wiedmann3a18d752019-04-17 18:17:32 +0200182 return -EOPNOTSUPP;
183
Frank Blaschkac4949f02010-05-11 19:34:47 +0000184 mutex_lock(&card->conf_mutex);
Julian Wiedmannd7d543f2019-02-28 18:59:36 +0100185 if (card->state != CARD_STATE_DOWN) {
Frank Blaschkac4949f02010-05-11 19:34:47 +0000186 rc = -EPERM;
187 goto out;
188 }
Frank Blaschka4a71df52008-02-15 09:19:42 +0100189
190 /* check if 1920 devices are supported ,
191 * if though we have to permit priority queueing
192 */
193 if (card->qdio.no_out_queues == 1) {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100194 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000195 rc = -EPERM;
196 goto out;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100197 }
198
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100199 if (sysfs_streq(buf, "prio_queueing_prec")) {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100200 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
Stefan Raspl0f8ee7f2014-04-28 10:05:05 +0200201 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100202 } else if (sysfs_streq(buf, "prio_queueing_skb")) {
Stefan Raspld66cb372014-04-28 10:05:09 +0200203 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
204 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100205 } else if (sysfs_streq(buf, "prio_queueing_tos")) {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100206 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
Stefan Raspl0f8ee7f2014-04-28 10:05:05 +0200207 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100208 } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
Julian Wiedmann4fda3352018-09-26 18:29:02 +0200209 if (IS_LAYER3(card)) {
Julian Wiedmann39bdbf32019-12-18 16:32:28 +0100210 rc = -EOPNOTSUPP;
Stefan Raspld66cb372014-04-28 10:05:09 +0200211 goto out;
212 }
213 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
214 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100215 } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
Julian Wiedmannc91a1fb2020-03-25 10:35:06 +0100216 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100217 card->qdio.default_out_queue = 0;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100218 } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
Julian Wiedmannc91a1fb2020-03-25 10:35:06 +0100219 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100220 card->qdio.default_out_queue = 1;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100221 } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
Julian Wiedmannc91a1fb2020-03-25 10:35:06 +0100222 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100223 card->qdio.default_out_queue = 2;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100224 } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
Julian Wiedmannc91a1fb2020-03-25 10:35:06 +0100225 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100226 card->qdio.default_out_queue = 3;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100227 } else if (sysfs_streq(buf, "no_prio_queueing")) {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100228 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
229 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000230 } else
231 rc = -EINVAL;
232out:
233 mutex_unlock(&card->conf_mutex);
234 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100235}
236
237static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
238 qeth_dev_prioqing_store);
239
240static ssize_t qeth_dev_bufcnt_show(struct device *dev,
241 struct device_attribute *attr, char *buf)
242{
243 struct qeth_card *card = dev_get_drvdata(dev);
244
Frank Blaschka4a71df52008-02-15 09:19:42 +0100245 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
246}
247
248static ssize_t qeth_dev_bufcnt_store(struct device *dev,
249 struct device_attribute *attr, const char *buf, size_t count)
250{
251 struct qeth_card *card = dev_get_drvdata(dev);
Julian Wiedmann5d4f7852020-03-11 18:07:11 +0100252 unsigned int cnt;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000253 int rc = 0;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100254
Julian Wiedmannab29c482020-09-23 10:36:55 +0200255 rc = kstrtouint(buf, 10, &cnt);
256 if (rc)
257 return rc;
258
Frank Blaschkac4949f02010-05-11 19:34:47 +0000259 mutex_lock(&card->conf_mutex);
Julian Wiedmannd7d543f2019-02-28 18:59:36 +0100260 if (card->state != CARD_STATE_DOWN) {
Frank Blaschkac4949f02010-05-11 19:34:47 +0000261 rc = -EPERM;
262 goto out;
263 }
Frank Blaschka4a71df52008-02-15 09:19:42 +0100264
Julian Wiedmannab29c482020-09-23 10:36:55 +0200265 cnt = clamp(cnt, QETH_IN_BUF_COUNT_MIN, QETH_IN_BUF_COUNT_MAX);
Julian Wiedmann5d4f7852020-03-11 18:07:11 +0100266 rc = qeth_resize_buffer_pool(card, cnt);
267
Frank Blaschkac4949f02010-05-11 19:34:47 +0000268out:
269 mutex_unlock(&card->conf_mutex);
270 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100271}
272
273static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
274 qeth_dev_bufcnt_store);
275
276static ssize_t qeth_dev_recover_store(struct device *dev,
277 struct device_attribute *attr, const char *buf, size_t count)
278{
279 struct qeth_card *card = dev_get_drvdata(dev);
Julian Wiedmann7005b752020-05-06 10:09:48 +0200280 bool reset;
281 int rc;
282
283 rc = kstrtobool(buf, &reset);
284 if (rc)
285 return rc;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100286
Julian Wiedmann0aa35a32019-02-15 19:22:25 +0100287 if (!qeth_card_hw_is_reachable(card))
Frank Blaschka4a71df52008-02-15 09:19:42 +0100288 return -EPERM;
289
Julian Wiedmann7005b752020-05-06 10:09:48 +0200290 if (reset)
291 rc = qeth_schedule_recovery(card);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100292
Julian Wiedmann7005b752020-05-06 10:09:48 +0200293 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100294}
295
296static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
297
298static ssize_t qeth_dev_performance_stats_show(struct device *dev,
299 struct device_attribute *attr, char *buf)
300{
Julian Wiedmannb0abc4f2019-02-15 19:22:29 +0100301 return sprintf(buf, "1\n");
Frank Blaschka4a71df52008-02-15 09:19:42 +0100302}
303
304static ssize_t qeth_dev_performance_stats_store(struct device *dev,
305 struct device_attribute *attr, const char *buf, size_t count)
306{
307 struct qeth_card *card = dev_get_drvdata(dev);
Julian Wiedmannb0abc4f2019-02-15 19:22:29 +0100308 struct qeth_qdio_out_q *queue;
309 unsigned int i;
310 bool reset;
311 int rc;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100312
Julian Wiedmannb0abc4f2019-02-15 19:22:29 +0100313 rc = kstrtobool(buf, &reset);
314 if (rc)
315 return rc;
316
317 if (reset) {
318 memset(&card->stats, 0, sizeof(card->stats));
319 for (i = 0; i < card->qdio.no_out_queues; i++) {
320 queue = card->qdio.out_qs[i];
321 if (!queue)
322 break;
323 memset(&queue->stats, 0, sizeof(queue->stats));
324 }
325 }
326
327 return count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100328}
329
330static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
331 qeth_dev_performance_stats_store);
332
333static ssize_t qeth_dev_layer2_show(struct device *dev,
334 struct device_attribute *attr, char *buf)
335{
336 struct qeth_card *card = dev_get_drvdata(dev);
337
Julian Wiedmann4fda3352018-09-26 18:29:02 +0200338 return sprintf(buf, "%i\n", card->options.layer);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100339}
340
341static ssize_t qeth_dev_layer2_store(struct device *dev,
342 struct device_attribute *attr, const char *buf, size_t count)
343{
344 struct qeth_card *card = dev_get_drvdata(dev);
Julian Wiedmannd3d1b202018-07-19 12:43:51 +0200345 struct net_device *ndev;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100346 enum qeth_discipline_id newdis;
Julian Wiedmannab29c482020-09-23 10:36:55 +0200347 unsigned int input;
348 int rc;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100349
Julian Wiedmannab29c482020-09-23 10:36:55 +0200350 rc = kstrtouint(buf, 16, &input);
351 if (rc)
352 return rc;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100353
Julian Wiedmannab29c482020-09-23 10:36:55 +0200354 switch (input) {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100355 case 0:
356 newdis = QETH_DISCIPLINE_LAYER3;
357 break;
358 case 1:
359 newdis = QETH_DISCIPLINE_LAYER2;
360 break;
361 default:
Julian Wiedmannab29c482020-09-23 10:36:55 +0200362 return -EINVAL;
363 }
364
365 mutex_lock(&card->discipline_mutex);
366 if (card->state != CARD_STATE_DOWN) {
367 rc = -EPERM;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000368 goto out;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100369 }
370
Julian Wiedmann4fda3352018-09-26 18:29:02 +0200371 if (card->options.layer == newdis)
Frank Blaschkac4949f02010-05-11 19:34:47 +0000372 goto out;
Julian Wiedmannc70eb092017-06-06 14:33:50 +0200373 if (card->info.layer_enforced) {
Julian Wiedmann2d2ebb32017-05-10 19:07:52 +0200374 /* fixed layer, can't switch */
375 rc = -EOPNOTSUPP;
376 goto out;
377 }
378
Julian Wiedmann2d2ebb32017-05-10 19:07:52 +0200379 if (card->discipline) {
Julian Wiedmannd3d1b202018-07-19 12:43:51 +0200380 /* start with a new, pristine netdevice: */
381 ndev = qeth_clone_netdev(card->dev);
382 if (!ndev) {
383 rc = -ENOMEM;
384 goto out;
385 }
386
Julian Wiedmannea12f1b32021-01-28 12:25:47 +0100387 qeth_remove_discipline(card);
Julian Wiedmannd3d1b202018-07-19 12:43:51 +0200388 free_netdev(card->dev);
389 card->dev = ndev;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100390 }
391
Julian Wiedmannea12f1b32021-01-28 12:25:47 +0100392 rc = qeth_setup_discipline(card, newdis);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100393
Frank Blaschkac4949f02010-05-11 19:34:47 +0000394out:
Ursula Braun9dc48cc2010-07-22 23:15:05 +0000395 mutex_unlock(&card->discipline_mutex);
Frank Blaschkac4949f02010-05-11 19:34:47 +0000396 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100397}
398
399static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
400 qeth_dev_layer2_store);
401
Einar Lueckd64ecc22009-11-12 00:11:41 +0000402#define ATTR_QETH_ISOLATION_NONE ("none")
403#define ATTR_QETH_ISOLATION_FWD ("forward")
404#define ATTR_QETH_ISOLATION_DROP ("drop")
405
406static ssize_t qeth_dev_isolation_show(struct device *dev,
407 struct device_attribute *attr, char *buf)
408{
409 struct qeth_card *card = dev_get_drvdata(dev);
410
Einar Lueckd64ecc22009-11-12 00:11:41 +0000411 switch (card->options.isolation) {
412 case ISOLATION_MODE_NONE:
413 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
414 case ISOLATION_MODE_FWD:
415 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
416 case ISOLATION_MODE_DROP:
417 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
418 default:
419 return snprintf(buf, 5, "%s\n", "N/A");
420 }
421}
422
423static ssize_t qeth_dev_isolation_store(struct device *dev,
424 struct device_attribute *attr, const char *buf, size_t count)
425{
426 struct qeth_card *card = dev_get_drvdata(dev);
427 enum qeth_ipa_isolation_modes isolation;
428 int rc = 0;
Einar Lueckd64ecc22009-11-12 00:11:41 +0000429
Frank Blaschkac4949f02010-05-11 19:34:47 +0000430 mutex_lock(&card->conf_mutex);
Julian Wiedmann379ac992019-04-25 18:25:57 +0200431 if (!IS_OSD(card) && !IS_OSX(card)) {
Einar Lueckd64ecc22009-11-12 00:11:41 +0000432 rc = -EOPNOTSUPP;
433 dev_err(&card->gdev->dev, "Adapter does not "
434 "support QDIO data connection isolation\n");
435 goto out;
436 }
437
438 /* parse input into isolation mode */
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100439 if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
Einar Lueckd64ecc22009-11-12 00:11:41 +0000440 isolation = ISOLATION_MODE_NONE;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100441 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
Einar Lueckd64ecc22009-11-12 00:11:41 +0000442 isolation = ISOLATION_MODE_FWD;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100443 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
Einar Lueckd64ecc22009-11-12 00:11:41 +0000444 isolation = ISOLATION_MODE_DROP;
445 } else {
446 rc = -EINVAL;
447 goto out;
448 }
Einar Lueckd64ecc22009-11-12 00:11:41 +0000449
Julian Wiedmann65878fd2020-07-14 16:23:00 +0200450 if (qeth_card_hw_is_reachable(card))
451 rc = qeth_setadpparms_set_access_ctrl(card, isolation);
452
453 if (!rc)
454 WRITE_ONCE(card->options.isolation, isolation);
455
Einar Lueckd64ecc22009-11-12 00:11:41 +0000456out:
Frank Blaschkac4949f02010-05-11 19:34:47 +0000457 mutex_unlock(&card->conf_mutex);
Julian Wiedmann65878fd2020-07-14 16:23:00 +0200458
459 return rc ? rc : count;
Einar Lueckd64ecc22009-11-12 00:11:41 +0000460}
461
462static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
Stefan Raspl45cbb2e2014-07-21 12:54:43 +0200463 qeth_dev_isolation_store);
464
465static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
466 struct device_attribute *attr, char *buf)
467{
468 struct qeth_card *card = dev_get_drvdata(dev);
469 struct qeth_switch_info sw_info;
470 int rc = 0;
471
Eugene Crosserc3521252015-01-16 14:05:47 +0100472 if (!qeth_card_hw_is_reachable(card))
Stefan Raspl45cbb2e2014-07-21 12:54:43 +0200473 return sprintf(buf, "n/a\n");
474
475 rc = qeth_query_switch_attributes(card, &sw_info);
476 if (rc)
477 return rc;
478
479 if (!sw_info.capabilities)
480 rc = sprintf(buf, "unknown");
481
482 if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
483 rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
484 "[802.1]" : "802.1"));
485 if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
486 rc += sprintf(buf + rc,
487 (sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ?
488 " [rr]" : " rr"));
489 rc += sprintf(buf + rc, "\n");
490
491 return rc;
492}
493
494static DEVICE_ATTR(switch_attrs, 0444,
495 qeth_dev_switch_attrs_show, NULL);
Einar Lueckd64ecc22009-11-12 00:11:41 +0000496
Frank Blaschka1da74b12011-05-12 18:45:02 +0000497static ssize_t qeth_hw_trap_show(struct device *dev,
498 struct device_attribute *attr, char *buf)
499{
500 struct qeth_card *card = dev_get_drvdata(dev);
501
Frank Blaschka1da74b12011-05-12 18:45:02 +0000502 if (card->info.hwtrap)
503 return snprintf(buf, 5, "arm\n");
504 else
505 return snprintf(buf, 8, "disarm\n");
506}
507
508static ssize_t qeth_hw_trap_store(struct device *dev,
509 struct device_attribute *attr, const char *buf, size_t count)
510{
511 struct qeth_card *card = dev_get_drvdata(dev);
512 int rc = 0;
Frank Blaschka1da74b12011-05-12 18:45:02 +0000513 int state = 0;
Frank Blaschka1da74b12011-05-12 18:45:02 +0000514
Frank Blaschka1da74b12011-05-12 18:45:02 +0000515 mutex_lock(&card->conf_mutex);
Eugene Crosserc3521252015-01-16 14:05:47 +0100516 if (qeth_card_hw_is_reachable(card))
Frank Blaschka1da74b12011-05-12 18:45:02 +0000517 state = 1;
Frank Blaschka1da74b12011-05-12 18:45:02 +0000518
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100519 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
Frank Blaschka1da74b12011-05-12 18:45:02 +0000520 if (state) {
521 if (qeth_is_diagass_supported(card,
522 QETH_DIAGS_CMD_TRAP)) {
523 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
524 if (!rc)
525 card->info.hwtrap = 1;
526 } else
527 rc = -EINVAL;
528 } else
529 card->info.hwtrap = 1;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100530 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
Frank Blaschka1da74b12011-05-12 18:45:02 +0000531 if (state) {
532 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
533 if (!rc)
534 card->info.hwtrap = 0;
535 } else
536 card->info.hwtrap = 0;
Eugene Crosser7e846d6b2015-01-16 14:05:48 +0100537 } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
Frank Blaschka1da74b12011-05-12 18:45:02 +0000538 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
539 else
540 rc = -EINVAL;
541
542 mutex_unlock(&card->conf_mutex);
543 return rc ? rc : count;
544}
545
546static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
547 qeth_hw_trap_store);
548
Frank Blaschka4a71df52008-02-15 09:19:42 +0100549static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
550 const char *buf, size_t count, int *value, int max_value)
551{
Julian Wiedmannab29c482020-09-23 10:36:55 +0200552 unsigned int input;
553 int rc;
554
555 rc = kstrtouint(buf, 10, &input);
556 if (rc)
557 return rc;
558
559 if (input > max_value)
560 return -EINVAL;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100561
Frank Blaschkac4949f02010-05-11 19:34:47 +0000562 mutex_lock(&card->conf_mutex);
Julian Wiedmannab29c482020-09-23 10:36:55 +0200563 if (card->state != CARD_STATE_DOWN)
Frank Blaschkac4949f02010-05-11 19:34:47 +0000564 rc = -EPERM;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000565 else
Julian Wiedmannab29c482020-09-23 10:36:55 +0200566 *value = input;
Frank Blaschkac4949f02010-05-11 19:34:47 +0000567 mutex_unlock(&card->conf_mutex);
568 return rc ? rc : count;
Frank Blaschka4a71df52008-02-15 09:19:42 +0100569}
570
571static ssize_t qeth_dev_blkt_total_show(struct device *dev,
572 struct device_attribute *attr, char *buf)
573{
574 struct qeth_card *card = dev_get_drvdata(dev);
575
Julian Wiedmann0b81c6c2019-11-14 11:19:24 +0100576 return sprintf(buf, "%i\n", card->info.blkt.time_total);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100577}
578
579static ssize_t qeth_dev_blkt_total_store(struct device *dev,
580 struct device_attribute *attr, const char *buf, size_t count)
581{
582 struct qeth_card *card = dev_get_drvdata(dev);
583
584 return qeth_dev_blkt_store(card, buf, count,
Einar Luecka60389a2010-01-11 02:50:52 +0000585 &card->info.blkt.time_total, 5000);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100586}
587
Frank Blaschka4a71df52008-02-15 09:19:42 +0100588static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
589 qeth_dev_blkt_total_store);
590
591static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
592 struct device_attribute *attr, char *buf)
593{
594 struct qeth_card *card = dev_get_drvdata(dev);
595
Julian Wiedmann0b81c6c2019-11-14 11:19:24 +0100596 return sprintf(buf, "%i\n", card->info.blkt.inter_packet);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100597}
598
599static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
600 struct device_attribute *attr, const char *buf, size_t count)
601{
602 struct qeth_card *card = dev_get_drvdata(dev);
603
604 return qeth_dev_blkt_store(card, buf, count,
Einar Luecka60389a2010-01-11 02:50:52 +0000605 &card->info.blkt.inter_packet, 1000);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100606}
607
608static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
609 qeth_dev_blkt_inter_store);
610
611static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
612 struct device_attribute *attr, char *buf)
613{
614 struct qeth_card *card = dev_get_drvdata(dev);
615
Julian Wiedmann0b81c6c2019-11-14 11:19:24 +0100616 return sprintf(buf, "%i\n", card->info.blkt.inter_packet_jumbo);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100617}
618
619static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
620 struct device_attribute *attr, const char *buf, size_t count)
621{
622 struct qeth_card *card = dev_get_drvdata(dev);
623
624 return qeth_dev_blkt_store(card, buf, count,
Einar Luecka60389a2010-01-11 02:50:52 +0000625 &card->info.blkt.inter_packet_jumbo, 1000);
Frank Blaschka4a71df52008-02-15 09:19:42 +0100626}
627
628static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
629 qeth_dev_blkt_inter_jumbo_store);
630
631static struct attribute *qeth_blkt_device_attrs[] = {
632 &dev_attr_total.attr,
633 &dev_attr_inter.attr,
634 &dev_attr_inter_jumbo.attr,
635 NULL,
636};
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100637
638static const struct attribute_group qeth_dev_blkt_group = {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100639 .name = "blkt",
640 .attrs = qeth_blkt_device_attrs,
641};
642
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100643static struct attribute *qeth_dev_extended_attrs[] = {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100644 &dev_attr_inbuf_size.attr,
645 &dev_attr_portno.attr,
646 &dev_attr_portname.attr,
647 &dev_attr_priority_queueing.attr,
Frank Blaschka4a71df52008-02-15 09:19:42 +0100648 &dev_attr_performance_stats.attr,
649 &dev_attr_layer2.attr,
Einar Lueckd64ecc22009-11-12 00:11:41 +0000650 &dev_attr_isolation.attr,
Frank Blaschka1da74b12011-05-12 18:45:02 +0000651 &dev_attr_hw_trap.attr,
Stefan Raspl45cbb2e2014-07-21 12:54:43 +0200652 &dev_attr_switch_attrs.attr,
Frank Blaschka4a71df52008-02-15 09:19:42 +0100653 NULL,
654};
Frank Blaschka4a71df52008-02-15 09:19:42 +0100655
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100656static const struct attribute_group qeth_dev_extended_group = {
657 .attrs = qeth_dev_extended_attrs,
Sebastian Ottb7169c52012-05-15 18:01:46 +0200658};
659
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100660static struct attribute *qeth_dev_attrs[] = {
Frank Blaschka4a71df52008-02-15 09:19:42 +0100661 &dev_attr_state.attr,
662 &dev_attr_chpid.attr,
663 &dev_attr_if_name.attr,
664 &dev_attr_card_type.attr,
665 &dev_attr_buffer_count.attr,
666 &dev_attr_recover.attr,
667 NULL,
668};
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100669
670static const struct attribute_group qeth_dev_group = {
671 .attrs = qeth_dev_attrs,
Frank Blaschka4a71df52008-02-15 09:19:42 +0100672};
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100673
Julian Wiedmann0b8da812020-12-07 14:12:30 +0100674const struct attribute_group *qeth_dev_groups[] = {
675 &qeth_dev_group,
676 &qeth_dev_extended_group,
677 &qeth_dev_blkt_group,
Sebastian Ottb7169c52012-05-15 18:01:46 +0200678 NULL,
679};