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->conf_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 if (card->discipline.ccwgdriver) { 437 card->discipline.ccwgdriver->remove(card->gdev); 438 qeth_core_free_discipline(card); 439 } 440 } 441 442 rc = qeth_core_load_discipline(card, newdis); 443 if (rc) 444 goto out; 445 446 rc = card->discipline.ccwgdriver->probe(card->gdev); 447 out: 448 mutex_unlock(&card->conf_mutex); 449 return rc ? rc : count; 450 } 451 452 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show, 453 qeth_dev_layer2_store); 454 455 #define ATTR_QETH_ISOLATION_NONE ("none") 456 #define ATTR_QETH_ISOLATION_FWD ("forward") 457 #define ATTR_QETH_ISOLATION_DROP ("drop") 458 459 static ssize_t qeth_dev_isolation_show(struct device *dev, 460 struct device_attribute *attr, char *buf) 461 { 462 struct qeth_card *card = dev_get_drvdata(dev); 463 464 if (!card) 465 return -EINVAL; 466 467 switch (card->options.isolation) { 468 case ISOLATION_MODE_NONE: 469 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE); 470 case ISOLATION_MODE_FWD: 471 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD); 472 case ISOLATION_MODE_DROP: 473 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP); 474 default: 475 return snprintf(buf, 5, "%s\n", "N/A"); 476 } 477 } 478 479 static ssize_t qeth_dev_isolation_store(struct device *dev, 480 struct device_attribute *attr, const char *buf, size_t count) 481 { 482 struct qeth_card *card = dev_get_drvdata(dev); 483 enum qeth_ipa_isolation_modes isolation; 484 int rc = 0; 485 char *tmp, *curtoken; 486 curtoken = (char *) buf; 487 488 if (!card) 489 return -EINVAL; 490 491 mutex_lock(&card->conf_mutex); 492 /* check for unknown, too, in case we do not yet know who we are */ 493 if (card->info.type != QETH_CARD_TYPE_OSD && 494 card->info.type != QETH_CARD_TYPE_OSX && 495 card->info.type != QETH_CARD_TYPE_UNKNOWN) { 496 rc = -EOPNOTSUPP; 497 dev_err(&card->gdev->dev, "Adapter does not " 498 "support QDIO data connection isolation\n"); 499 goto out; 500 } 501 502 /* parse input into isolation mode */ 503 tmp = strsep(&curtoken, "\n"); 504 if (!strcmp(tmp, ATTR_QETH_ISOLATION_NONE)) { 505 isolation = ISOLATION_MODE_NONE; 506 } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_FWD)) { 507 isolation = ISOLATION_MODE_FWD; 508 } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_DROP)) { 509 isolation = ISOLATION_MODE_DROP; 510 } else { 511 rc = -EINVAL; 512 goto out; 513 } 514 rc = count; 515 516 /* defer IP assist if device is offline (until discipline->set_online)*/ 517 card->options.isolation = isolation; 518 if (card->state == CARD_STATE_SOFTSETUP || 519 card->state == CARD_STATE_UP) { 520 int ipa_rc = qeth_set_access_ctrl_online(card); 521 if (ipa_rc != 0) 522 rc = ipa_rc; 523 } 524 out: 525 mutex_unlock(&card->conf_mutex); 526 return rc; 527 } 528 529 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show, 530 qeth_dev_isolation_store); 531 532 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value) 533 { 534 535 if (!card) 536 return -EINVAL; 537 538 return sprintf(buf, "%i\n", value); 539 } 540 541 static ssize_t qeth_dev_blkt_store(struct qeth_card *card, 542 const char *buf, size_t count, int *value, int max_value) 543 { 544 char *tmp; 545 int i, rc = 0; 546 547 if (!card) 548 return -EINVAL; 549 550 mutex_lock(&card->conf_mutex); 551 if ((card->state != CARD_STATE_DOWN) && 552 (card->state != CARD_STATE_RECOVER)) { 553 rc = -EPERM; 554 goto out; 555 } 556 i = simple_strtoul(buf, &tmp, 10); 557 if (i <= max_value) 558 *value = i; 559 else 560 rc = -EINVAL; 561 out: 562 mutex_unlock(&card->conf_mutex); 563 return rc ? rc : count; 564 } 565 566 static ssize_t qeth_dev_blkt_total_show(struct device *dev, 567 struct device_attribute *attr, char *buf) 568 { 569 struct qeth_card *card = dev_get_drvdata(dev); 570 571 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total); 572 } 573 574 static ssize_t qeth_dev_blkt_total_store(struct device *dev, 575 struct device_attribute *attr, const char *buf, size_t count) 576 { 577 struct qeth_card *card = dev_get_drvdata(dev); 578 579 return qeth_dev_blkt_store(card, buf, count, 580 &card->info.blkt.time_total, 5000); 581 } 582 583 584 585 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show, 586 qeth_dev_blkt_total_store); 587 588 static ssize_t qeth_dev_blkt_inter_show(struct device *dev, 589 struct device_attribute *attr, char *buf) 590 { 591 struct qeth_card *card = dev_get_drvdata(dev); 592 593 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet); 594 } 595 596 static ssize_t qeth_dev_blkt_inter_store(struct device *dev, 597 struct device_attribute *attr, const char *buf, size_t count) 598 { 599 struct qeth_card *card = dev_get_drvdata(dev); 600 601 return qeth_dev_blkt_store(card, buf, count, 602 &card->info.blkt.inter_packet, 1000); 603 } 604 605 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show, 606 qeth_dev_blkt_inter_store); 607 608 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev, 609 struct device_attribute *attr, char *buf) 610 { 611 struct qeth_card *card = dev_get_drvdata(dev); 612 613 return qeth_dev_blkt_show(buf, card, 614 card->info.blkt.inter_packet_jumbo); 615 } 616 617 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev, 618 struct device_attribute *attr, const char *buf, size_t count) 619 { 620 struct qeth_card *card = dev_get_drvdata(dev); 621 622 return qeth_dev_blkt_store(card, buf, count, 623 &card->info.blkt.inter_packet_jumbo, 1000); 624 } 625 626 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show, 627 qeth_dev_blkt_inter_jumbo_store); 628 629 static struct attribute *qeth_blkt_device_attrs[] = { 630 &dev_attr_total.attr, 631 &dev_attr_inter.attr, 632 &dev_attr_inter_jumbo.attr, 633 NULL, 634 }; 635 636 static struct attribute_group qeth_device_blkt_group = { 637 .name = "blkt", 638 .attrs = qeth_blkt_device_attrs, 639 }; 640 641 static struct attribute *qeth_device_attrs[] = { 642 &dev_attr_state.attr, 643 &dev_attr_chpid.attr, 644 &dev_attr_if_name.attr, 645 &dev_attr_card_type.attr, 646 &dev_attr_inbuf_size.attr, 647 &dev_attr_portno.attr, 648 &dev_attr_portname.attr, 649 &dev_attr_priority_queueing.attr, 650 &dev_attr_buffer_count.attr, 651 &dev_attr_recover.attr, 652 &dev_attr_performance_stats.attr, 653 &dev_attr_layer2.attr, 654 &dev_attr_isolation.attr, 655 NULL, 656 }; 657 658 static struct attribute_group qeth_device_attr_group = { 659 .attrs = qeth_device_attrs, 660 }; 661 662 static struct attribute *qeth_osn_device_attrs[] = { 663 &dev_attr_state.attr, 664 &dev_attr_chpid.attr, 665 &dev_attr_if_name.attr, 666 &dev_attr_card_type.attr, 667 &dev_attr_buffer_count.attr, 668 &dev_attr_recover.attr, 669 NULL, 670 }; 671 672 static struct attribute_group qeth_osn_device_attr_group = { 673 .attrs = qeth_osn_device_attrs, 674 }; 675 676 int qeth_core_create_device_attributes(struct device *dev) 677 { 678 int ret; 679 ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group); 680 if (ret) 681 return ret; 682 ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group); 683 if (ret) 684 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 685 686 return 0; 687 } 688 689 void qeth_core_remove_device_attributes(struct device *dev) 690 { 691 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group); 692 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group); 693 } 694 695 int qeth_core_create_osn_attributes(struct device *dev) 696 { 697 return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group); 698 } 699 700 void qeth_core_remove_osn_attributes(struct device *dev) 701 { 702 sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group); 703 return; 704 } 705