2 * drivers/s390/net/qeth_core_sys.c
4 * Copyright IBM Corp. 2007
5 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
6 * Frank Pavlic <fpavlic@de.ibm.com>,
7 * Thomas Spatzier <tspat@de.ibm.com>,
8 * Frank Blaschka <frank.blaschka@de.ibm.com>
11 #include <linux/list.h>
12 #include <linux/rwsem.h>
13 #include <asm/ebcdic.h>
15 #include "qeth_core.h"
17 static ssize_t qeth_dev_state_show(struct device *dev,
18 struct device_attribute *attr, char *buf)
20 struct qeth_card *card = dev_get_drvdata(dev);
24 switch (card->state) {
26 return sprintf(buf, "DOWN\n");
27 case CARD_STATE_HARDSETUP:
28 return sprintf(buf, "HARDSETUP\n");
29 case CARD_STATE_SOFTSETUP:
30 return sprintf(buf, "SOFTSETUP\n");
33 return sprintf(buf, "UP (LAN ONLINE)\n");
35 return sprintf(buf, "UP (LAN OFFLINE)\n");
36 case CARD_STATE_RECOVER:
37 return sprintf(buf, "RECOVER\n");
39 return sprintf(buf, "UNKNOWN\n");
43 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
45 static ssize_t qeth_dev_chpid_show(struct device *dev,
46 struct device_attribute *attr, char *buf)
48 struct qeth_card *card = dev_get_drvdata(dev);
52 return sprintf(buf, "%02X\n", card->info.chpid);
55 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
57 static ssize_t qeth_dev_if_name_show(struct device *dev,
58 struct device_attribute *attr, char *buf)
60 struct qeth_card *card = dev_get_drvdata(dev);
63 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
66 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
68 static ssize_t qeth_dev_card_type_show(struct device *dev,
69 struct device_attribute *attr, char *buf)
71 struct qeth_card *card = dev_get_drvdata(dev);
75 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
78 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
80 static inline const char *qeth_get_bufsize_str(struct qeth_card *card)
82 if (card->qdio.in_buf_size == 16384)
84 else if (card->qdio.in_buf_size == 24576)
86 else if (card->qdio.in_buf_size == 32768)
88 else if (card->qdio.in_buf_size == 40960)
94 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
95 struct device_attribute *attr, char *buf)
97 struct qeth_card *card = dev_get_drvdata(dev);
101 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
104 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
106 static ssize_t qeth_dev_portno_show(struct device *dev,
107 struct device_attribute *attr, char *buf)
109 struct qeth_card *card = dev_get_drvdata(dev);
113 return sprintf(buf, "%i\n", card->info.portno);
116 static ssize_t qeth_dev_portno_store(struct device *dev,
117 struct device_attribute *attr, const char *buf, size_t count)
119 struct qeth_card *card = dev_get_drvdata(dev);
126 if ((card->state != CARD_STATE_DOWN) &&
127 (card->state != CARD_STATE_RECOVER))
130 portno = simple_strtoul(buf, &tmp, 16);
131 if (portno > QETH_MAX_PORTNO) {
135 card->info.portno = portno;
139 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
141 static ssize_t qeth_dev_portname_show(struct device *dev,
142 struct device_attribute *attr, char *buf)
144 struct qeth_card *card = dev_get_drvdata(dev);
145 char portname[9] = {0, };
150 if (card->info.portname_required) {
151 memcpy(portname, card->info.portname + 1, 8);
153 return sprintf(buf, "%s\n", portname);
155 return sprintf(buf, "no portname required\n");
158 static ssize_t qeth_dev_portname_store(struct device *dev,
159 struct device_attribute *attr, const char *buf, size_t count)
161 struct qeth_card *card = dev_get_drvdata(dev);
168 if ((card->state != CARD_STATE_DOWN) &&
169 (card->state != CARD_STATE_RECOVER))
172 tmp = strsep((char **) &buf, "\n");
173 if ((strlen(tmp) > 8) || (strlen(tmp) == 0))
176 card->info.portname[0] = strlen(tmp);
177 /* for beauty reasons */
178 for (i = 1; i < 9; i++)
179 card->info.portname[i] = ' ';
180 strcpy(card->info.portname + 1, tmp);
181 ASCEBC(card->info.portname + 1, 8);
186 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
187 qeth_dev_portname_store);
189 static ssize_t qeth_dev_prioqing_show(struct device *dev,
190 struct device_attribute *attr, char *buf)
192 struct qeth_card *card = dev_get_drvdata(dev);
197 switch (card->qdio.do_prio_queueing) {
198 case QETH_PRIO_Q_ING_PREC:
199 return sprintf(buf, "%s\n", "by precedence");
200 case QETH_PRIO_Q_ING_TOS:
201 return sprintf(buf, "%s\n", "by type of service");
203 return sprintf(buf, "always queue %i\n",
204 card->qdio.default_out_queue);
208 static ssize_t qeth_dev_prioqing_store(struct device *dev,
209 struct device_attribute *attr, const char *buf, size_t count)
211 struct qeth_card *card = dev_get_drvdata(dev);
217 if ((card->state != CARD_STATE_DOWN) &&
218 (card->state != CARD_STATE_RECOVER))
221 /* check if 1920 devices are supported ,
222 * if though we have to permit priority queueing
224 if (card->qdio.no_out_queues == 1) {
225 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
229 tmp = strsep((char **) &buf, "\n");
230 if (!strcmp(tmp, "prio_queueing_prec"))
231 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
232 else if (!strcmp(tmp, "prio_queueing_tos"))
233 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
234 else if (!strcmp(tmp, "no_prio_queueing:0")) {
235 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
236 card->qdio.default_out_queue = 0;
237 } else if (!strcmp(tmp, "no_prio_queueing:1")) {
238 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
239 card->qdio.default_out_queue = 1;
240 } else if (!strcmp(tmp, "no_prio_queueing:2")) {
241 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
242 card->qdio.default_out_queue = 2;
243 } else if (!strcmp(tmp, "no_prio_queueing:3")) {
244 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
245 card->qdio.default_out_queue = 3;
246 } else if (!strcmp(tmp, "no_prio_queueing")) {
247 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
248 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
255 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
256 qeth_dev_prioqing_store);
258 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
259 struct device_attribute *attr, char *buf)
261 struct qeth_card *card = dev_get_drvdata(dev);
266 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
269 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
270 struct device_attribute *attr, const char *buf, size_t count)
272 struct qeth_card *card = dev_get_drvdata(dev);
280 if ((card->state != CARD_STATE_DOWN) &&
281 (card->state != CARD_STATE_RECOVER))
284 old_cnt = card->qdio.in_buf_pool.buf_count;
285 cnt = simple_strtoul(buf, &tmp, 10);
286 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
287 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
288 if (old_cnt != cnt) {
289 rc = qeth_realloc_buffer_pool(card, cnt);
294 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
295 qeth_dev_bufcnt_store);
297 static ssize_t qeth_dev_recover_store(struct device *dev,
298 struct device_attribute *attr, const char *buf, size_t count)
300 struct qeth_card *card = dev_get_drvdata(dev);
307 if (card->state != CARD_STATE_UP)
310 i = simple_strtoul(buf, &tmp, 16);
312 qeth_schedule_recovery(card);
317 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
319 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
320 struct device_attribute *attr, char *buf)
322 struct qeth_card *card = dev_get_drvdata(dev);
327 return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
330 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
331 struct device_attribute *attr, const char *buf, size_t count)
333 struct qeth_card *card = dev_get_drvdata(dev);
340 i = simple_strtoul(buf, &tmp, 16);
341 if ((i == 0) || (i == 1)) {
342 if (i == card->options.performance_stats)
344 card->options.performance_stats = i;
346 memset(&card->perf_stats, 0,
347 sizeof(struct qeth_perf_stats));
348 card->perf_stats.initial_rx_packets = card->stats.rx_packets;
349 card->perf_stats.initial_tx_packets = card->stats.tx_packets;
356 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
357 qeth_dev_performance_stats_store);
359 static ssize_t qeth_dev_layer2_show(struct device *dev,
360 struct device_attribute *attr, char *buf)
362 struct qeth_card *card = dev_get_drvdata(dev);
367 return sprintf(buf, "%i\n", card->options.layer2);
370 static ssize_t qeth_dev_layer2_store(struct device *dev,
371 struct device_attribute *attr, const char *buf, size_t count)
373 struct qeth_card *card = dev_get_drvdata(dev);
376 enum qeth_discipline_id newdis;
381 if (((card->state != CARD_STATE_DOWN) &&
382 (card->state != CARD_STATE_RECOVER)))
385 i = simple_strtoul(buf, &tmp, 16);
388 newdis = QETH_DISCIPLINE_LAYER3;
391 newdis = QETH_DISCIPLINE_LAYER2;
397 if (card->options.layer2 == newdis) {
400 if (card->discipline.ccwgdriver) {
401 card->discipline.ccwgdriver->remove(card->gdev);
402 qeth_core_free_discipline(card);
406 rc = qeth_core_load_discipline(card, newdis);
410 rc = card->discipline.ccwgdriver->probe(card->gdev);
416 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
417 qeth_dev_layer2_store);
419 #define ATTR_QETH_ISOLATION_NONE ("none")
420 #define ATTR_QETH_ISOLATION_FWD ("forward")
421 #define ATTR_QETH_ISOLATION_DROP ("drop")
423 static ssize_t qeth_dev_isolation_show(struct device *dev,
424 struct device_attribute *attr, char *buf)
426 struct qeth_card *card = dev_get_drvdata(dev);
431 switch (card->options.isolation) {
432 case ISOLATION_MODE_NONE:
433 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
434 case ISOLATION_MODE_FWD:
435 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
436 case ISOLATION_MODE_DROP:
437 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
439 return snprintf(buf, 5, "%s\n", "N/A");
443 static ssize_t qeth_dev_isolation_store(struct device *dev,
444 struct device_attribute *attr, const char *buf, size_t count)
446 struct qeth_card *card = dev_get_drvdata(dev);
447 enum qeth_ipa_isolation_modes isolation;
449 char *tmp, *curtoken;
450 curtoken = (char *) buf;
457 /* check for unknown, too, in case we do not yet know who we are */
458 if (card->info.type != QETH_CARD_TYPE_OSAE &&
459 card->info.type != QETH_CARD_TYPE_UNKNOWN) {
461 dev_err(&card->gdev->dev, "Adapter does not "
462 "support QDIO data connection isolation\n");
466 /* parse input into isolation mode */
467 tmp = strsep(&curtoken, "\n");
468 if (!strcmp(tmp, ATTR_QETH_ISOLATION_NONE)) {
469 isolation = ISOLATION_MODE_NONE;
470 } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_FWD)) {
471 isolation = ISOLATION_MODE_FWD;
472 } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_DROP)) {
473 isolation = ISOLATION_MODE_DROP;
480 /* defer IP assist if device is offline (until discipline->set_online)*/
481 card->options.isolation = isolation;
482 if (card->state == CARD_STATE_SOFTSETUP ||
483 card->state == CARD_STATE_UP) {
484 int ipa_rc = qeth_set_access_ctrl_online(card);
492 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
493 qeth_dev_isolation_store);
495 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
501 return sprintf(buf, "%i\n", value);
504 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
505 const char *buf, size_t count, int *value, int max_value)
513 if ((card->state != CARD_STATE_DOWN) &&
514 (card->state != CARD_STATE_RECOVER))
517 i = simple_strtoul(buf, &tmp, 10);
518 if (i <= max_value) {
526 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
527 struct device_attribute *attr, char *buf)
529 struct qeth_card *card = dev_get_drvdata(dev);
531 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
534 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
535 struct device_attribute *attr, const char *buf, size_t count)
537 struct qeth_card *card = dev_get_drvdata(dev);
539 return qeth_dev_blkt_store(card, buf, count,
540 &card->info.blkt.time_total, 1000);
545 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
546 qeth_dev_blkt_total_store);
548 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
549 struct device_attribute *attr, char *buf)
551 struct qeth_card *card = dev_get_drvdata(dev);
553 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
556 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
557 struct device_attribute *attr, const char *buf, size_t count)
559 struct qeth_card *card = dev_get_drvdata(dev);
561 return qeth_dev_blkt_store(card, buf, count,
562 &card->info.blkt.inter_packet, 100);
565 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
566 qeth_dev_blkt_inter_store);
568 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
569 struct device_attribute *attr, char *buf)
571 struct qeth_card *card = dev_get_drvdata(dev);
573 return qeth_dev_blkt_show(buf, card,
574 card->info.blkt.inter_packet_jumbo);
577 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
578 struct device_attribute *attr, const char *buf, size_t count)
580 struct qeth_card *card = dev_get_drvdata(dev);
582 return qeth_dev_blkt_store(card, buf, count,
583 &card->info.blkt.inter_packet_jumbo, 100);
586 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
587 qeth_dev_blkt_inter_jumbo_store);
589 static struct attribute *qeth_blkt_device_attrs[] = {
590 &dev_attr_total.attr,
591 &dev_attr_inter.attr,
592 &dev_attr_inter_jumbo.attr,
596 static struct attribute_group qeth_device_blkt_group = {
598 .attrs = qeth_blkt_device_attrs,
601 static struct attribute *qeth_device_attrs[] = {
602 &dev_attr_state.attr,
603 &dev_attr_chpid.attr,
604 &dev_attr_if_name.attr,
605 &dev_attr_card_type.attr,
606 &dev_attr_inbuf_size.attr,
607 &dev_attr_portno.attr,
608 &dev_attr_portname.attr,
609 &dev_attr_priority_queueing.attr,
610 &dev_attr_buffer_count.attr,
611 &dev_attr_recover.attr,
612 &dev_attr_performance_stats.attr,
613 &dev_attr_layer2.attr,
614 &dev_attr_isolation.attr,
618 static struct attribute_group qeth_device_attr_group = {
619 .attrs = qeth_device_attrs,
622 static struct attribute *qeth_osn_device_attrs[] = {
623 &dev_attr_state.attr,
624 &dev_attr_chpid.attr,
625 &dev_attr_if_name.attr,
626 &dev_attr_card_type.attr,
627 &dev_attr_buffer_count.attr,
628 &dev_attr_recover.attr,
632 static struct attribute_group qeth_osn_device_attr_group = {
633 .attrs = qeth_osn_device_attrs,
636 int qeth_core_create_device_attributes(struct device *dev)
639 ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group);
642 ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group);
644 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
649 void qeth_core_remove_device_attributes(struct device *dev)
651 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
652 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group);
655 int qeth_core_create_osn_attributes(struct device *dev)
657 return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group);
660 void qeth_core_remove_osn_attributes(struct device *dev)
662 sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group);