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