2 * Copyright IBM Corp. 2007
3 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
4 * Frank Pavlic <fpavlic@de.ibm.com>,
5 * Thomas Spatzier <tspat@de.ibm.com>,
6 * Frank Blaschka <frank.blaschka@de.ibm.com>
9 #define KMSG_COMPONENT "qeth"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/list.h>
13 #include <linux/rwsem.h>
14 #include <asm/ebcdic.h>
16 #include "qeth_core.h"
18 static ssize_t qeth_dev_state_show(struct device *dev,
19 struct device_attribute *attr, char *buf)
21 struct qeth_card *card = dev_get_drvdata(dev);
25 switch (card->state) {
27 return sprintf(buf, "DOWN\n");
28 case CARD_STATE_HARDSETUP:
29 return sprintf(buf, "HARDSETUP\n");
30 case CARD_STATE_SOFTSETUP:
31 return sprintf(buf, "SOFTSETUP\n");
34 return sprintf(buf, "UP (LAN ONLINE)\n");
36 return sprintf(buf, "UP (LAN OFFLINE)\n");
37 case CARD_STATE_RECOVER:
38 return sprintf(buf, "RECOVER\n");
40 return sprintf(buf, "UNKNOWN\n");
44 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
46 static ssize_t qeth_dev_chpid_show(struct device *dev,
47 struct device_attribute *attr, char *buf)
49 struct qeth_card *card = dev_get_drvdata(dev);
53 return sprintf(buf, "%02X\n", card->info.chpid);
56 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
58 static ssize_t qeth_dev_if_name_show(struct device *dev,
59 struct device_attribute *attr, char *buf)
61 struct qeth_card *card = dev_get_drvdata(dev);
64 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
67 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
69 static ssize_t qeth_dev_card_type_show(struct device *dev,
70 struct device_attribute *attr, char *buf)
72 struct qeth_card *card = dev_get_drvdata(dev);
76 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
79 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
81 static const char *qeth_get_bufsize_str(struct qeth_card *card)
83 if (card->qdio.in_buf_size == 16384)
85 else if (card->qdio.in_buf_size == 24576)
87 else if (card->qdio.in_buf_size == 32768)
89 else if (card->qdio.in_buf_size == 40960)
95 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
96 struct device_attribute *attr, char *buf)
98 struct qeth_card *card = dev_get_drvdata(dev);
102 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
105 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
107 static ssize_t qeth_dev_portno_show(struct device *dev,
108 struct device_attribute *attr, char *buf)
110 struct qeth_card *card = dev_get_drvdata(dev);
114 return sprintf(buf, "%i\n", card->info.portno);
117 static ssize_t qeth_dev_portno_store(struct device *dev,
118 struct device_attribute *attr, const char *buf, size_t count)
120 struct qeth_card *card = dev_get_drvdata(dev);
122 unsigned int portno, limit;
128 mutex_lock(&card->conf_mutex);
129 if ((card->state != CARD_STATE_DOWN) &&
130 (card->state != CARD_STATE_RECOVER)) {
135 portno = simple_strtoul(buf, &tmp, 16);
136 if (portno > QETH_MAX_PORTNO) {
140 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
141 if (portno > limit) {
145 card->info.portno = portno;
147 mutex_unlock(&card->conf_mutex);
148 return rc ? rc : count;
151 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
153 static ssize_t qeth_dev_portname_show(struct device *dev,
154 struct device_attribute *attr, char *buf)
156 return sprintf(buf, "no portname required\n");
159 static ssize_t qeth_dev_portname_store(struct device *dev,
160 struct device_attribute *attr, const char *buf, size_t count)
162 struct qeth_card *card = dev_get_drvdata(dev);
164 dev_warn_once(&card->gdev->dev,
165 "portname is deprecated and is ignored\n");
169 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
170 qeth_dev_portname_store);
172 static ssize_t qeth_dev_prioqing_show(struct device *dev,
173 struct device_attribute *attr, char *buf)
175 struct qeth_card *card = dev_get_drvdata(dev);
180 switch (card->qdio.do_prio_queueing) {
181 case QETH_PRIO_Q_ING_PREC:
182 return sprintf(buf, "%s\n", "by precedence");
183 case QETH_PRIO_Q_ING_TOS:
184 return sprintf(buf, "%s\n", "by type of service");
185 case QETH_PRIO_Q_ING_SKB:
186 return sprintf(buf, "%s\n", "by skb-priority");
187 case QETH_PRIO_Q_ING_VLAN:
188 return sprintf(buf, "%s\n", "by VLAN headers");
190 return sprintf(buf, "always queue %i\n",
191 card->qdio.default_out_queue);
195 static ssize_t qeth_dev_prioqing_store(struct device *dev,
196 struct device_attribute *attr, const char *buf, size_t count)
198 struct qeth_card *card = dev_get_drvdata(dev);
204 mutex_lock(&card->conf_mutex);
205 if ((card->state != CARD_STATE_DOWN) &&
206 (card->state != CARD_STATE_RECOVER)) {
211 /* check if 1920 devices are supported ,
212 * if though we have to permit priority queueing
214 if (card->qdio.no_out_queues == 1) {
215 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
220 if (sysfs_streq(buf, "prio_queueing_prec")) {
221 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
222 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
223 } else if (sysfs_streq(buf, "prio_queueing_skb")) {
224 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
225 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
226 } else if (sysfs_streq(buf, "prio_queueing_tos")) {
227 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
228 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
229 } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
230 if (!card->options.layer2) {
234 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
235 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
236 } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
237 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
238 card->qdio.default_out_queue = 0;
239 } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
240 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
241 card->qdio.default_out_queue = 1;
242 } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
243 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
244 card->qdio.default_out_queue = 2;
245 } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
246 if (card->info.type == QETH_CARD_TYPE_IQD) {
250 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
251 card->qdio.default_out_queue = 3;
252 } else if (sysfs_streq(buf, "no_prio_queueing")) {
253 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
254 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
258 mutex_unlock(&card->conf_mutex);
259 return rc ? rc : count;
262 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
263 qeth_dev_prioqing_store);
265 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
266 struct device_attribute *attr, char *buf)
268 struct qeth_card *card = dev_get_drvdata(dev);
273 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
276 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
277 struct device_attribute *attr, const char *buf, size_t count)
279 struct qeth_card *card = dev_get_drvdata(dev);
287 mutex_lock(&card->conf_mutex);
288 if ((card->state != CARD_STATE_DOWN) &&
289 (card->state != CARD_STATE_RECOVER)) {
294 old_cnt = card->qdio.in_buf_pool.buf_count;
295 cnt = simple_strtoul(buf, &tmp, 10);
296 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
297 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
298 if (old_cnt != cnt) {
299 rc = qeth_realloc_buffer_pool(card, cnt);
302 mutex_unlock(&card->conf_mutex);
303 return rc ? rc : count;
306 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
307 qeth_dev_bufcnt_store);
309 static ssize_t qeth_dev_recover_store(struct device *dev,
310 struct device_attribute *attr, const char *buf, size_t count)
312 struct qeth_card *card = dev_get_drvdata(dev);
319 if (card->state != CARD_STATE_UP)
322 i = simple_strtoul(buf, &tmp, 16);
324 qeth_schedule_recovery(card);
329 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
331 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
332 struct device_attribute *attr, char *buf)
334 struct qeth_card *card = dev_get_drvdata(dev);
339 return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
342 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
343 struct device_attribute *attr, const char *buf, size_t count)
345 struct qeth_card *card = dev_get_drvdata(dev);
352 mutex_lock(&card->conf_mutex);
353 i = simple_strtoul(buf, &tmp, 16);
354 if ((i == 0) || (i == 1)) {
355 if (i == card->options.performance_stats)
357 card->options.performance_stats = i;
359 memset(&card->perf_stats, 0,
360 sizeof(struct qeth_perf_stats));
361 card->perf_stats.initial_rx_packets = card->stats.rx_packets;
362 card->perf_stats.initial_tx_packets = card->stats.tx_packets;
366 mutex_unlock(&card->conf_mutex);
367 return rc ? rc : count;
370 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
371 qeth_dev_performance_stats_store);
373 static ssize_t qeth_dev_layer2_show(struct device *dev,
374 struct device_attribute *attr, char *buf)
376 struct qeth_card *card = dev_get_drvdata(dev);
381 return sprintf(buf, "%i\n", card->options.layer2);
384 static ssize_t qeth_dev_layer2_store(struct device *dev,
385 struct device_attribute *attr, const char *buf, size_t count)
387 struct qeth_card *card = dev_get_drvdata(dev);
390 enum qeth_discipline_id newdis;
395 mutex_lock(&card->discipline_mutex);
396 if (card->state != CARD_STATE_DOWN) {
401 i = simple_strtoul(buf, &tmp, 16);
404 newdis = QETH_DISCIPLINE_LAYER3;
407 newdis = QETH_DISCIPLINE_LAYER2;
414 if (card->options.layer2 == newdis)
416 if (card->info.layer_enforced) {
417 /* fixed layer, can't switch */
422 card->info.mac_bits = 0;
423 if (card->discipline) {
424 card->discipline->remove(card->gdev);
425 qeth_core_free_discipline(card);
426 card->options.layer2 = -1;
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 /* check for unknown, too, in case we do not yet know who we are */
480 if (card->info.type != QETH_CARD_TYPE_OSD &&
481 card->info.type != QETH_CARD_TYPE_OSX &&
482 card->info.type != QETH_CARD_TYPE_UNKNOWN) {
484 dev_err(&card->gdev->dev, "Adapter does not "
485 "support QDIO data connection isolation\n");
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;
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);
511 mutex_unlock(&card->conf_mutex);
515 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
516 qeth_dev_isolation_store);
518 static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
519 struct device_attribute *attr, char *buf)
521 struct qeth_card *card = dev_get_drvdata(dev);
522 struct qeth_switch_info sw_info;
528 if (!qeth_card_hw_is_reachable(card))
529 return sprintf(buf, "n/a\n");
531 rc = qeth_query_switch_attributes(card, &sw_info);
535 if (!sw_info.capabilities)
536 rc = sprintf(buf, "unknown");
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 ?
545 rc += sprintf(buf + rc, "\n");
550 static DEVICE_ATTR(switch_attrs, 0444,
551 qeth_dev_switch_attrs_show, NULL);
553 static ssize_t qeth_hw_trap_show(struct device *dev,
554 struct device_attribute *attr, char *buf)
556 struct qeth_card *card = dev_get_drvdata(dev);
560 if (card->info.hwtrap)
561 return snprintf(buf, 5, "arm\n");
563 return snprintf(buf, 8, "disarm\n");
566 static ssize_t qeth_hw_trap_store(struct device *dev,
567 struct device_attribute *attr, const char *buf, size_t count)
569 struct qeth_card *card = dev_get_drvdata(dev);
576 mutex_lock(&card->conf_mutex);
577 if (qeth_card_hw_is_reachable(card))
580 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
582 if (qeth_is_diagass_supported(card,
583 QETH_DIAGS_CMD_TRAP)) {
584 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
586 card->info.hwtrap = 1;
590 card->info.hwtrap = 1;
591 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
593 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
595 card->info.hwtrap = 0;
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);
603 mutex_unlock(&card->conf_mutex);
604 return rc ? rc : count;
607 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
610 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
616 return sprintf(buf, "%i\n", value);
619 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
620 const char *buf, size_t count, int *value, int max_value)
628 mutex_lock(&card->conf_mutex);
629 if ((card->state != CARD_STATE_DOWN) &&
630 (card->state != CARD_STATE_RECOVER)) {
634 i = simple_strtoul(buf, &tmp, 10);
640 mutex_unlock(&card->conf_mutex);
641 return rc ? rc : count;
644 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
645 struct device_attribute *attr, char *buf)
647 struct qeth_card *card = dev_get_drvdata(dev);
649 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
652 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
653 struct device_attribute *attr, const char *buf, size_t count)
655 struct qeth_card *card = dev_get_drvdata(dev);
657 return qeth_dev_blkt_store(card, buf, count,
658 &card->info.blkt.time_total, 5000);
663 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
664 qeth_dev_blkt_total_store);
666 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
667 struct device_attribute *attr, char *buf)
669 struct qeth_card *card = dev_get_drvdata(dev);
671 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
674 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
675 struct device_attribute *attr, const char *buf, size_t count)
677 struct qeth_card *card = dev_get_drvdata(dev);
679 return qeth_dev_blkt_store(card, buf, count,
680 &card->info.blkt.inter_packet, 1000);
683 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
684 qeth_dev_blkt_inter_store);
686 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
687 struct device_attribute *attr, char *buf)
689 struct qeth_card *card = dev_get_drvdata(dev);
691 return qeth_dev_blkt_show(buf, card,
692 card->info.blkt.inter_packet_jumbo);
695 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
696 struct device_attribute *attr, const char *buf, size_t count)
698 struct qeth_card *card = dev_get_drvdata(dev);
700 return qeth_dev_blkt_store(card, buf, count,
701 &card->info.blkt.inter_packet_jumbo, 1000);
704 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
705 qeth_dev_blkt_inter_jumbo_store);
707 static struct attribute *qeth_blkt_device_attrs[] = {
708 &dev_attr_total.attr,
709 &dev_attr_inter.attr,
710 &dev_attr_inter_jumbo.attr,
713 const struct attribute_group qeth_device_blkt_group = {
715 .attrs = qeth_blkt_device_attrs,
717 EXPORT_SYMBOL_GPL(qeth_device_blkt_group);
719 static struct attribute *qeth_device_attrs[] = {
720 &dev_attr_state.attr,
721 &dev_attr_chpid.attr,
722 &dev_attr_if_name.attr,
723 &dev_attr_card_type.attr,
724 &dev_attr_inbuf_size.attr,
725 &dev_attr_portno.attr,
726 &dev_attr_portname.attr,
727 &dev_attr_priority_queueing.attr,
728 &dev_attr_buffer_count.attr,
729 &dev_attr_recover.attr,
730 &dev_attr_performance_stats.attr,
731 &dev_attr_layer2.attr,
732 &dev_attr_isolation.attr,
733 &dev_attr_hw_trap.attr,
734 &dev_attr_switch_attrs.attr,
737 const struct attribute_group qeth_device_attr_group = {
738 .attrs = qeth_device_attrs,
740 EXPORT_SYMBOL_GPL(qeth_device_attr_group);
742 const struct attribute_group *qeth_generic_attr_groups[] = {
743 &qeth_device_attr_group,
744 &qeth_device_blkt_group,
748 static struct attribute *qeth_osn_device_attrs[] = {
749 &dev_attr_state.attr,
750 &dev_attr_chpid.attr,
751 &dev_attr_if_name.attr,
752 &dev_attr_card_type.attr,
753 &dev_attr_buffer_count.attr,
754 &dev_attr_recover.attr,
757 static struct attribute_group qeth_osn_device_attr_group = {
758 .attrs = qeth_osn_device_attrs,
760 const struct attribute_group *qeth_osn_attr_groups[] = {
761 &qeth_osn_device_attr_group,