1 /* 2 * drivers/s390/net/qeth_core_sys.c 3 * 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> 9 */ 10 11 #include <linux/list.h> 12 #include <linux/rwsem.h> 13 #include <asm/ebcdic.h> 14 15 #include "qeth_core.h" 16 17 static ssize_t qeth_dev_state_show(struct device *dev, 18 struct device_attribute *attr, char *buf) 19 { 20 struct qeth_card *card = dev_get_drvdata(dev); 21 if (!card) 22 return -EINVAL; 23 24 switch (card->state) { 25 case CARD_STATE_DOWN: 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"); 31 case CARD_STATE_UP: 32 if (card->lan_online) 33 return sprintf(buf, "UP (LAN ONLINE)\n"); 34 else 35 return sprintf(buf, "UP (LAN OFFLINE)\n"); 36 case CARD_STATE_RECOVER: 37 return sprintf(buf, "RECOVER\n"); 38 default: 39 return sprintf(buf, "UNKNOWN\n"); 40 } 41 } 42 43 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL); 44 45 static ssize_t qeth_dev_chpid_show(struct device *dev, 46 struct device_attribute *attr, char *buf) 47 { 48 struct qeth_card *card = dev_get_drvdata(dev); 49 if (!card) 50 return -EINVAL; 51 52 return sprintf(buf, "%02X\n", card->info.chpid); 53 } 54 55 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL); 56 57 static ssize_t qeth_dev_if_name_show(struct device *dev, 58 struct device_attribute *attr, char *buf) 59 { 60 struct qeth_card *card = dev_get_drvdata(dev); 61 if (!card) 62 return -EINVAL; 63 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card)); 64 } 65 66 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL); 67 68 static ssize_t qeth_dev_card_type_show(struct device *dev, 69 struct device_attribute *attr, char *buf) 70 { 71 struct qeth_card *card = dev_get_drvdata(dev); 72 if (!card) 73 return -EINVAL; 74 75 return sprintf(buf, "%s\n", qeth_get_cardname_short(card)); 76 } 77 78 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL); 79 80 static inline const char *qeth_get_bufsize_str(struct qeth_card *card) 81 { 82 if (card->qdio.in_buf_size == 16384) 83 return "16k"; 84 else if (card->qdio.in_buf_size == 24576) 85 return "24k"; 86 else if (card->qdio.in_buf_size == 32768) 87 return "32k"; 88 else if (card->qdio.in_buf_size == 40960) 89 return "40k"; 90 else 91 return "64k"; 92 } 93 94 static ssize_t qeth_dev_inbuf_size_show(struct device *dev, 95 struct device_attribute *attr, char *buf) 96 { 97 struct qeth_card *card = dev_get_drvdata(dev); 98 if (!card) 99 return -EINVAL; 100 101 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card)); 102 } 103 104 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL); 105 106 static ssize_t qeth_dev_portno_show(struct device *dev, 107 struct device_attribute *attr, char *buf) 108 { 109 struct qeth_card *card = dev_get_drvdata(dev); 110 if (!card) 111 return -EINVAL; 112 113 return sprintf(buf, "%i\n", card->info.portno); 114 } 115 116 static ssize_t qeth_dev_portno_store(struct device *dev, 117 struct device_attribute *attr, const char *buf, size_t count) 118 { 119 struct qeth_card *card = dev_get_drvdata(dev); 120 char *tmp; 121 unsigned int portno; 122 123 if (!card) 124 return -EINVAL; 125 126 if ((card->state != CARD_STATE_DOWN) && 127 (card->state != CARD_STATE_RECOVER)) 128 return -EPERM; 129 130 portno = simple_strtoul(buf, &tmp, 16); 131 if (portno > QETH_MAX_PORTNO) { 132 return -EINVAL; 133 } 134 135 card->info.portno = portno; 136 return count; 137 } 138 139 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store); 140 141 static ssize_t qeth_dev_portname_show(struct device *dev, 142 struct device_attribute *attr, char *buf) 143 { 144 struct qeth_card *card = dev_get_drvdata(dev); 145 char portname[9] = {0, }; 146 147 if (!card) 148 return -EINVAL; 149 150 if (card->info.portname_required) { 151 memcpy(portname, card->info.portname + 1, 8); 152 EBCASC(portname, 8); 153 return sprintf(buf, "%s\n", portname); 154 } else 155 return sprintf(buf, "no portname required\n"); 156 } 157 158 static ssize_t qeth_dev_portname_store(struct device *dev, 159 struct device_attribute *attr, const char *buf, size_t count) 160 { 161 struct qeth_card *card = dev_get_drvdata(dev); 162 char *tmp; 163 int i; 164 165 if (!card) 166 return -EINVAL; 167 168 if ((card->state != CARD_STATE_DOWN) && 169 (card->state != CARD_STATE_RECOVER)) 170 return -EPERM; 171 172 tmp = strsep((char **) &buf, "\n"); 173 if ((strlen(tmp) > 8) || (strlen(tmp) == 0)) 174 return -EINVAL; 175 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); 182 183 return count; 184 } 185 186 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show, 187 qeth_dev_portname_store); 188 189 static ssize_t qeth_dev_prioqing_show(struct device *dev, 190 struct device_attribute *attr, char *buf) 191 { 192 struct qeth_card *card = dev_get_drvdata(dev); 193 194 if (!card) 195 return -EINVAL; 196 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"); 202 default: 203 return sprintf(buf, "always queue %i\n", 204 card->qdio.default_out_queue); 205 } 206 } 207 208 static ssize_t qeth_dev_prioqing_store(struct device *dev, 209 struct device_attribute *attr, const char *buf, size_t count) 210 { 211 struct qeth_card *card = dev_get_drvdata(dev); 212 char *tmp; 213 214 if (!card) 215 return -EINVAL; 216 217 if ((card->state != CARD_STATE_DOWN) && 218 (card->state != CARD_STATE_RECOVER)) 219 return -EPERM; 220 221 /* check if 1920 devices are supported , 222 * if though we have to permit priority queueing 223 */ 224 if (card->qdio.no_out_queues == 1) { 225 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT; 226 return -EPERM; 227 } 228 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; 249 } else { 250 return -EINVAL; 251 } 252 return count; 253 } 254 255 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show, 256 qeth_dev_prioqing_store); 257 258 static ssize_t qeth_dev_bufcnt_show(struct device *dev, 259 struct device_attribute *attr, char *buf) 260 { 261 struct qeth_card *card = dev_get_drvdata(dev); 262 263 if (!card) 264 return -EINVAL; 265 266 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count); 267 } 268 269 static ssize_t qeth_dev_bufcnt_store(struct device *dev, 270 struct device_attribute *attr, const char *buf, size_t count) 271 { 272 struct qeth_card *card = dev_get_drvdata(dev); 273 char *tmp; 274 int cnt, old_cnt; 275 int rc; 276 277 if (!card) 278 return -EINVAL; 279 280 if ((card->state != CARD_STATE_DOWN) && 281 (card->state != CARD_STATE_RECOVER)) 282 return -EPERM; 283 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); 290 } 291 return count; 292 } 293 294 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show, 295 qeth_dev_bufcnt_store); 296 297 static ssize_t qeth_dev_recover_store(struct device *dev, 298 struct device_attribute *attr, const char *buf, size_t count) 299 { 300 struct qeth_card *card = dev_get_drvdata(dev); 301 char *tmp; 302 int i; 303 304 if (!card) 305 return -EINVAL; 306 307 if (card->state != CARD_STATE_UP) 308 return -EPERM; 309 310 i = simple_strtoul(buf, &tmp, 16); 311 if (i == 1) 312 qeth_schedule_recovery(card); 313 314 return count; 315 } 316 317 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store); 318 319 static ssize_t qeth_dev_performance_stats_show(struct device *dev, 320 struct device_attribute *attr, char *buf) 321 { 322 struct qeth_card *card = dev_get_drvdata(dev); 323 324 if (!card) 325 return -EINVAL; 326 327 return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0); 328 } 329 330 static ssize_t qeth_dev_performance_stats_store(struct device *dev, 331 struct device_attribute *attr, const char *buf, size_t count) 332 { 333 struct qeth_card *card = dev_get_drvdata(dev); 334 char *tmp; 335 int i; 336 337 if (!card) 338 return -EINVAL; 339 340 i = simple_strtoul(buf, &tmp, 16); 341 if ((i == 0) || (i == 1)) { 342 if (i == card->options.performance_stats) 343 return count; 344 card->options.performance_stats = i; 345 if (i == 0) 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; 350 } else { 351 return -EINVAL; 352 } 353 return count; 354 } 355 356 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show, 357 qeth_dev_performance_stats_store); 358 359 static ssize_t qeth_dev_layer2_show(struct device *dev, 360 struct device_attribute *attr, char *buf) 361 { 362 struct qeth_card *card = dev_get_drvdata(dev); 363 364 if (!card) 365 return -EINVAL; 366 367 return sprintf(buf, "%i\n", card->options.layer2); 368 } 369 370 static ssize_t qeth_dev_layer2_store(struct device *dev, 371 struct device_attribute *attr, const char *buf, size_t count) 372 { 373 struct qeth_card *card = dev_get_drvdata(dev); 374 char *tmp; 375 int i, rc; 376 enum qeth_discipline_id newdis; 377 378 if (!card) 379 return -EINVAL; 380 381 if (((card->state != CARD_STATE_DOWN) && 382 (card->state != CARD_STATE_RECOVER))) 383 return -EPERM; 384 385 i = simple_strtoul(buf, &tmp, 16); 386 switch (i) { 387 case 0: 388 newdis = QETH_DISCIPLINE_LAYER3; 389 break; 390 case 1: 391 newdis = QETH_DISCIPLINE_LAYER2; 392 break; 393 default: 394 return -EINVAL; 395 } 396 397 if (card->options.layer2 == newdis) { 398 return count; 399 } else { 400 if (card->discipline.ccwgdriver) { 401 card->discipline.ccwgdriver->remove(card->gdev); 402 qeth_core_free_discipline(card); 403 } 404 } 405 406 rc = qeth_core_load_discipline(card, newdis); 407 if (rc) 408 return rc; 409 410 rc = card->discipline.ccwgdriver->probe(card->gdev); 411 if (rc) 412 return rc; 413 return count; 414 } 415 416 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show, 417 qeth_dev_layer2_store); 418 419 #define ATTR_QETH_ISOLATION_NONE ("none") 420 #define ATTR_QETH_ISOLATION_FWD ("forward") 421 #define ATTR_QETH_ISOLATION_DROP ("drop") 422 423 static ssize_t qeth_dev_isolation_show(struct device *dev, 424 struct device_attribute *attr, char *buf) 425 { 426 struct qeth_card *card = dev_get_drvdata(dev); 427 428 if (!card) 429 return -EINVAL; 430 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); 438 default: 439 return snprintf(buf, 5, "%s\n", "N/A"); 440 } 441 } 442 443 static ssize_t qeth_dev_isolation_store(struct device *dev, 444 struct device_attribute *attr, const char *buf, size_t count) 445 { 446 struct qeth_card *card = dev_get_drvdata(dev); 447 enum qeth_ipa_isolation_modes isolation; 448 int rc = 0; 449 char *tmp, *curtoken; 450 curtoken = (char *) buf; 451 452 if (!card) { 453 rc = -EINVAL; 454 goto out; 455 } 456 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) { 460 rc = -EOPNOTSUPP; 461 dev_err(&card->gdev->dev, "Adapter does not " 462 "support QDIO data connection isolation\n"); 463 goto out; 464 } 465 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; 474 } else { 475 rc = -EINVAL; 476 goto out; 477 } 478 rc = count; 479 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); 485 if (ipa_rc != 0) 486 rc = ipa_rc; 487 } 488 out: 489 return rc; 490 } 491 492 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show, 493 qeth_dev_isolation_store); 494 495 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value) 496 { 497 498 if (!card) 499 return -EINVAL; 500 501 return sprintf(buf, "%i\n", value); 502 } 503 504 static ssize_t qeth_dev_blkt_store(struct qeth_card *card, 505 const char *buf, size_t count, int *value, int max_value) 506 { 507 char *tmp; 508 int i; 509 510 if (!card) 511 return -EINVAL; 512 513 if ((card->state != CARD_STATE_DOWN) && 514 (card->state != CARD_STATE_RECOVER)) 515 return -EPERM; 516 517 i = simple_strtoul(buf, &tmp, 10); 518 if (i <= max_value) { 519 *value = i; 520 } else { 521 return -EINVAL; 522 } 523 return count; 524 } 525 526 static ssize_t qeth_dev_blkt_total_show(struct device *dev, 527 struct device_attribute *attr, char *buf) 528 { 529 struct qeth_card *card = dev_get_drvdata(dev); 530 531 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total); 532 } 533 534 static ssize_t qeth_dev_blkt_total_store(struct device *dev, 535 struct device_attribute *attr, const char *buf, size_t count) 536 { 537 struct qeth_card *card = dev_get_drvdata(dev); 538 539 return qeth_dev_blkt_store(card, buf, count, 540 &card->info.blkt.time_total, 1000); 541 } 542 543 544 545 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show, 546 qeth_dev_blkt_total_store); 547 548 static ssize_t qeth_dev_blkt_inter_show(struct device *dev, 549 struct device_attribute *attr, char *buf) 550 { 551 struct qeth_card *card = dev_get_drvdata(dev); 552 553 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet); 554 } 555 556 static ssize_t qeth_dev_blkt_inter_store(struct device *dev, 557 struct device_attribute *attr, const char *buf, size_t count) 558 { 559 struct qeth_card *card = dev_get_drvdata(dev); 560 561 return qeth_dev_blkt_store(card, buf, count, 562 &card->info.blkt.inter_packet, 100); 563 } 564 565 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show, 566 qeth_dev_blkt_inter_store); 567 568 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev, 569 struct device_attribute *attr, char *buf) 570 { 571 struct qeth_card *card = dev_get_drvdata(dev); 572 573 return qeth_dev_blkt_show(buf, card, 574 card->info.blkt.inter_packet_jumbo); 575 } 576 577 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev, 578 struct device_attribute *attr, const char *buf, size_t count) 579 { 580 struct qeth_card *card = dev_get_drvdata(dev); 581 582 return qeth_dev_blkt_store(card, buf, count, 583 &card->info.blkt.inter_packet_jumbo, 100); 584 } 585 586 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show, 587 qeth_dev_blkt_inter_jumbo_store); 588 589 static struct attribute *qeth_blkt_device_attrs[] = { 590 &dev_attr_total.attr, 591 &dev_attr_inter.attr, 592 &dev_attr_inter_jumbo.attr, 593 NULL, 594 }; 595 596 static struct attribute_group qeth_device_blkt_group = { 597 .name = "blkt", 598 .attrs = qeth_blkt_device_attrs, 599 }; 600 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, 615 NULL, 616 }; 617 618 static struct attribute_group qeth_device_attr_group = { 619 .attrs = qeth_device_attrs, 620 }; 621 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, 629 NULL, 630 }; 631 632 static struct attribute_group qeth_osn_device_attr_group = { 633 .attrs = qeth_osn_device_attrs, 634 }; 635 636 int qeth_core_create_device_attributes(struct device *dev) 637 { 638 int ret; 639 ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group); 640 if (ret) 641 return ret; 642 ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group); 643 if (ret) 644 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 645 646 return 0; 647 } 648 649 void qeth_core_remove_device_attributes(struct device *dev) 650 { 651 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 652 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group); 653 } 654 655 int qeth_core_create_osn_attributes(struct device *dev) 656 { 657 return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group); 658 } 659 660 void qeth_core_remove_osn_attributes(struct device *dev) 661 { 662 sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group); 663 return; 664 } 665