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