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