1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2007 4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 5 * Frank Pavlic <fpavlic@de.ibm.com>, 6 * Thomas Spatzier <tspat@de.ibm.com>, 7 * Frank Blaschka <frank.blaschka@de.ibm.com> 8 */ 9 10 #define KMSG_COMPONENT "qeth" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/list.h> 14 #include <linux/rwsem.h> 15 #include <asm/ebcdic.h> 16 17 #include "qeth_core.h" 18 19 static ssize_t qeth_dev_state_show(struct device *dev, 20 struct device_attribute *attr, char *buf) 21 { 22 struct qeth_card *card = dev_get_drvdata(dev); 23 if (!card) 24 return -EINVAL; 25 26 switch (card->state) { 27 case CARD_STATE_DOWN: 28 return sprintf(buf, "DOWN\n"); 29 case CARD_STATE_HARDSETUP: 30 return sprintf(buf, "HARDSETUP\n"); 31 case CARD_STATE_SOFTSETUP: 32 if (card->dev->flags & IFF_UP) 33 return sprintf(buf, "UP (LAN %s)\n", 34 netif_carrier_ok(card->dev) ? "ONLINE" : 35 "OFFLINE"); 36 return sprintf(buf, "SOFTSETUP\n"); 37 default: 38 return sprintf(buf, "UNKNOWN\n"); 39 } 40 } 41 42 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL); 43 44 static ssize_t qeth_dev_chpid_show(struct device *dev, 45 struct device_attribute *attr, char *buf) 46 { 47 struct qeth_card *card = dev_get_drvdata(dev); 48 if (!card) 49 return -EINVAL; 50 51 return sprintf(buf, "%02X\n", card->info.chpid); 52 } 53 54 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL); 55 56 static ssize_t qeth_dev_if_name_show(struct device *dev, 57 struct device_attribute *attr, char *buf) 58 { 59 struct qeth_card *card = dev_get_drvdata(dev); 60 if (!card) 61 return -EINVAL; 62 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card)); 63 } 64 65 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL); 66 67 static ssize_t qeth_dev_card_type_show(struct device *dev, 68 struct device_attribute *attr, char *buf) 69 { 70 struct qeth_card *card = dev_get_drvdata(dev); 71 if (!card) 72 return -EINVAL; 73 74 return sprintf(buf, "%s\n", qeth_get_cardname_short(card)); 75 } 76 77 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL); 78 79 static const char *qeth_get_bufsize_str(struct qeth_card *card) 80 { 81 if (card->qdio.in_buf_size == 16384) 82 return "16k"; 83 else if (card->qdio.in_buf_size == 24576) 84 return "24k"; 85 else if (card->qdio.in_buf_size == 32768) 86 return "32k"; 87 else if (card->qdio.in_buf_size == 40960) 88 return "40k"; 89 else 90 return "64k"; 91 } 92 93 static ssize_t qeth_dev_inbuf_size_show(struct device *dev, 94 struct device_attribute *attr, char *buf) 95 { 96 struct qeth_card *card = dev_get_drvdata(dev); 97 if (!card) 98 return -EINVAL; 99 100 return sprintf(buf, "%s\n", qeth_get_bufsize_str(card)); 101 } 102 103 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL); 104 105 static ssize_t qeth_dev_portno_show(struct device *dev, 106 struct device_attribute *attr, char *buf) 107 { 108 struct qeth_card *card = dev_get_drvdata(dev); 109 if (!card) 110 return -EINVAL; 111 112 return sprintf(buf, "%i\n", card->dev->dev_port); 113 } 114 115 static ssize_t qeth_dev_portno_store(struct device *dev, 116 struct device_attribute *attr, const char *buf, size_t count) 117 { 118 struct qeth_card *card = dev_get_drvdata(dev); 119 char *tmp; 120 unsigned int portno, limit; 121 int rc = 0; 122 123 if (!card) 124 return -EINVAL; 125 126 mutex_lock(&card->conf_mutex); 127 if (card->state != CARD_STATE_DOWN) { 128 rc = -EPERM; 129 goto out; 130 } 131 132 portno = simple_strtoul(buf, &tmp, 16); 133 if (portno > QETH_MAX_PORTNO) { 134 rc = -EINVAL; 135 goto out; 136 } 137 limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt); 138 if (portno > limit) { 139 rc = -EINVAL; 140 goto out; 141 } 142 card->dev->dev_port = portno; 143 out: 144 mutex_unlock(&card->conf_mutex); 145 return rc ? rc : count; 146 } 147 148 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store); 149 150 static ssize_t qeth_dev_portname_show(struct device *dev, 151 struct device_attribute *attr, char *buf) 152 { 153 return sprintf(buf, "no portname required\n"); 154 } 155 156 static ssize_t qeth_dev_portname_store(struct device *dev, 157 struct device_attribute *attr, const char *buf, size_t count) 158 { 159 struct qeth_card *card = dev_get_drvdata(dev); 160 161 dev_warn_once(&card->gdev->dev, 162 "portname is deprecated and is ignored\n"); 163 return count; 164 } 165 166 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show, 167 qeth_dev_portname_store); 168 169 static ssize_t qeth_dev_prioqing_show(struct device *dev, 170 struct device_attribute *attr, char *buf) 171 { 172 struct qeth_card *card = dev_get_drvdata(dev); 173 174 if (!card) 175 return -EINVAL; 176 177 switch (card->qdio.do_prio_queueing) { 178 case QETH_PRIO_Q_ING_PREC: 179 return sprintf(buf, "%s\n", "by precedence"); 180 case QETH_PRIO_Q_ING_TOS: 181 return sprintf(buf, "%s\n", "by type of service"); 182 case QETH_PRIO_Q_ING_SKB: 183 return sprintf(buf, "%s\n", "by skb-priority"); 184 case QETH_PRIO_Q_ING_VLAN: 185 return sprintf(buf, "%s\n", "by VLAN headers"); 186 default: 187 return sprintf(buf, "always queue %i\n", 188 card->qdio.default_out_queue); 189 } 190 } 191 192 static ssize_t qeth_dev_prioqing_store(struct device *dev, 193 struct device_attribute *attr, const char *buf, size_t count) 194 { 195 struct qeth_card *card = dev_get_drvdata(dev); 196 int rc = 0; 197 198 if (!card) 199 return -EINVAL; 200 201 if (IS_IQD(card)) 202 return -EOPNOTSUPP; 203 204 mutex_lock(&card->conf_mutex); 205 if (card->state != CARD_STATE_DOWN) { 206 rc = -EPERM; 207 goto out; 208 } 209 210 /* check if 1920 devices are supported , 211 * if though we have to permit priority queueing 212 */ 213 if (card->qdio.no_out_queues == 1) { 214 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT; 215 rc = -EPERM; 216 goto out; 217 } 218 219 if (sysfs_streq(buf, "prio_queueing_prec")) { 220 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC; 221 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 222 } else if (sysfs_streq(buf, "prio_queueing_skb")) { 223 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB; 224 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 225 } else if (sysfs_streq(buf, "prio_queueing_tos")) { 226 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS; 227 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 228 } else if (sysfs_streq(buf, "prio_queueing_vlan")) { 229 if (IS_LAYER3(card)) { 230 rc = -ENOTSUPP; 231 goto out; 232 } 233 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN; 234 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 235 } else if (sysfs_streq(buf, "no_prio_queueing:0")) { 236 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING; 237 card->qdio.default_out_queue = 0; 238 } else if (sysfs_streq(buf, "no_prio_queueing:1")) { 239 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING; 240 card->qdio.default_out_queue = 1; 241 } else if (sysfs_streq(buf, "no_prio_queueing:2")) { 242 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING; 243 card->qdio.default_out_queue = 2; 244 } else if (sysfs_streq(buf, "no_prio_queueing:3")) { 245 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING; 246 card->qdio.default_out_queue = 3; 247 } else if (sysfs_streq(buf, "no_prio_queueing")) { 248 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING; 249 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 250 } else 251 rc = -EINVAL; 252 out: 253 mutex_unlock(&card->conf_mutex); 254 return rc ? rc : count; 255 } 256 257 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show, 258 qeth_dev_prioqing_store); 259 260 static ssize_t qeth_dev_bufcnt_show(struct device *dev, 261 struct device_attribute *attr, char *buf) 262 { 263 struct qeth_card *card = dev_get_drvdata(dev); 264 265 if (!card) 266 return -EINVAL; 267 268 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count); 269 } 270 271 static ssize_t qeth_dev_bufcnt_store(struct device *dev, 272 struct device_attribute *attr, const char *buf, size_t count) 273 { 274 struct qeth_card *card = dev_get_drvdata(dev); 275 char *tmp; 276 int cnt, old_cnt; 277 int rc = 0; 278 279 if (!card) 280 return -EINVAL; 281 282 mutex_lock(&card->conf_mutex); 283 if (card->state != CARD_STATE_DOWN) { 284 rc = -EPERM; 285 goto out; 286 } 287 288 old_cnt = card->qdio.in_buf_pool.buf_count; 289 cnt = simple_strtoul(buf, &tmp, 10); 290 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN : 291 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt); 292 if (old_cnt != cnt) { 293 rc = qeth_realloc_buffer_pool(card, cnt); 294 } 295 out: 296 mutex_unlock(&card->conf_mutex); 297 return rc ? rc : count; 298 } 299 300 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show, 301 qeth_dev_bufcnt_store); 302 303 static ssize_t qeth_dev_recover_store(struct device *dev, 304 struct device_attribute *attr, const char *buf, size_t count) 305 { 306 struct qeth_card *card = dev_get_drvdata(dev); 307 char *tmp; 308 int i; 309 310 if (!card) 311 return -EINVAL; 312 313 if (!qeth_card_hw_is_reachable(card)) 314 return -EPERM; 315 316 i = simple_strtoul(buf, &tmp, 16); 317 if (i == 1) 318 qeth_schedule_recovery(card); 319 320 return count; 321 } 322 323 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store); 324 325 static ssize_t qeth_dev_performance_stats_show(struct device *dev, 326 struct device_attribute *attr, char *buf) 327 { 328 struct qeth_card *card = dev_get_drvdata(dev); 329 330 if (!card) 331 return -EINVAL; 332 333 return sprintf(buf, "1\n"); 334 } 335 336 static ssize_t qeth_dev_performance_stats_store(struct device *dev, 337 struct device_attribute *attr, const char *buf, size_t count) 338 { 339 struct qeth_card *card = dev_get_drvdata(dev); 340 struct qeth_qdio_out_q *queue; 341 unsigned int i; 342 bool reset; 343 int rc; 344 345 if (!card) 346 return -EINVAL; 347 348 rc = kstrtobool(buf, &reset); 349 if (rc) 350 return rc; 351 352 if (reset) { 353 memset(&card->stats, 0, sizeof(card->stats)); 354 for (i = 0; i < card->qdio.no_out_queues; i++) { 355 queue = card->qdio.out_qs[i]; 356 if (!queue) 357 break; 358 memset(&queue->stats, 0, sizeof(queue->stats)); 359 } 360 } 361 362 return count; 363 } 364 365 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show, 366 qeth_dev_performance_stats_store); 367 368 static ssize_t qeth_dev_layer2_show(struct device *dev, 369 struct device_attribute *attr, char *buf) 370 { 371 struct qeth_card *card = dev_get_drvdata(dev); 372 373 if (!card) 374 return -EINVAL; 375 376 return sprintf(buf, "%i\n", card->options.layer); 377 } 378 379 static ssize_t qeth_dev_layer2_store(struct device *dev, 380 struct device_attribute *attr, const char *buf, size_t count) 381 { 382 struct qeth_card *card = dev_get_drvdata(dev); 383 struct net_device *ndev; 384 char *tmp; 385 int i, rc = 0; 386 enum qeth_discipline_id newdis; 387 388 if (!card) 389 return -EINVAL; 390 391 mutex_lock(&card->discipline_mutex); 392 if (card->state != CARD_STATE_DOWN) { 393 rc = -EPERM; 394 goto out; 395 } 396 397 i = simple_strtoul(buf, &tmp, 16); 398 switch (i) { 399 case 0: 400 newdis = QETH_DISCIPLINE_LAYER3; 401 break; 402 case 1: 403 newdis = QETH_DISCIPLINE_LAYER2; 404 break; 405 default: 406 rc = -EINVAL; 407 goto out; 408 } 409 410 if (card->options.layer == newdis) 411 goto out; 412 if (card->info.layer_enforced) { 413 /* fixed layer, can't switch */ 414 rc = -EOPNOTSUPP; 415 goto out; 416 } 417 418 if (card->discipline) { 419 /* start with a new, pristine netdevice: */ 420 ndev = qeth_clone_netdev(card->dev); 421 if (!ndev) { 422 rc = -ENOMEM; 423 goto out; 424 } 425 426 card->discipline->remove(card->gdev); 427 qeth_core_free_discipline(card); 428 free_netdev(card->dev); 429 card->dev = ndev; 430 } 431 432 rc = qeth_core_load_discipline(card, newdis); 433 if (rc) 434 goto out; 435 436 rc = card->discipline->setup(card->gdev); 437 if (rc) 438 qeth_core_free_discipline(card); 439 out: 440 mutex_unlock(&card->discipline_mutex); 441 return rc ? rc : count; 442 } 443 444 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show, 445 qeth_dev_layer2_store); 446 447 #define ATTR_QETH_ISOLATION_NONE ("none") 448 #define ATTR_QETH_ISOLATION_FWD ("forward") 449 #define ATTR_QETH_ISOLATION_DROP ("drop") 450 451 static ssize_t qeth_dev_isolation_show(struct device *dev, 452 struct device_attribute *attr, char *buf) 453 { 454 struct qeth_card *card = dev_get_drvdata(dev); 455 456 if (!card) 457 return -EINVAL; 458 459 switch (card->options.isolation) { 460 case ISOLATION_MODE_NONE: 461 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE); 462 case ISOLATION_MODE_FWD: 463 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD); 464 case ISOLATION_MODE_DROP: 465 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP); 466 default: 467 return snprintf(buf, 5, "%s\n", "N/A"); 468 } 469 } 470 471 static ssize_t qeth_dev_isolation_store(struct device *dev, 472 struct device_attribute *attr, const char *buf, size_t count) 473 { 474 struct qeth_card *card = dev_get_drvdata(dev); 475 enum qeth_ipa_isolation_modes isolation; 476 int rc = 0; 477 478 if (!card) 479 return -EINVAL; 480 481 mutex_lock(&card->conf_mutex); 482 if (card->info.type != QETH_CARD_TYPE_OSD && 483 card->info.type != QETH_CARD_TYPE_OSX) { 484 rc = -EOPNOTSUPP; 485 dev_err(&card->gdev->dev, "Adapter does not " 486 "support QDIO data connection isolation\n"); 487 goto out; 488 } 489 490 /* parse input into isolation mode */ 491 if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) { 492 isolation = ISOLATION_MODE_NONE; 493 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) { 494 isolation = ISOLATION_MODE_FWD; 495 } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) { 496 isolation = ISOLATION_MODE_DROP; 497 } else { 498 rc = -EINVAL; 499 goto out; 500 } 501 rc = count; 502 503 /* defer IP assist if device is offline (until discipline->set_online)*/ 504 card->options.prev_isolation = card->options.isolation; 505 card->options.isolation = isolation; 506 if (qeth_card_hw_is_reachable(card)) { 507 int ipa_rc = qeth_set_access_ctrl_online(card, 1); 508 if (ipa_rc != 0) 509 rc = ipa_rc; 510 } 511 out: 512 mutex_unlock(&card->conf_mutex); 513 return rc; 514 } 515 516 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show, 517 qeth_dev_isolation_store); 518 519 static ssize_t qeth_dev_switch_attrs_show(struct device *dev, 520 struct device_attribute *attr, char *buf) 521 { 522 struct qeth_card *card = dev_get_drvdata(dev); 523 struct qeth_switch_info sw_info; 524 int rc = 0; 525 526 if (!card) 527 return -EINVAL; 528 529 if (!qeth_card_hw_is_reachable(card)) 530 return sprintf(buf, "n/a\n"); 531 532 rc = qeth_query_switch_attributes(card, &sw_info); 533 if (rc) 534 return rc; 535 536 if (!sw_info.capabilities) 537 rc = sprintf(buf, "unknown"); 538 539 if (sw_info.capabilities & QETH_SWITCH_FORW_802_1) 540 rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ? 541 "[802.1]" : "802.1")); 542 if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY) 543 rc += sprintf(buf + rc, 544 (sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ? 545 " [rr]" : " rr")); 546 rc += sprintf(buf + rc, "\n"); 547 548 return rc; 549 } 550 551 static DEVICE_ATTR(switch_attrs, 0444, 552 qeth_dev_switch_attrs_show, NULL); 553 554 static ssize_t qeth_hw_trap_show(struct device *dev, 555 struct device_attribute *attr, char *buf) 556 { 557 struct qeth_card *card = dev_get_drvdata(dev); 558 559 if (!card) 560 return -EINVAL; 561 if (card->info.hwtrap) 562 return snprintf(buf, 5, "arm\n"); 563 else 564 return snprintf(buf, 8, "disarm\n"); 565 } 566 567 static ssize_t qeth_hw_trap_store(struct device *dev, 568 struct device_attribute *attr, const char *buf, size_t count) 569 { 570 struct qeth_card *card = dev_get_drvdata(dev); 571 int rc = 0; 572 int state = 0; 573 574 if (!card) 575 return -EINVAL; 576 577 mutex_lock(&card->conf_mutex); 578 if (qeth_card_hw_is_reachable(card)) 579 state = 1; 580 581 if (sysfs_streq(buf, "arm") && !card->info.hwtrap) { 582 if (state) { 583 if (qeth_is_diagass_supported(card, 584 QETH_DIAGS_CMD_TRAP)) { 585 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM); 586 if (!rc) 587 card->info.hwtrap = 1; 588 } else 589 rc = -EINVAL; 590 } else 591 card->info.hwtrap = 1; 592 } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) { 593 if (state) { 594 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 595 if (!rc) 596 card->info.hwtrap = 0; 597 } else 598 card->info.hwtrap = 0; 599 } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap) 600 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE); 601 else 602 rc = -EINVAL; 603 604 mutex_unlock(&card->conf_mutex); 605 return rc ? rc : count; 606 } 607 608 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show, 609 qeth_hw_trap_store); 610 611 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value) 612 { 613 614 if (!card) 615 return -EINVAL; 616 617 return sprintf(buf, "%i\n", value); 618 } 619 620 static ssize_t qeth_dev_blkt_store(struct qeth_card *card, 621 const char *buf, size_t count, int *value, int max_value) 622 { 623 char *tmp; 624 int i, rc = 0; 625 626 if (!card) 627 return -EINVAL; 628 629 mutex_lock(&card->conf_mutex); 630 if (card->state != CARD_STATE_DOWN) { 631 rc = -EPERM; 632 goto out; 633 } 634 i = simple_strtoul(buf, &tmp, 10); 635 if (i <= max_value) 636 *value = i; 637 else 638 rc = -EINVAL; 639 out: 640 mutex_unlock(&card->conf_mutex); 641 return rc ? rc : count; 642 } 643 644 static ssize_t qeth_dev_blkt_total_show(struct device *dev, 645 struct device_attribute *attr, char *buf) 646 { 647 struct qeth_card *card = dev_get_drvdata(dev); 648 649 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total); 650 } 651 652 static ssize_t qeth_dev_blkt_total_store(struct device *dev, 653 struct device_attribute *attr, const char *buf, size_t count) 654 { 655 struct qeth_card *card = dev_get_drvdata(dev); 656 657 return qeth_dev_blkt_store(card, buf, count, 658 &card->info.blkt.time_total, 5000); 659 } 660 661 662 663 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show, 664 qeth_dev_blkt_total_store); 665 666 static ssize_t qeth_dev_blkt_inter_show(struct device *dev, 667 struct device_attribute *attr, char *buf) 668 { 669 struct qeth_card *card = dev_get_drvdata(dev); 670 671 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet); 672 } 673 674 static ssize_t qeth_dev_blkt_inter_store(struct device *dev, 675 struct device_attribute *attr, const char *buf, size_t count) 676 { 677 struct qeth_card *card = dev_get_drvdata(dev); 678 679 return qeth_dev_blkt_store(card, buf, count, 680 &card->info.blkt.inter_packet, 1000); 681 } 682 683 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show, 684 qeth_dev_blkt_inter_store); 685 686 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev, 687 struct device_attribute *attr, char *buf) 688 { 689 struct qeth_card *card = dev_get_drvdata(dev); 690 691 return qeth_dev_blkt_show(buf, card, 692 card->info.blkt.inter_packet_jumbo); 693 } 694 695 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev, 696 struct device_attribute *attr, const char *buf, size_t count) 697 { 698 struct qeth_card *card = dev_get_drvdata(dev); 699 700 return qeth_dev_blkt_store(card, buf, count, 701 &card->info.blkt.inter_packet_jumbo, 1000); 702 } 703 704 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show, 705 qeth_dev_blkt_inter_jumbo_store); 706 707 static struct attribute *qeth_blkt_device_attrs[] = { 708 &dev_attr_total.attr, 709 &dev_attr_inter.attr, 710 &dev_attr_inter_jumbo.attr, 711 NULL, 712 }; 713 const struct attribute_group qeth_device_blkt_group = { 714 .name = "blkt", 715 .attrs = qeth_blkt_device_attrs, 716 }; 717 EXPORT_SYMBOL_GPL(qeth_device_blkt_group); 718 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, 735 NULL, 736 }; 737 const struct attribute_group qeth_device_attr_group = { 738 .attrs = qeth_device_attrs, 739 }; 740 EXPORT_SYMBOL_GPL(qeth_device_attr_group); 741 742 const struct attribute_group *qeth_generic_attr_groups[] = { 743 &qeth_device_attr_group, 744 &qeth_device_blkt_group, 745 NULL, 746 }; 747 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, 755 NULL, 756 }; 757 static struct attribute_group qeth_osn_device_attr_group = { 758 .attrs = qeth_osn_device_attrs, 759 }; 760 const struct attribute_group *qeth_osn_attr_groups[] = { 761 &qeth_osn_device_attr_group, 762 NULL, 763 }; 764