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