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 ? 1:0); 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 static ssize_t qeth_dev_large_send_show(struct device *dev, 420 struct device_attribute *attr, char *buf) 421 { 422 struct qeth_card *card = dev_get_drvdata(dev); 423 424 if (!card) 425 return -EINVAL; 426 427 switch (card->options.large_send) { 428 case QETH_LARGE_SEND_NO: 429 return sprintf(buf, "%s\n", "no"); 430 case QETH_LARGE_SEND_EDDP: 431 return sprintf(buf, "%s\n", "EDDP"); 432 case QETH_LARGE_SEND_TSO: 433 return sprintf(buf, "%s\n", "TSO"); 434 default: 435 return sprintf(buf, "%s\n", "N/A"); 436 } 437 } 438 439 static ssize_t qeth_dev_large_send_store(struct device *dev, 440 struct device_attribute *attr, const char *buf, size_t count) 441 { 442 struct qeth_card *card = dev_get_drvdata(dev); 443 enum qeth_large_send_types type; 444 int rc = 0; 445 char *tmp; 446 447 if (!card) 448 return -EINVAL; 449 tmp = strsep((char **) &buf, "\n"); 450 if (!strcmp(tmp, "no")) { 451 type = QETH_LARGE_SEND_NO; 452 } else if (!strcmp(tmp, "EDDP")) { 453 type = QETH_LARGE_SEND_EDDP; 454 } else if (!strcmp(tmp, "TSO")) { 455 type = QETH_LARGE_SEND_TSO; 456 } else { 457 return -EINVAL; 458 } 459 if (card->options.large_send == type) 460 return count; 461 rc = qeth_set_large_send(card, type); 462 if (rc) 463 return rc; 464 return count; 465 } 466 467 static DEVICE_ATTR(large_send, 0644, qeth_dev_large_send_show, 468 qeth_dev_large_send_store); 469 470 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value) 471 { 472 473 if (!card) 474 return -EINVAL; 475 476 return sprintf(buf, "%i\n", value); 477 } 478 479 static ssize_t qeth_dev_blkt_store(struct qeth_card *card, 480 const char *buf, size_t count, int *value, int max_value) 481 { 482 char *tmp; 483 int i; 484 485 if (!card) 486 return -EINVAL; 487 488 if ((card->state != CARD_STATE_DOWN) && 489 (card->state != CARD_STATE_RECOVER)) 490 return -EPERM; 491 492 i = simple_strtoul(buf, &tmp, 10); 493 if (i <= max_value) { 494 *value = i; 495 } else { 496 return -EINVAL; 497 } 498 return count; 499 } 500 501 static ssize_t qeth_dev_blkt_total_show(struct device *dev, 502 struct device_attribute *attr, char *buf) 503 { 504 struct qeth_card *card = dev_get_drvdata(dev); 505 506 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total); 507 } 508 509 static ssize_t qeth_dev_blkt_total_store(struct device *dev, 510 struct device_attribute *attr, const char *buf, size_t count) 511 { 512 struct qeth_card *card = dev_get_drvdata(dev); 513 514 return qeth_dev_blkt_store(card, buf, count, 515 &card->info.blkt.time_total, 1000); 516 } 517 518 519 520 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show, 521 qeth_dev_blkt_total_store); 522 523 static ssize_t qeth_dev_blkt_inter_show(struct device *dev, 524 struct device_attribute *attr, char *buf) 525 { 526 struct qeth_card *card = dev_get_drvdata(dev); 527 528 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet); 529 } 530 531 static ssize_t qeth_dev_blkt_inter_store(struct device *dev, 532 struct device_attribute *attr, const char *buf, size_t count) 533 { 534 struct qeth_card *card = dev_get_drvdata(dev); 535 536 return qeth_dev_blkt_store(card, buf, count, 537 &card->info.blkt.inter_packet, 100); 538 } 539 540 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show, 541 qeth_dev_blkt_inter_store); 542 543 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev, 544 struct device_attribute *attr, char *buf) 545 { 546 struct qeth_card *card = dev_get_drvdata(dev); 547 548 return qeth_dev_blkt_show(buf, card, 549 card->info.blkt.inter_packet_jumbo); 550 } 551 552 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev, 553 struct device_attribute *attr, const char *buf, size_t count) 554 { 555 struct qeth_card *card = dev_get_drvdata(dev); 556 557 return qeth_dev_blkt_store(card, buf, count, 558 &card->info.blkt.inter_packet_jumbo, 100); 559 } 560 561 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show, 562 qeth_dev_blkt_inter_jumbo_store); 563 564 static struct attribute *qeth_blkt_device_attrs[] = { 565 &dev_attr_total.attr, 566 &dev_attr_inter.attr, 567 &dev_attr_inter_jumbo.attr, 568 NULL, 569 }; 570 571 static struct attribute_group qeth_device_blkt_group = { 572 .name = "blkt", 573 .attrs = qeth_blkt_device_attrs, 574 }; 575 576 static struct attribute *qeth_device_attrs[] = { 577 &dev_attr_state.attr, 578 &dev_attr_chpid.attr, 579 &dev_attr_if_name.attr, 580 &dev_attr_card_type.attr, 581 &dev_attr_inbuf_size.attr, 582 &dev_attr_portno.attr, 583 &dev_attr_portname.attr, 584 &dev_attr_priority_queueing.attr, 585 &dev_attr_buffer_count.attr, 586 &dev_attr_recover.attr, 587 &dev_attr_performance_stats.attr, 588 &dev_attr_layer2.attr, 589 &dev_attr_large_send.attr, 590 NULL, 591 }; 592 593 static struct attribute_group qeth_device_attr_group = { 594 .attrs = qeth_device_attrs, 595 }; 596 597 static struct attribute *qeth_osn_device_attrs[] = { 598 &dev_attr_state.attr, 599 &dev_attr_chpid.attr, 600 &dev_attr_if_name.attr, 601 &dev_attr_card_type.attr, 602 &dev_attr_buffer_count.attr, 603 &dev_attr_recover.attr, 604 NULL, 605 }; 606 607 static struct attribute_group qeth_osn_device_attr_group = { 608 .attrs = qeth_osn_device_attrs, 609 }; 610 611 int qeth_core_create_device_attributes(struct device *dev) 612 { 613 int ret; 614 ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group); 615 if (ret) 616 return ret; 617 ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group); 618 if (ret) 619 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 620 621 return 0; 622 } 623 624 void qeth_core_remove_device_attributes(struct device *dev) 625 { 626 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 627 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group); 628 } 629 630 int qeth_core_create_osn_attributes(struct device *dev) 631 { 632 return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group); 633 } 634 635 void qeth_core_remove_osn_attributes(struct device *dev) 636 { 637 sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group); 638 return; 639 } 640