Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * 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
10#define KMSG_COMPONENT "qeth"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13#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);
23
24 switch (card->state) {
25 case CARD_STATE_DOWN:
26 return sysfs_emit(buf, "DOWN\n");
27 case CARD_STATE_SOFTSETUP:
28 if (card->dev->flags & IFF_UP)
29 return sysfs_emit(buf, "UP (LAN %s)\n",
30 netif_carrier_ok(card->dev) ?
31 "ONLINE" : "OFFLINE");
32 return sysfs_emit(buf, "SOFTSETUP\n");
33 default:
34 return sysfs_emit(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);
44
45 return sysfs_emit(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);
54
55 return sysfs_emit(buf, "%s\n", netdev_name(card->dev));
56}
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);
64
65 return sysfs_emit(buf, "%s\n", qeth_get_cardname_short(card));
66}
67
68static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
69
70static const char *qeth_get_bufsize_str(struct qeth_card *card)
71{
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);
88
89 return sysfs_emit(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);
98
99 return sysfs_emit(buf, "%i\n", card->dev->dev_port);
100}
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);
106 unsigned int portno, limit;
107 int rc = 0;
108
109 rc = kstrtouint(buf, 16, &portno);
110 if (rc)
111 return rc;
112 if (portno > QETH_MAX_PORTNO)
113 return -EINVAL;
114
115 mutex_lock(&card->conf_mutex);
116 if (card->state != CARD_STATE_DOWN) {
117 rc = -EPERM;
118 goto out;
119 }
120
121 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
122 if (portno > limit) {
123 rc = -EINVAL;
124 goto out;
125 }
126 card->dev->dev_port = portno;
127out:
128 mutex_unlock(&card->conf_mutex);
129 return rc ? rc : count;
130}
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{
137 return sysfs_emit(buf, "no portname required\n");
138}
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);
144
145 dev_warn_once(&card->gdev->dev,
146 "portname is deprecated and is ignored\n");
147 return count;
148}
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
158 switch (card->qdio.do_prio_queueing) {
159 case QETH_PRIO_Q_ING_PREC:
160 return sysfs_emit(buf, "%s\n", "by precedence");
161 case QETH_PRIO_Q_ING_TOS:
162 return sysfs_emit(buf, "%s\n", "by type of service");
163 case QETH_PRIO_Q_ING_SKB:
164 return sysfs_emit(buf, "%s\n", "by skb-priority");
165 case QETH_PRIO_Q_ING_VLAN:
166 return sysfs_emit(buf, "%s\n", "by VLAN headers");
167 case QETH_PRIO_Q_ING_FIXED:
168 return sysfs_emit(buf, "always queue %i\n",
169 card->qdio.default_out_queue);
170 default:
171 return sysfs_emit(buf, "disabled\n");
172 }
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);
179 int rc = 0;
180
181 if (IS_IQD(card) || IS_VM_NIC(card))
182 return -EOPNOTSUPP;
183
184 mutex_lock(&card->conf_mutex);
185 if (card->state != CARD_STATE_DOWN) {
186 rc = -EPERM;
187 goto out;
188 }
189
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) {
194 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
195 rc = -EPERM;
196 goto out;
197 }
198
199 if (sysfs_streq(buf, "prio_queueing_prec")) {
200 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
201 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
202 } else if (sysfs_streq(buf, "prio_queueing_skb")) {
203 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
204 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
205 } else if (sysfs_streq(buf, "prio_queueing_tos")) {
206 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
207 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
208 } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
209 if (IS_LAYER3(card)) {
210 rc = -EOPNOTSUPP;
211 goto out;
212 }
213 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
214 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
215 } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
216 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
217 card->qdio.default_out_queue = 0;
218 } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
219 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
220 card->qdio.default_out_queue = 1;
221 } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
222 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
223 card->qdio.default_out_queue = 2;
224 } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
225 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
226 card->qdio.default_out_queue = 3;
227 } else if (sysfs_streq(buf, "no_prio_queueing")) {
228 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
229 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
230 } else
231 rc = -EINVAL;
232out:
233 mutex_unlock(&card->conf_mutex);
234 return rc ? rc : count;
235}
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
245 return sysfs_emit(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);
252 unsigned int cnt;
253 int rc = 0;
254
255 rc = kstrtouint(buf, 10, &cnt);
256 if (rc)
257 return rc;
258
259 mutex_lock(&card->conf_mutex);
260 if (card->state != CARD_STATE_DOWN) {
261 rc = -EPERM;
262 goto out;
263 }
264
265 cnt = clamp(cnt, QETH_IN_BUF_COUNT_MIN, QETH_IN_BUF_COUNT_MAX);
266 rc = qeth_resize_buffer_pool(card, cnt);
267
268out:
269 mutex_unlock(&card->conf_mutex);
270 return rc ? rc : count;
271}
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);
280 bool reset;
281 int rc;
282
283 rc = kstrtobool(buf, &reset);
284 if (rc)
285 return rc;
286
287 if (!qeth_card_hw_is_reachable(card))
288 return -EPERM;
289
290 if (reset)
291 rc = qeth_schedule_recovery(card);
292
293 return rc ? rc : count;
294}
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{
301 return sysfs_emit(buf, "1\n");
302}
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);
308 struct qeth_qdio_out_q *queue;
309 unsigned int i;
310 bool reset;
311 int rc;
312
313 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;
328}
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
338 return sysfs_emit(buf, "%i\n", card->options.layer);
339}
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);
345 struct net_device *ndev;
346 enum qeth_discipline_id newdis;
347 unsigned int input;
348 int rc;
349
350 rc = kstrtouint(buf, 16, &input);
351 if (rc)
352 return rc;
353
354 switch (input) {
355 case 0:
356 newdis = QETH_DISCIPLINE_LAYER3;
357 break;
358 case 1:
359 newdis = QETH_DISCIPLINE_LAYER2;
360 break;
361 default:
362 return -EINVAL;
363 }
364
365 mutex_lock(&card->discipline_mutex);
366 if (card->state != CARD_STATE_DOWN) {
367 rc = -EPERM;
368 goto out;
369 }
370
371 if (card->options.layer == newdis)
372 goto out;
373 if (card->info.layer_enforced) {
374 /* fixed layer, can't switch */
375 rc = -EOPNOTSUPP;
376 goto out;
377 }
378
379 if (card->discipline) {
380 /* start with a new, pristine netdevice: */
381 ndev = qeth_clone_netdev(card->dev);
382 if (!ndev) {
383 rc = -ENOMEM;
384 goto out;
385 }
386
387 qeth_remove_discipline(card);
388 free_netdev(card->dev);
389 card->dev = ndev;
390 }
391
392 rc = qeth_setup_discipline(card, newdis);
393
394out:
395 mutex_unlock(&card->discipline_mutex);
396 return rc ? rc : count;
397}
398
399static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
400 qeth_dev_layer2_store);
401
402#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
411 switch (card->options.isolation) {
412 case ISOLATION_MODE_NONE:
413 return sysfs_emit(buf, "%s\n", ATTR_QETH_ISOLATION_NONE);
414 case ISOLATION_MODE_FWD:
415 return sysfs_emit(buf, "%s\n", ATTR_QETH_ISOLATION_FWD);
416 case ISOLATION_MODE_DROP:
417 return sysfs_emit(buf, "%s\n", ATTR_QETH_ISOLATION_DROP);
418 default:
419 return sysfs_emit(buf, "%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;
429
430 mutex_lock(&card->conf_mutex);
431 if (!IS_OSD(card) && !IS_OSX(card)) {
432 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 */
439 if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
440 isolation = ISOLATION_MODE_NONE;
441 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
442 isolation = ISOLATION_MODE_FWD;
443 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
444 isolation = ISOLATION_MODE_DROP;
445 } else {
446 rc = -EINVAL;
447 goto out;
448 }
449
450 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
456out:
457 mutex_unlock(&card->conf_mutex);
458
459 return rc ? rc : count;
460}
461
462static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
463 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
472 if (!qeth_card_hw_is_reachable(card))
473 return sysfs_emit(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 = sysfs_emit(buf, "unknown");
481
482 if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
483 rc = sysfs_emit(buf,
484 (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
485 "[802.1]" : "802.1"));
486 if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
487 rc += sysfs_emit_at(buf, rc,
488 (sw_info.settings &
489 QETH_SWITCH_FORW_REFL_RELAY ?
490 " [rr]" : " rr"));
491 rc += sysfs_emit_at(buf, rc, "\n");
492
493 return rc;
494}
495
496static DEVICE_ATTR(switch_attrs, 0444,
497 qeth_dev_switch_attrs_show, NULL);
498
499static ssize_t qeth_hw_trap_show(struct device *dev,
500 struct device_attribute *attr, char *buf)
501{
502 struct qeth_card *card = dev_get_drvdata(dev);
503
504 if (card->info.hwtrap)
505 return sysfs_emit(buf, "arm\n");
506 else
507 return sysfs_emit(buf, "disarm\n");
508}
509
510static ssize_t qeth_hw_trap_store(struct device *dev,
511 struct device_attribute *attr, const char *buf, size_t count)
512{
513 struct qeth_card *card = dev_get_drvdata(dev);
514 int rc = 0;
515 int state = 0;
516
517 mutex_lock(&card->conf_mutex);
518 if (qeth_card_hw_is_reachable(card))
519 state = 1;
520
521 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
522 if (state) {
523 if (qeth_is_diagass_supported(card,
524 QETH_DIAGS_CMD_TRAP)) {
525 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
526 if (!rc)
527 card->info.hwtrap = 1;
528 } else
529 rc = -EINVAL;
530 } else
531 card->info.hwtrap = 1;
532 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
533 if (state) {
534 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
535 if (!rc)
536 card->info.hwtrap = 0;
537 } else
538 card->info.hwtrap = 0;
539 } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
540 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
541 else
542 rc = -EINVAL;
543
544 mutex_unlock(&card->conf_mutex);
545 return rc ? rc : count;
546}
547
548static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
549 qeth_hw_trap_store);
550
551static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
552 const char *buf, size_t count, int *value, int max_value)
553{
554 unsigned int input;
555 int rc;
556
557 rc = kstrtouint(buf, 10, &input);
558 if (rc)
559 return rc;
560
561 if (input > max_value)
562 return -EINVAL;
563
564 mutex_lock(&card->conf_mutex);
565 if (card->state != CARD_STATE_DOWN)
566 rc = -EPERM;
567 else
568 *value = input;
569 mutex_unlock(&card->conf_mutex);
570 return rc ? rc : count;
571}
572
573static ssize_t qeth_dev_blkt_total_show(struct device *dev,
574 struct device_attribute *attr, char *buf)
575{
576 struct qeth_card *card = dev_get_drvdata(dev);
577
578 return sysfs_emit(buf, "%i\n", card->info.blkt.time_total);
579}
580
581static ssize_t qeth_dev_blkt_total_store(struct device *dev,
582 struct device_attribute *attr, const char *buf, size_t count)
583{
584 struct qeth_card *card = dev_get_drvdata(dev);
585
586 return qeth_dev_blkt_store(card, buf, count,
587 &card->info.blkt.time_total, 5000);
588}
589
590static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
591 qeth_dev_blkt_total_store);
592
593static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
594 struct device_attribute *attr, char *buf)
595{
596 struct qeth_card *card = dev_get_drvdata(dev);
597
598 return sysfs_emit(buf, "%i\n", card->info.blkt.inter_packet);
599}
600
601static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
602 struct device_attribute *attr, const char *buf, size_t count)
603{
604 struct qeth_card *card = dev_get_drvdata(dev);
605
606 return qeth_dev_blkt_store(card, buf, count,
607 &card->info.blkt.inter_packet, 1000);
608}
609
610static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
611 qeth_dev_blkt_inter_store);
612
613static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
614 struct device_attribute *attr, char *buf)
615{
616 struct qeth_card *card = dev_get_drvdata(dev);
617
618 return sysfs_emit(buf, "%i\n", card->info.blkt.inter_packet_jumbo);
619}
620
621static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
622 struct device_attribute *attr, const char *buf, size_t count)
623{
624 struct qeth_card *card = dev_get_drvdata(dev);
625
626 return qeth_dev_blkt_store(card, buf, count,
627 &card->info.blkt.inter_packet_jumbo, 1000);
628}
629
630static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
631 qeth_dev_blkt_inter_jumbo_store);
632
633static struct attribute *qeth_blkt_device_attrs[] = {
634 &dev_attr_total.attr,
635 &dev_attr_inter.attr,
636 &dev_attr_inter_jumbo.attr,
637 NULL,
638};
639
640static const struct attribute_group qeth_dev_blkt_group = {
641 .name = "blkt",
642 .attrs = qeth_blkt_device_attrs,
643};
644
645static struct attribute *qeth_dev_extended_attrs[] = {
646 &dev_attr_inbuf_size.attr,
647 &dev_attr_portno.attr,
648 &dev_attr_portname.attr,
649 &dev_attr_priority_queueing.attr,
650 &dev_attr_performance_stats.attr,
651 &dev_attr_layer2.attr,
652 &dev_attr_isolation.attr,
653 &dev_attr_hw_trap.attr,
654 &dev_attr_switch_attrs.attr,
655 NULL,
656};
657
658static const struct attribute_group qeth_dev_extended_group = {
659 .attrs = qeth_dev_extended_attrs,
660};
661
662static struct attribute *qeth_dev_attrs[] = {
663 &dev_attr_state.attr,
664 &dev_attr_chpid.attr,
665 &dev_attr_if_name.attr,
666 &dev_attr_card_type.attr,
667 &dev_attr_buffer_count.attr,
668 &dev_attr_recover.attr,
669 NULL,
670};
671
672static const struct attribute_group qeth_dev_group = {
673 .attrs = qeth_dev_attrs,
674};
675
676const struct attribute_group *qeth_dev_groups[] = {
677 &qeth_dev_group,
678 &qeth_dev_extended_group,
679 &qeth_dev_blkt_group,
680 NULL,
681};
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * 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
10#define KMSG_COMPONENT "qeth"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13#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);
23 if (!card)
24 return -EINVAL;
25
26 switch (card->state) {
27 case CARD_STATE_DOWN:
28 return sprintf(buf, "DOWN\n");
29 case CARD_STATE_HARDSETUP:
30 return sprintf(buf, "HARDSETUP\n");
31 case CARD_STATE_SOFTSETUP:
32 if (card->dev->flags & IFF_UP)
33 return sprintf(buf, "UP (LAN %s)\n",
34 netif_carrier_ok(card->dev) ? "ONLINE" :
35 "OFFLINE");
36 return sprintf(buf, "SOFTSETUP\n");
37 default:
38 return sprintf(buf, "UNKNOWN\n");
39 }
40}
41
42static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
43
44static ssize_t qeth_dev_chpid_show(struct device *dev,
45 struct device_attribute *attr, char *buf)
46{
47 struct qeth_card *card = dev_get_drvdata(dev);
48 if (!card)
49 return -EINVAL;
50
51 return sprintf(buf, "%02X\n", card->info.chpid);
52}
53
54static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
55
56static ssize_t qeth_dev_if_name_show(struct device *dev,
57 struct device_attribute *attr, char *buf)
58{
59 struct qeth_card *card = dev_get_drvdata(dev);
60 if (!card)
61 return -EINVAL;
62 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
63}
64
65static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
66
67static ssize_t qeth_dev_card_type_show(struct device *dev,
68 struct device_attribute *attr, char *buf)
69{
70 struct qeth_card *card = dev_get_drvdata(dev);
71 if (!card)
72 return -EINVAL;
73
74 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
75}
76
77static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
78
79static const char *qeth_get_bufsize_str(struct qeth_card *card)
80{
81 if (card->qdio.in_buf_size == 16384)
82 return "16k";
83 else if (card->qdio.in_buf_size == 24576)
84 return "24k";
85 else if (card->qdio.in_buf_size == 32768)
86 return "32k";
87 else if (card->qdio.in_buf_size == 40960)
88 return "40k";
89 else
90 return "64k";
91}
92
93static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
94 struct device_attribute *attr, char *buf)
95{
96 struct qeth_card *card = dev_get_drvdata(dev);
97 if (!card)
98 return -EINVAL;
99
100 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
101}
102
103static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
104
105static ssize_t qeth_dev_portno_show(struct device *dev,
106 struct device_attribute *attr, char *buf)
107{
108 struct qeth_card *card = dev_get_drvdata(dev);
109 if (!card)
110 return -EINVAL;
111
112 return sprintf(buf, "%i\n", card->dev->dev_port);
113}
114
115static ssize_t qeth_dev_portno_store(struct device *dev,
116 struct device_attribute *attr, const char *buf, size_t count)
117{
118 struct qeth_card *card = dev_get_drvdata(dev);
119 char *tmp;
120 unsigned int portno, limit;
121 int rc = 0;
122
123 if (!card)
124 return -EINVAL;
125
126 mutex_lock(&card->conf_mutex);
127 if (card->state != CARD_STATE_DOWN) {
128 rc = -EPERM;
129 goto out;
130 }
131
132 portno = simple_strtoul(buf, &tmp, 16);
133 if (portno > QETH_MAX_PORTNO) {
134 rc = -EINVAL;
135 goto out;
136 }
137 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
138 if (portno > limit) {
139 rc = -EINVAL;
140 goto out;
141 }
142 card->dev->dev_port = portno;
143out:
144 mutex_unlock(&card->conf_mutex);
145 return rc ? rc : count;
146}
147
148static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
149
150static ssize_t qeth_dev_portname_show(struct device *dev,
151 struct device_attribute *attr, char *buf)
152{
153 return sprintf(buf, "no portname required\n");
154}
155
156static ssize_t qeth_dev_portname_store(struct device *dev,
157 struct device_attribute *attr, const char *buf, size_t count)
158{
159 struct qeth_card *card = dev_get_drvdata(dev);
160
161 dev_warn_once(&card->gdev->dev,
162 "portname is deprecated and is ignored\n");
163 return count;
164}
165
166static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
167 qeth_dev_portname_store);
168
169static ssize_t qeth_dev_prioqing_show(struct device *dev,
170 struct device_attribute *attr, char *buf)
171{
172 struct qeth_card *card = dev_get_drvdata(dev);
173
174 if (!card)
175 return -EINVAL;
176
177 switch (card->qdio.do_prio_queueing) {
178 case QETH_PRIO_Q_ING_PREC:
179 return sprintf(buf, "%s\n", "by precedence");
180 case QETH_PRIO_Q_ING_TOS:
181 return sprintf(buf, "%s\n", "by type of service");
182 case QETH_PRIO_Q_ING_SKB:
183 return sprintf(buf, "%s\n", "by skb-priority");
184 case QETH_PRIO_Q_ING_VLAN:
185 return sprintf(buf, "%s\n", "by VLAN headers");
186 default:
187 return sprintf(buf, "always queue %i\n",
188 card->qdio.default_out_queue);
189 }
190}
191
192static ssize_t qeth_dev_prioqing_store(struct device *dev,
193 struct device_attribute *attr, const char *buf, size_t count)
194{
195 struct qeth_card *card = dev_get_drvdata(dev);
196 int rc = 0;
197
198 if (!card)
199 return -EINVAL;
200
201 if (IS_IQD(card))
202 return -EOPNOTSUPP;
203
204 mutex_lock(&card->conf_mutex);
205 if (card->state != CARD_STATE_DOWN) {
206 rc = -EPERM;
207 goto out;
208 }
209
210 /* check if 1920 devices are supported ,
211 * if though we have to permit priority queueing
212 */
213 if (card->qdio.no_out_queues == 1) {
214 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
215 rc = -EPERM;
216 goto out;
217 }
218
219 if (sysfs_streq(buf, "prio_queueing_prec")) {
220 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
221 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
222 } else if (sysfs_streq(buf, "prio_queueing_skb")) {
223 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
224 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
225 } else if (sysfs_streq(buf, "prio_queueing_tos")) {
226 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
227 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
228 } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
229 if (IS_LAYER3(card)) {
230 rc = -ENOTSUPP;
231 goto out;
232 }
233 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
234 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
235 } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
236 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
237 card->qdio.default_out_queue = 0;
238 } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
239 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
240 card->qdio.default_out_queue = 1;
241 } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
242 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
243 card->qdio.default_out_queue = 2;
244 } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
245 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
246 card->qdio.default_out_queue = 3;
247 } else if (sysfs_streq(buf, "no_prio_queueing")) {
248 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
249 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
250 } else
251 rc = -EINVAL;
252out:
253 mutex_unlock(&card->conf_mutex);
254 return rc ? rc : count;
255}
256
257static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
258 qeth_dev_prioqing_store);
259
260static ssize_t qeth_dev_bufcnt_show(struct device *dev,
261 struct device_attribute *attr, char *buf)
262{
263 struct qeth_card *card = dev_get_drvdata(dev);
264
265 if (!card)
266 return -EINVAL;
267
268 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
269}
270
271static ssize_t qeth_dev_bufcnt_store(struct device *dev,
272 struct device_attribute *attr, const char *buf, size_t count)
273{
274 struct qeth_card *card = dev_get_drvdata(dev);
275 char *tmp;
276 int cnt, old_cnt;
277 int rc = 0;
278
279 if (!card)
280 return -EINVAL;
281
282 mutex_lock(&card->conf_mutex);
283 if (card->state != CARD_STATE_DOWN) {
284 rc = -EPERM;
285 goto out;
286 }
287
288 old_cnt = card->qdio.in_buf_pool.buf_count;
289 cnt = simple_strtoul(buf, &tmp, 10);
290 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
291 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
292 if (old_cnt != cnt) {
293 rc = qeth_realloc_buffer_pool(card, cnt);
294 }
295out:
296 mutex_unlock(&card->conf_mutex);
297 return rc ? rc : count;
298}
299
300static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
301 qeth_dev_bufcnt_store);
302
303static ssize_t qeth_dev_recover_store(struct device *dev,
304 struct device_attribute *attr, const char *buf, size_t count)
305{
306 struct qeth_card *card = dev_get_drvdata(dev);
307 char *tmp;
308 int i;
309
310 if (!card)
311 return -EINVAL;
312
313 if (!qeth_card_hw_is_reachable(card))
314 return -EPERM;
315
316 i = simple_strtoul(buf, &tmp, 16);
317 if (i == 1)
318 qeth_schedule_recovery(card);
319
320 return count;
321}
322
323static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
324
325static ssize_t qeth_dev_performance_stats_show(struct device *dev,
326 struct device_attribute *attr, char *buf)
327{
328 struct qeth_card *card = dev_get_drvdata(dev);
329
330 if (!card)
331 return -EINVAL;
332
333 return sprintf(buf, "1\n");
334}
335
336static ssize_t qeth_dev_performance_stats_store(struct device *dev,
337 struct device_attribute *attr, const char *buf, size_t count)
338{
339 struct qeth_card *card = dev_get_drvdata(dev);
340 struct qeth_qdio_out_q *queue;
341 unsigned int i;
342 bool reset;
343 int rc;
344
345 if (!card)
346 return -EINVAL;
347
348 rc = kstrtobool(buf, &reset);
349 if (rc)
350 return rc;
351
352 if (reset) {
353 memset(&card->stats, 0, sizeof(card->stats));
354 for (i = 0; i < card->qdio.no_out_queues; i++) {
355 queue = card->qdio.out_qs[i];
356 if (!queue)
357 break;
358 memset(&queue->stats, 0, sizeof(queue->stats));
359 }
360 }
361
362 return count;
363}
364
365static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
366 qeth_dev_performance_stats_store);
367
368static ssize_t qeth_dev_layer2_show(struct device *dev,
369 struct device_attribute *attr, char *buf)
370{
371 struct qeth_card *card = dev_get_drvdata(dev);
372
373 if (!card)
374 return -EINVAL;
375
376 return sprintf(buf, "%i\n", card->options.layer);
377}
378
379static ssize_t qeth_dev_layer2_store(struct device *dev,
380 struct device_attribute *attr, const char *buf, size_t count)
381{
382 struct qeth_card *card = dev_get_drvdata(dev);
383 struct net_device *ndev;
384 char *tmp;
385 int i, rc = 0;
386 enum qeth_discipline_id newdis;
387
388 if (!card)
389 return -EINVAL;
390
391 mutex_lock(&card->discipline_mutex);
392 if (card->state != CARD_STATE_DOWN) {
393 rc = -EPERM;
394 goto out;
395 }
396
397 i = simple_strtoul(buf, &tmp, 16);
398 switch (i) {
399 case 0:
400 newdis = QETH_DISCIPLINE_LAYER3;
401 break;
402 case 1:
403 newdis = QETH_DISCIPLINE_LAYER2;
404 break;
405 default:
406 rc = -EINVAL;
407 goto out;
408 }
409
410 if (card->options.layer == newdis)
411 goto out;
412 if (card->info.layer_enforced) {
413 /* fixed layer, can't switch */
414 rc = -EOPNOTSUPP;
415 goto out;
416 }
417
418 if (card->discipline) {
419 /* start with a new, pristine netdevice: */
420 ndev = qeth_clone_netdev(card->dev);
421 if (!ndev) {
422 rc = -ENOMEM;
423 goto out;
424 }
425
426 card->discipline->remove(card->gdev);
427 qeth_core_free_discipline(card);
428 free_netdev(card->dev);
429 card->dev = ndev;
430 }
431
432 rc = qeth_core_load_discipline(card, newdis);
433 if (rc)
434 goto out;
435
436 rc = card->discipline->setup(card->gdev);
437 if (rc)
438 qeth_core_free_discipline(card);
439out:
440 mutex_unlock(&card->discipline_mutex);
441 return rc ? rc : count;
442}
443
444static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
445 qeth_dev_layer2_store);
446
447#define ATTR_QETH_ISOLATION_NONE ("none")
448#define ATTR_QETH_ISOLATION_FWD ("forward")
449#define ATTR_QETH_ISOLATION_DROP ("drop")
450
451static ssize_t qeth_dev_isolation_show(struct device *dev,
452 struct device_attribute *attr, char *buf)
453{
454 struct qeth_card *card = dev_get_drvdata(dev);
455
456 if (!card)
457 return -EINVAL;
458
459 switch (card->options.isolation) {
460 case ISOLATION_MODE_NONE:
461 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
462 case ISOLATION_MODE_FWD:
463 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
464 case ISOLATION_MODE_DROP:
465 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
466 default:
467 return snprintf(buf, 5, "%s\n", "N/A");
468 }
469}
470
471static ssize_t qeth_dev_isolation_store(struct device *dev,
472 struct device_attribute *attr, const char *buf, size_t count)
473{
474 struct qeth_card *card = dev_get_drvdata(dev);
475 enum qeth_ipa_isolation_modes isolation;
476 int rc = 0;
477
478 if (!card)
479 return -EINVAL;
480
481 mutex_lock(&card->conf_mutex);
482 if (!IS_OSD(card) && !IS_OSX(card)) {
483 rc = -EOPNOTSUPP;
484 dev_err(&card->gdev->dev, "Adapter does not "
485 "support QDIO data connection isolation\n");
486 goto out;
487 }
488
489 /* parse input into isolation mode */
490 if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
491 isolation = ISOLATION_MODE_NONE;
492 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
493 isolation = ISOLATION_MODE_FWD;
494 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
495 isolation = ISOLATION_MODE_DROP;
496 } else {
497 rc = -EINVAL;
498 goto out;
499 }
500 rc = count;
501
502 /* defer IP assist if device is offline (until discipline->set_online)*/
503 card->options.prev_isolation = card->options.isolation;
504 card->options.isolation = isolation;
505 if (qeth_card_hw_is_reachable(card)) {
506 int ipa_rc = qeth_set_access_ctrl_online(card, 1);
507 if (ipa_rc != 0)
508 rc = ipa_rc;
509 }
510out:
511 mutex_unlock(&card->conf_mutex);
512 return rc;
513}
514
515static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
516 qeth_dev_isolation_store);
517
518static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
519 struct device_attribute *attr, char *buf)
520{
521 struct qeth_card *card = dev_get_drvdata(dev);
522 struct qeth_switch_info sw_info;
523 int rc = 0;
524
525 if (!card)
526 return -EINVAL;
527
528 if (!qeth_card_hw_is_reachable(card))
529 return sprintf(buf, "n/a\n");
530
531 rc = qeth_query_switch_attributes(card, &sw_info);
532 if (rc)
533 return rc;
534
535 if (!sw_info.capabilities)
536 rc = sprintf(buf, "unknown");
537
538 if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
539 rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
540 "[802.1]" : "802.1"));
541 if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
542 rc += sprintf(buf + rc,
543 (sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ?
544 " [rr]" : " rr"));
545 rc += sprintf(buf + rc, "\n");
546
547 return rc;
548}
549
550static DEVICE_ATTR(switch_attrs, 0444,
551 qeth_dev_switch_attrs_show, NULL);
552
553static ssize_t qeth_hw_trap_show(struct device *dev,
554 struct device_attribute *attr, char *buf)
555{
556 struct qeth_card *card = dev_get_drvdata(dev);
557
558 if (!card)
559 return -EINVAL;
560 if (card->info.hwtrap)
561 return snprintf(buf, 5, "arm\n");
562 else
563 return snprintf(buf, 8, "disarm\n");
564}
565
566static ssize_t qeth_hw_trap_store(struct device *dev,
567 struct device_attribute *attr, const char *buf, size_t count)
568{
569 struct qeth_card *card = dev_get_drvdata(dev);
570 int rc = 0;
571 int state = 0;
572
573 if (!card)
574 return -EINVAL;
575
576 mutex_lock(&card->conf_mutex);
577 if (qeth_card_hw_is_reachable(card))
578 state = 1;
579
580 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
581 if (state) {
582 if (qeth_is_diagass_supported(card,
583 QETH_DIAGS_CMD_TRAP)) {
584 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
585 if (!rc)
586 card->info.hwtrap = 1;
587 } else
588 rc = -EINVAL;
589 } else
590 card->info.hwtrap = 1;
591 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
592 if (state) {
593 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
594 if (!rc)
595 card->info.hwtrap = 0;
596 } else
597 card->info.hwtrap = 0;
598 } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
599 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
600 else
601 rc = -EINVAL;
602
603 mutex_unlock(&card->conf_mutex);
604 return rc ? rc : count;
605}
606
607static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
608 qeth_hw_trap_store);
609
610static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
611{
612
613 if (!card)
614 return -EINVAL;
615
616 return sprintf(buf, "%i\n", value);
617}
618
619static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
620 const char *buf, size_t count, int *value, int max_value)
621{
622 char *tmp;
623 int i, rc = 0;
624
625 if (!card)
626 return -EINVAL;
627
628 mutex_lock(&card->conf_mutex);
629 if (card->state != CARD_STATE_DOWN) {
630 rc = -EPERM;
631 goto out;
632 }
633 i = simple_strtoul(buf, &tmp, 10);
634 if (i <= max_value)
635 *value = i;
636 else
637 rc = -EINVAL;
638out:
639 mutex_unlock(&card->conf_mutex);
640 return rc ? rc : count;
641}
642
643static ssize_t qeth_dev_blkt_total_show(struct device *dev,
644 struct device_attribute *attr, char *buf)
645{
646 struct qeth_card *card = dev_get_drvdata(dev);
647
648 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
649}
650
651static ssize_t qeth_dev_blkt_total_store(struct device *dev,
652 struct device_attribute *attr, const char *buf, size_t count)
653{
654 struct qeth_card *card = dev_get_drvdata(dev);
655
656 return qeth_dev_blkt_store(card, buf, count,
657 &card->info.blkt.time_total, 5000);
658}
659
660
661
662static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
663 qeth_dev_blkt_total_store);
664
665static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
666 struct device_attribute *attr, char *buf)
667{
668 struct qeth_card *card = dev_get_drvdata(dev);
669
670 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
671}
672
673static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
674 struct device_attribute *attr, const char *buf, size_t count)
675{
676 struct qeth_card *card = dev_get_drvdata(dev);
677
678 return qeth_dev_blkt_store(card, buf, count,
679 &card->info.blkt.inter_packet, 1000);
680}
681
682static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
683 qeth_dev_blkt_inter_store);
684
685static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
686 struct device_attribute *attr, char *buf)
687{
688 struct qeth_card *card = dev_get_drvdata(dev);
689
690 return qeth_dev_blkt_show(buf, card,
691 card->info.blkt.inter_packet_jumbo);
692}
693
694static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
695 struct device_attribute *attr, const char *buf, size_t count)
696{
697 struct qeth_card *card = dev_get_drvdata(dev);
698
699 return qeth_dev_blkt_store(card, buf, count,
700 &card->info.blkt.inter_packet_jumbo, 1000);
701}
702
703static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
704 qeth_dev_blkt_inter_jumbo_store);
705
706static struct attribute *qeth_blkt_device_attrs[] = {
707 &dev_attr_total.attr,
708 &dev_attr_inter.attr,
709 &dev_attr_inter_jumbo.attr,
710 NULL,
711};
712const struct attribute_group qeth_device_blkt_group = {
713 .name = "blkt",
714 .attrs = qeth_blkt_device_attrs,
715};
716EXPORT_SYMBOL_GPL(qeth_device_blkt_group);
717
718static struct attribute *qeth_device_attrs[] = {
719 &dev_attr_state.attr,
720 &dev_attr_chpid.attr,
721 &dev_attr_if_name.attr,
722 &dev_attr_card_type.attr,
723 &dev_attr_inbuf_size.attr,
724 &dev_attr_portno.attr,
725 &dev_attr_portname.attr,
726 &dev_attr_priority_queueing.attr,
727 &dev_attr_buffer_count.attr,
728 &dev_attr_recover.attr,
729 &dev_attr_performance_stats.attr,
730 &dev_attr_layer2.attr,
731 &dev_attr_isolation.attr,
732 &dev_attr_hw_trap.attr,
733 &dev_attr_switch_attrs.attr,
734 NULL,
735};
736const struct attribute_group qeth_device_attr_group = {
737 .attrs = qeth_device_attrs,
738};
739EXPORT_SYMBOL_GPL(qeth_device_attr_group);
740
741const struct attribute_group *qeth_generic_attr_groups[] = {
742 &qeth_device_attr_group,
743 &qeth_device_blkt_group,
744 NULL,
745};
746
747static struct attribute *qeth_osn_device_attrs[] = {
748 &dev_attr_state.attr,
749 &dev_attr_chpid.attr,
750 &dev_attr_if_name.attr,
751 &dev_attr_card_type.attr,
752 &dev_attr_buffer_count.attr,
753 &dev_attr_recover.attr,
754 NULL,
755};
756static struct attribute_group qeth_osn_device_attr_group = {
757 .attrs = qeth_osn_device_attrs,
758};
759const struct attribute_group *qeth_osn_attr_groups[] = {
760 &qeth_osn_device_attr_group,
761 NULL,
762};