1 // SPDX-License-Identifier: GPL-2.0
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>
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/list.h>
14 #include <linux/rwsem.h>
15 #include <asm/ebcdic.h>
17 #include "qeth_core.h"
19 static ssize_t qeth_dev_state_show(struct device *dev,
20 struct device_attribute *attr, char *buf)
22 struct qeth_card *card = dev_get_drvdata(dev);
26 switch (card->state) {
28 return sprintf(buf, "DOWN\n");
29 case CARD_STATE_HARDSETUP:
30 return sprintf(buf, "HARDSETUP\n");
31 case CARD_STATE_SOFTSETUP:
32 return sprintf(buf, "SOFTSETUP\n");
35 return sprintf(buf, "UP (LAN ONLINE)\n");
37 return sprintf(buf, "UP (LAN OFFLINE)\n");
38 case CARD_STATE_RECOVER:
39 return sprintf(buf, "RECOVER\n");
41 return sprintf(buf, "UNKNOWN\n");
45 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
47 static ssize_t qeth_dev_chpid_show(struct device *dev,
48 struct device_attribute *attr, char *buf)
50 struct qeth_card *card = dev_get_drvdata(dev);
54 return sprintf(buf, "%02X\n", card->info.chpid);
57 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
59 static ssize_t qeth_dev_if_name_show(struct device *dev,
60 struct device_attribute *attr, char *buf)
62 struct qeth_card *card = dev_get_drvdata(dev);
65 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
68 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
70 static ssize_t qeth_dev_card_type_show(struct device *dev,
71 struct device_attribute *attr, char *buf)
73 struct qeth_card *card = dev_get_drvdata(dev);
77 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
80 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
82 static const char *qeth_get_bufsize_str(struct qeth_card *card)
84 if (card->qdio.in_buf_size == 16384)
86 else if (card->qdio.in_buf_size == 24576)
88 else if (card->qdio.in_buf_size == 32768)
90 else if (card->qdio.in_buf_size == 40960)
96 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
97 struct device_attribute *attr, char *buf)
99 struct qeth_card *card = dev_get_drvdata(dev);
103 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
106 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
108 static ssize_t qeth_dev_portno_show(struct device *dev,
109 struct device_attribute *attr, char *buf)
111 struct qeth_card *card = dev_get_drvdata(dev);
115 return sprintf(buf, "%i\n", card->info.portno);
118 static ssize_t qeth_dev_portno_store(struct device *dev,
119 struct device_attribute *attr, const char *buf, size_t count)
121 struct qeth_card *card = dev_get_drvdata(dev);
123 unsigned int portno, limit;
129 mutex_lock(&card->conf_mutex);
130 if ((card->state != CARD_STATE_DOWN) &&
131 (card->state != CARD_STATE_RECOVER)) {
136 portno = simple_strtoul(buf, &tmp, 16);
137 if (portno > QETH_MAX_PORTNO) {
141 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
142 if (portno > limit) {
146 card->info.portno = portno;
148 mutex_unlock(&card->conf_mutex);
149 return rc ? rc : count;
152 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
154 static ssize_t qeth_dev_portname_show(struct device *dev,
155 struct device_attribute *attr, char *buf)
157 return sprintf(buf, "no portname required\n");
160 static ssize_t qeth_dev_portname_store(struct device *dev,
161 struct device_attribute *attr, const char *buf, size_t count)
163 struct qeth_card *card = dev_get_drvdata(dev);
165 dev_warn_once(&card->gdev->dev,
166 "portname is deprecated and is ignored\n");
170 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
171 qeth_dev_portname_store);
173 static ssize_t qeth_dev_prioqing_show(struct device *dev,
174 struct device_attribute *attr, char *buf)
176 struct qeth_card *card = dev_get_drvdata(dev);
181 switch (card->qdio.do_prio_queueing) {
182 case QETH_PRIO_Q_ING_PREC:
183 return sprintf(buf, "%s\n", "by precedence");
184 case QETH_PRIO_Q_ING_TOS:
185 return sprintf(buf, "%s\n", "by type of service");
186 case QETH_PRIO_Q_ING_SKB:
187 return sprintf(buf, "%s\n", "by skb-priority");
188 case QETH_PRIO_Q_ING_VLAN:
189 return sprintf(buf, "%s\n", "by VLAN headers");
191 return sprintf(buf, "always queue %i\n",
192 card->qdio.default_out_queue);
196 static ssize_t qeth_dev_prioqing_store(struct device *dev,
197 struct device_attribute *attr, const char *buf, size_t count)
199 struct qeth_card *card = dev_get_drvdata(dev);
205 mutex_lock(&card->conf_mutex);
206 if ((card->state != CARD_STATE_DOWN) &&
207 (card->state != CARD_STATE_RECOVER)) {
212 /* check if 1920 devices are supported ,
213 * if though we have to permit priority queueing
215 if (card->qdio.no_out_queues == 1) {
216 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
221 if (sysfs_streq(buf, "prio_queueing_prec")) {
222 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
223 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
224 } else if (sysfs_streq(buf, "prio_queueing_skb")) {
225 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
226 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
227 } else if (sysfs_streq(buf, "prio_queueing_tos")) {
228 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
229 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
230 } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
231 if (!card->options.layer2) {
235 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
236 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
237 } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
238 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
239 card->qdio.default_out_queue = 0;
240 } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
241 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
242 card->qdio.default_out_queue = 1;
243 } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
244 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
245 card->qdio.default_out_queue = 2;
246 } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
247 if (card->info.type == QETH_CARD_TYPE_IQD) {
251 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
252 card->qdio.default_out_queue = 3;
253 } else if (sysfs_streq(buf, "no_prio_queueing")) {
254 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
255 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
259 mutex_unlock(&card->conf_mutex);
260 return rc ? rc : count;
263 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
264 qeth_dev_prioqing_store);
266 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
267 struct device_attribute *attr, char *buf)
269 struct qeth_card *card = dev_get_drvdata(dev);
274 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
277 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
278 struct device_attribute *attr, const char *buf, size_t count)
280 struct qeth_card *card = dev_get_drvdata(dev);
288 mutex_lock(&card->conf_mutex);
289 if ((card->state != CARD_STATE_DOWN) &&
290 (card->state != CARD_STATE_RECOVER)) {
295 old_cnt = card->qdio.in_buf_pool.buf_count;
296 cnt = simple_strtoul(buf, &tmp, 10);
297 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
298 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
299 if (old_cnt != cnt) {
300 rc = qeth_realloc_buffer_pool(card, cnt);
303 mutex_unlock(&card->conf_mutex);
304 return rc ? rc : count;
307 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
308 qeth_dev_bufcnt_store);
310 static ssize_t qeth_dev_recover_store(struct device *dev,
311 struct device_attribute *attr, const char *buf, size_t count)
313 struct qeth_card *card = dev_get_drvdata(dev);
320 if (card->state != CARD_STATE_UP)
323 i = simple_strtoul(buf, &tmp, 16);
325 qeth_schedule_recovery(card);
330 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
332 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
333 struct device_attribute *attr, char *buf)
335 struct qeth_card *card = dev_get_drvdata(dev);
340 return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
343 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
344 struct device_attribute *attr, const char *buf, size_t count)
346 struct qeth_card *card = dev_get_drvdata(dev);
353 mutex_lock(&card->conf_mutex);
354 i = simple_strtoul(buf, &tmp, 16);
355 if ((i == 0) || (i == 1)) {
356 if (i == card->options.performance_stats)
358 card->options.performance_stats = i;
360 memset(&card->perf_stats, 0,
361 sizeof(struct qeth_perf_stats));
362 card->perf_stats.initial_rx_packets = card->stats.rx_packets;
363 card->perf_stats.initial_tx_packets = card->stats.tx_packets;
367 mutex_unlock(&card->conf_mutex);
368 return rc ? rc : count;
371 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
372 qeth_dev_performance_stats_store);
374 static ssize_t qeth_dev_layer2_show(struct device *dev,
375 struct device_attribute *attr, char *buf)
377 struct qeth_card *card = dev_get_drvdata(dev);
382 return sprintf(buf, "%i\n", card->options.layer2);
385 static ssize_t qeth_dev_layer2_store(struct device *dev,
386 struct device_attribute *attr, const char *buf, size_t count)
388 struct qeth_card *card = dev_get_drvdata(dev);
391 enum qeth_discipline_id newdis;
396 mutex_lock(&card->discipline_mutex);
397 if (card->state != CARD_STATE_DOWN) {
402 i = simple_strtoul(buf, &tmp, 16);
405 newdis = QETH_DISCIPLINE_LAYER3;
408 newdis = QETH_DISCIPLINE_LAYER2;
415 if (card->options.layer2 == newdis)
417 if (card->info.layer_enforced) {
418 /* fixed layer, can't switch */
423 card->info.mac_bits = 0;
424 if (card->discipline) {
425 card->discipline->remove(card->gdev);
426 qeth_core_free_discipline(card);
429 rc = qeth_core_load_discipline(card, newdis);
433 rc = card->discipline->setup(card->gdev);
435 qeth_core_free_discipline(card);
437 mutex_unlock(&card->discipline_mutex);
438 return rc ? rc : count;
441 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
442 qeth_dev_layer2_store);
444 #define ATTR_QETH_ISOLATION_NONE ("none")
445 #define ATTR_QETH_ISOLATION_FWD ("forward")
446 #define ATTR_QETH_ISOLATION_DROP ("drop")
448 static ssize_t qeth_dev_isolation_show(struct device *dev,
449 struct device_attribute *attr, char *buf)
451 struct qeth_card *card = dev_get_drvdata(dev);
456 switch (card->options.isolation) {
457 case ISOLATION_MODE_NONE:
458 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
459 case ISOLATION_MODE_FWD:
460 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
461 case ISOLATION_MODE_DROP:
462 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
464 return snprintf(buf, 5, "%s\n", "N/A");
468 static ssize_t qeth_dev_isolation_store(struct device *dev,
469 struct device_attribute *attr, const char *buf, size_t count)
471 struct qeth_card *card = dev_get_drvdata(dev);
472 enum qeth_ipa_isolation_modes isolation;
478 mutex_lock(&card->conf_mutex);
479 if (card->info.type != QETH_CARD_TYPE_OSD &&
480 card->info.type != QETH_CARD_TYPE_OSX) {
482 dev_err(&card->gdev->dev, "Adapter does not "
483 "support QDIO data connection isolation\n");
487 /* parse input into isolation mode */
488 if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
489 isolation = ISOLATION_MODE_NONE;
490 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
491 isolation = ISOLATION_MODE_FWD;
492 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
493 isolation = ISOLATION_MODE_DROP;
500 /* defer IP assist if device is offline (until discipline->set_online)*/
501 card->options.prev_isolation = card->options.isolation;
502 card->options.isolation = isolation;
503 if (qeth_card_hw_is_reachable(card)) {
504 int ipa_rc = qeth_set_access_ctrl_online(card, 1);
509 mutex_unlock(&card->conf_mutex);
513 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
514 qeth_dev_isolation_store);
516 static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
517 struct device_attribute *attr, char *buf)
519 struct qeth_card *card = dev_get_drvdata(dev);
520 struct qeth_switch_info sw_info;
526 if (!qeth_card_hw_is_reachable(card))
527 return sprintf(buf, "n/a\n");
529 rc = qeth_query_switch_attributes(card, &sw_info);
533 if (!sw_info.capabilities)
534 rc = sprintf(buf, "unknown");
536 if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
537 rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
538 "[802.1]" : "802.1"));
539 if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
540 rc += sprintf(buf + rc,
541 (sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ?
543 rc += sprintf(buf + rc, "\n");
548 static DEVICE_ATTR(switch_attrs, 0444,
549 qeth_dev_switch_attrs_show, NULL);
551 static ssize_t qeth_hw_trap_show(struct device *dev,
552 struct device_attribute *attr, char *buf)
554 struct qeth_card *card = dev_get_drvdata(dev);
558 if (card->info.hwtrap)
559 return snprintf(buf, 5, "arm\n");
561 return snprintf(buf, 8, "disarm\n");
564 static ssize_t qeth_hw_trap_store(struct device *dev,
565 struct device_attribute *attr, const char *buf, size_t count)
567 struct qeth_card *card = dev_get_drvdata(dev);
574 mutex_lock(&card->conf_mutex);
575 if (qeth_card_hw_is_reachable(card))
578 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
580 if (qeth_is_diagass_supported(card,
581 QETH_DIAGS_CMD_TRAP)) {
582 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
584 card->info.hwtrap = 1;
588 card->info.hwtrap = 1;
589 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
591 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
593 card->info.hwtrap = 0;
595 card->info.hwtrap = 0;
596 } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
597 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
601 mutex_unlock(&card->conf_mutex);
602 return rc ? rc : count;
605 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
608 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
614 return sprintf(buf, "%i\n", value);
617 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
618 const char *buf, size_t count, int *value, int max_value)
626 mutex_lock(&card->conf_mutex);
627 if ((card->state != CARD_STATE_DOWN) &&
628 (card->state != CARD_STATE_RECOVER)) {
632 i = simple_strtoul(buf, &tmp, 10);
638 mutex_unlock(&card->conf_mutex);
639 return rc ? rc : count;
642 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
643 struct device_attribute *attr, char *buf)
645 struct qeth_card *card = dev_get_drvdata(dev);
647 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
650 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
651 struct device_attribute *attr, const char *buf, size_t count)
653 struct qeth_card *card = dev_get_drvdata(dev);
655 return qeth_dev_blkt_store(card, buf, count,
656 &card->info.blkt.time_total, 5000);
661 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
662 qeth_dev_blkt_total_store);
664 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
665 struct device_attribute *attr, char *buf)
667 struct qeth_card *card = dev_get_drvdata(dev);
669 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
672 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
673 struct device_attribute *attr, const char *buf, size_t count)
675 struct qeth_card *card = dev_get_drvdata(dev);
677 return qeth_dev_blkt_store(card, buf, count,
678 &card->info.blkt.inter_packet, 1000);
681 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
682 qeth_dev_blkt_inter_store);
684 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
685 struct device_attribute *attr, char *buf)
687 struct qeth_card *card = dev_get_drvdata(dev);
689 return qeth_dev_blkt_show(buf, card,
690 card->info.blkt.inter_packet_jumbo);
693 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
694 struct device_attribute *attr, const char *buf, size_t count)
696 struct qeth_card *card = dev_get_drvdata(dev);
698 return qeth_dev_blkt_store(card, buf, count,
699 &card->info.blkt.inter_packet_jumbo, 1000);
702 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
703 qeth_dev_blkt_inter_jumbo_store);
705 static struct attribute *qeth_blkt_device_attrs[] = {
706 &dev_attr_total.attr,
707 &dev_attr_inter.attr,
708 &dev_attr_inter_jumbo.attr,
711 const struct attribute_group qeth_device_blkt_group = {
713 .attrs = qeth_blkt_device_attrs,
715 EXPORT_SYMBOL_GPL(qeth_device_blkt_group);
717 static struct attribute *qeth_device_attrs[] = {
718 &dev_attr_state.attr,
719 &dev_attr_chpid.attr,
720 &dev_attr_if_name.attr,
721 &dev_attr_card_type.attr,
722 &dev_attr_inbuf_size.attr,
723 &dev_attr_portno.attr,
724 &dev_attr_portname.attr,
725 &dev_attr_priority_queueing.attr,
726 &dev_attr_buffer_count.attr,
727 &dev_attr_recover.attr,
728 &dev_attr_performance_stats.attr,
729 &dev_attr_layer2.attr,
730 &dev_attr_isolation.attr,
731 &dev_attr_hw_trap.attr,
732 &dev_attr_switch_attrs.attr,
735 const struct attribute_group qeth_device_attr_group = {
736 .attrs = qeth_device_attrs,
738 EXPORT_SYMBOL_GPL(qeth_device_attr_group);
740 const struct attribute_group *qeth_generic_attr_groups[] = {
741 &qeth_device_attr_group,
742 &qeth_device_blkt_group,
746 static struct attribute *qeth_osn_device_attrs[] = {
747 &dev_attr_state.attr,
748 &dev_attr_chpid.attr,
749 &dev_attr_if_name.attr,
750 &dev_attr_card_type.attr,
751 &dev_attr_buffer_count.attr,
752 &dev_attr_recover.attr,
755 static struct attribute_group qeth_osn_device_attr_group = {
756 .attrs = qeth_osn_device_attrs,
758 const struct attribute_group *qeth_osn_attr_groups[] = {
759 &qeth_osn_device_attr_group,