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 20 static 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 46 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL); 47 48 static 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 58 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL); 59 60 static 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 69 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL); 70 71 static 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 81 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL); 82 83 static 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 97 static 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 107 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL); 108 109 static 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 119 static 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; 148 out: 149 mutex_unlock(&card->conf_mutex); 150 return rc ? rc : count; 151 } 152 153 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store); 154 155 static 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 172 static 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); 201 out: 202 mutex_unlock(&card->conf_mutex); 203 return rc ? rc : count; 204 } 205 206 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show, 207 qeth_dev_portname_store); 208 209 static 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 228 static 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; 276 out: 277 mutex_unlock(&card->conf_mutex); 278 return rc ? rc : count; 279 } 280 281 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show, 282 qeth_dev_prioqing_store); 283 284 static 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 295 static 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 } 320 out: 321 mutex_unlock(&card->conf_mutex); 322 return rc ? rc : count; 323 } 324 325 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show, 326 qeth_dev_bufcnt_store); 327 328 static 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 348 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store); 349 350 static 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 361 static 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; 384 out: 385 mutex_unlock(&card->conf_mutex); 386 return rc ? rc : count; 387 } 388 389 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show, 390 qeth_dev_performance_stats_store); 391 392 static 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 403 static 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); 448 out: 449 mutex_unlock(&card->discipline_mutex); 450 return rc ? rc : count; 451 } 452 453 static 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 460 static 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 480 static 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 } 525 out: 526 mutex_unlock(&card->conf_mutex); 527 return rc; 528 } 529 530 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show, 531 qeth_dev_isolation_store); 532 533 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value) 534 { 535 536 if (!card) 537 return -EINVAL; 538 539 return sprintf(buf, "%i\n", value); 540 } 541 542 static ssize_t qeth_dev_blkt_store(struct qeth_card *card, 543 const char *buf, size_t count, int *value, int max_value) 544 { 545 char *tmp; 546 int i, rc = 0; 547 548 if (!card) 549 return -EINVAL; 550 551 mutex_lock(&card->conf_mutex); 552 if ((card->state != CARD_STATE_DOWN) && 553 (card->state != CARD_STATE_RECOVER)) { 554 rc = -EPERM; 555 goto out; 556 } 557 i = simple_strtoul(buf, &tmp, 10); 558 if (i <= max_value) 559 *value = i; 560 else 561 rc = -EINVAL; 562 out: 563 mutex_unlock(&card->conf_mutex); 564 return rc ? rc : count; 565 } 566 567 static ssize_t qeth_dev_blkt_total_show(struct device *dev, 568 struct device_attribute *attr, char *buf) 569 { 570 struct qeth_card *card = dev_get_drvdata(dev); 571 572 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total); 573 } 574 575 static ssize_t qeth_dev_blkt_total_store(struct device *dev, 576 struct device_attribute *attr, const char *buf, size_t count) 577 { 578 struct qeth_card *card = dev_get_drvdata(dev); 579 580 return qeth_dev_blkt_store(card, buf, count, 581 &card->info.blkt.time_total, 5000); 582 } 583 584 585 586 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show, 587 qeth_dev_blkt_total_store); 588 589 static ssize_t qeth_dev_blkt_inter_show(struct device *dev, 590 struct device_attribute *attr, char *buf) 591 { 592 struct qeth_card *card = dev_get_drvdata(dev); 593 594 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet); 595 } 596 597 static ssize_t qeth_dev_blkt_inter_store(struct device *dev, 598 struct device_attribute *attr, const char *buf, size_t count) 599 { 600 struct qeth_card *card = dev_get_drvdata(dev); 601 602 return qeth_dev_blkt_store(card, buf, count, 603 &card->info.blkt.inter_packet, 1000); 604 } 605 606 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show, 607 qeth_dev_blkt_inter_store); 608 609 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev, 610 struct device_attribute *attr, char *buf) 611 { 612 struct qeth_card *card = dev_get_drvdata(dev); 613 614 return qeth_dev_blkt_show(buf, card, 615 card->info.blkt.inter_packet_jumbo); 616 } 617 618 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev, 619 struct device_attribute *attr, const char *buf, size_t count) 620 { 621 struct qeth_card *card = dev_get_drvdata(dev); 622 623 return qeth_dev_blkt_store(card, buf, count, 624 &card->info.blkt.inter_packet_jumbo, 1000); 625 } 626 627 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show, 628 qeth_dev_blkt_inter_jumbo_store); 629 630 static struct attribute *qeth_blkt_device_attrs[] = { 631 &dev_attr_total.attr, 632 &dev_attr_inter.attr, 633 &dev_attr_inter_jumbo.attr, 634 NULL, 635 }; 636 637 static struct attribute_group qeth_device_blkt_group = { 638 .name = "blkt", 639 .attrs = qeth_blkt_device_attrs, 640 }; 641 642 static struct attribute *qeth_device_attrs[] = { 643 &dev_attr_state.attr, 644 &dev_attr_chpid.attr, 645 &dev_attr_if_name.attr, 646 &dev_attr_card_type.attr, 647 &dev_attr_inbuf_size.attr, 648 &dev_attr_portno.attr, 649 &dev_attr_portname.attr, 650 &dev_attr_priority_queueing.attr, 651 &dev_attr_buffer_count.attr, 652 &dev_attr_recover.attr, 653 &dev_attr_performance_stats.attr, 654 &dev_attr_layer2.attr, 655 &dev_attr_isolation.attr, 656 NULL, 657 }; 658 659 static struct attribute_group qeth_device_attr_group = { 660 .attrs = qeth_device_attrs, 661 }; 662 663 static struct attribute *qeth_osn_device_attrs[] = { 664 &dev_attr_state.attr, 665 &dev_attr_chpid.attr, 666 &dev_attr_if_name.attr, 667 &dev_attr_card_type.attr, 668 &dev_attr_buffer_count.attr, 669 &dev_attr_recover.attr, 670 NULL, 671 }; 672 673 static struct attribute_group qeth_osn_device_attr_group = { 674 .attrs = qeth_osn_device_attrs, 675 }; 676 677 int qeth_core_create_device_attributes(struct device *dev) 678 { 679 int ret; 680 ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group); 681 if (ret) 682 return ret; 683 ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group); 684 if (ret) 685 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 686 687 return 0; 688 } 689 690 void qeth_core_remove_device_attributes(struct device *dev) 691 { 692 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 693 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group); 694 } 695 696 int qeth_core_create_osn_attributes(struct device *dev) 697 { 698 return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group); 699 } 700 701 void qeth_core_remove_osn_attributes(struct device *dev) 702 { 703 sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group); 704 return; 705 } 706