ipath_sysfs.c revision 30fc5c3130bdbc7cc051a2d6054ad38360d408a8
1/* 2 * Copyright (c) 2006 QLogic, Inc. All rights reserved. 3 * Copyright (c) 2006 PathScale, Inc. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34#include <linux/ctype.h> 35#include <linux/pci.h> 36 37#include "ipath_kernel.h" 38#include "ipath_common.h" 39 40/** 41 * ipath_parse_ushort - parse an unsigned short value in an arbitrary base 42 * @str: the string containing the number 43 * @valp: where to put the result 44 * 45 * returns the number of bytes consumed, or negative value on error 46 */ 47int ipath_parse_ushort(const char *str, unsigned short *valp) 48{ 49 unsigned long val; 50 char *end; 51 int ret; 52 53 if (!isdigit(str[0])) { 54 ret = -EINVAL; 55 goto bail; 56 } 57 58 val = simple_strtoul(str, &end, 0); 59 60 if (val > 0xffff) { 61 ret = -EINVAL; 62 goto bail; 63 } 64 65 *valp = val; 66 67 ret = end + 1 - str; 68 if (ret == 0) 69 ret = -EINVAL; 70 71bail: 72 return ret; 73} 74 75static ssize_t show_version(struct device_driver *dev, char *buf) 76{ 77 /* The string printed here is already newline-terminated. */ 78 return scnprintf(buf, PAGE_SIZE, "%s", ib_ipath_version); 79} 80 81static ssize_t show_num_units(struct device_driver *dev, char *buf) 82{ 83 return scnprintf(buf, PAGE_SIZE, "%d\n", 84 ipath_count_units(NULL, NULL, NULL)); 85} 86 87static ssize_t show_status(struct device *dev, 88 struct device_attribute *attr, 89 char *buf) 90{ 91 struct ipath_devdata *dd = dev_get_drvdata(dev); 92 ssize_t ret; 93 94 if (!dd->ipath_statusp) { 95 ret = -EINVAL; 96 goto bail; 97 } 98 99 ret = scnprintf(buf, PAGE_SIZE, "0x%llx\n", 100 (unsigned long long) *(dd->ipath_statusp)); 101 102bail: 103 return ret; 104} 105 106static const char *ipath_status_str[] = { 107 "Initted", 108 "Disabled", 109 "Admin_Disabled", 110 "", /* This used to be the old "OIB_SMA" status. */ 111 "", /* This used to be the old "SMA" status. */ 112 "Present", 113 "IB_link_up", 114 "IB_configured", 115 "NoIBcable", 116 "Fatal_Hardware_Error", 117 NULL, 118}; 119 120static ssize_t show_status_str(struct device *dev, 121 struct device_attribute *attr, 122 char *buf) 123{ 124 struct ipath_devdata *dd = dev_get_drvdata(dev); 125 int i, any; 126 u64 s; 127 ssize_t ret; 128 129 if (!dd->ipath_statusp) { 130 ret = -EINVAL; 131 goto bail; 132 } 133 134 s = *(dd->ipath_statusp); 135 *buf = '\0'; 136 for (any = i = 0; s && ipath_status_str[i]; i++) { 137 if (s & 1) { 138 if (any && strlcat(buf, " ", PAGE_SIZE) >= 139 PAGE_SIZE) 140 /* overflow */ 141 break; 142 if (strlcat(buf, ipath_status_str[i], 143 PAGE_SIZE) >= PAGE_SIZE) 144 break; 145 any = 1; 146 } 147 s >>= 1; 148 } 149 if (any) 150 strlcat(buf, "\n", PAGE_SIZE); 151 152 ret = strlen(buf); 153 154bail: 155 return ret; 156} 157 158static ssize_t show_boardversion(struct device *dev, 159 struct device_attribute *attr, 160 char *buf) 161{ 162 struct ipath_devdata *dd = dev_get_drvdata(dev); 163 /* The string printed here is already newline-terminated. */ 164 return scnprintf(buf, PAGE_SIZE, "%s", dd->ipath_boardversion); 165} 166 167static ssize_t show_lid(struct device *dev, 168 struct device_attribute *attr, 169 char *buf) 170{ 171 struct ipath_devdata *dd = dev_get_drvdata(dev); 172 173 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_lid); 174} 175 176static ssize_t store_lid(struct device *dev, 177 struct device_attribute *attr, 178 const char *buf, 179 size_t count) 180{ 181 struct ipath_devdata *dd = dev_get_drvdata(dev); 182 u16 lid = 0; 183 int ret; 184 185 ret = ipath_parse_ushort(buf, &lid); 186 if (ret < 0) 187 goto invalid; 188 189 if (lid == 0 || lid >= IPATH_MULTICAST_LID_BASE) { 190 ret = -EINVAL; 191 goto invalid; 192 } 193 194 ipath_set_lid(dd, lid, 0); 195 196 goto bail; 197invalid: 198 ipath_dev_err(dd, "attempt to set invalid LID 0x%x\n", lid); 199bail: 200 return ret; 201} 202 203static ssize_t show_mlid(struct device *dev, 204 struct device_attribute *attr, 205 char *buf) 206{ 207 struct ipath_devdata *dd = dev_get_drvdata(dev); 208 209 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_mlid); 210} 211 212static ssize_t store_mlid(struct device *dev, 213 struct device_attribute *attr, 214 const char *buf, 215 size_t count) 216{ 217 struct ipath_devdata *dd = dev_get_drvdata(dev); 218 int unit; 219 u16 mlid; 220 int ret; 221 222 ret = ipath_parse_ushort(buf, &mlid); 223 if (ret < 0 || mlid < IPATH_MULTICAST_LID_BASE) 224 goto invalid; 225 226 unit = dd->ipath_unit; 227 228 dd->ipath_mlid = mlid; 229 230 goto bail; 231invalid: 232 ipath_dev_err(dd, "attempt to set invalid MLID\n"); 233bail: 234 return ret; 235} 236 237static ssize_t show_guid(struct device *dev, 238 struct device_attribute *attr, 239 char *buf) 240{ 241 struct ipath_devdata *dd = dev_get_drvdata(dev); 242 u8 *guid; 243 244 guid = (u8 *) & (dd->ipath_guid); 245 246 return scnprintf(buf, PAGE_SIZE, 247 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", 248 guid[0], guid[1], guid[2], guid[3], 249 guid[4], guid[5], guid[6], guid[7]); 250} 251 252static ssize_t store_guid(struct device *dev, 253 struct device_attribute *attr, 254 const char *buf, 255 size_t count) 256{ 257 struct ipath_devdata *dd = dev_get_drvdata(dev); 258 ssize_t ret; 259 unsigned short guid[8]; 260 __be64 nguid; 261 u8 *ng; 262 int i; 263 264 if (sscanf(buf, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx", 265 &guid[0], &guid[1], &guid[2], &guid[3], 266 &guid[4], &guid[5], &guid[6], &guid[7]) != 8) 267 goto invalid; 268 269 ng = (u8 *) &nguid; 270 271 for (i = 0; i < 8; i++) { 272 if (guid[i] > 0xff) 273 goto invalid; 274 ng[i] = guid[i]; 275 } 276 277 dd->ipath_guid = nguid; 278 dd->ipath_nguid = 1; 279 280 ret = strlen(buf); 281 goto bail; 282 283invalid: 284 ipath_dev_err(dd, "attempt to set invalid GUID\n"); 285 ret = -EINVAL; 286 287bail: 288 return ret; 289} 290 291static ssize_t show_nguid(struct device *dev, 292 struct device_attribute *attr, 293 char *buf) 294{ 295 struct ipath_devdata *dd = dev_get_drvdata(dev); 296 297 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_nguid); 298} 299 300static ssize_t show_serial(struct device *dev, 301 struct device_attribute *attr, 302 char *buf) 303{ 304 struct ipath_devdata *dd = dev_get_drvdata(dev); 305 306 buf[sizeof dd->ipath_serial] = '\0'; 307 memcpy(buf, dd->ipath_serial, sizeof dd->ipath_serial); 308 strcat(buf, "\n"); 309 return strlen(buf); 310} 311 312static ssize_t show_unit(struct device *dev, 313 struct device_attribute *attr, 314 char *buf) 315{ 316 struct ipath_devdata *dd = dev_get_drvdata(dev); 317 318 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_unit); 319} 320 321#define DEVICE_COUNTER(name, attr) \ 322 static ssize_t show_counter_##name(struct device *dev, \ 323 struct device_attribute *attr, \ 324 char *buf) \ 325 { \ 326 struct ipath_devdata *dd = dev_get_drvdata(dev); \ 327 return scnprintf(\ 328 buf, PAGE_SIZE, "%llu\n", (unsigned long long) \ 329 ipath_snap_cntr( \ 330 dd, offsetof(struct infinipath_counters, \ 331 attr) / sizeof(u64))); \ 332 } \ 333 static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL); 334 335DEVICE_COUNTER(ib_link_downeds, IBLinkDownedCnt); 336DEVICE_COUNTER(ib_link_err_recoveries, IBLinkErrRecoveryCnt); 337DEVICE_COUNTER(ib_status_changes, IBStatusChangeCnt); 338DEVICE_COUNTER(ib_symbol_errs, IBSymbolErrCnt); 339DEVICE_COUNTER(lb_flow_stalls, LBFlowStallCnt); 340DEVICE_COUNTER(lb_ints, LBIntCnt); 341DEVICE_COUNTER(rx_bad_formats, RxBadFormatCnt); 342DEVICE_COUNTER(rx_buf_ovfls, RxBufOvflCnt); 343DEVICE_COUNTER(rx_data_pkts, RxDataPktCnt); 344DEVICE_COUNTER(rx_dropped_pkts, RxDroppedPktCnt); 345DEVICE_COUNTER(rx_dwords, RxDwordCnt); 346DEVICE_COUNTER(rx_ebps, RxEBPCnt); 347DEVICE_COUNTER(rx_flow_ctrl_errs, RxFlowCtrlErrCnt); 348DEVICE_COUNTER(rx_flow_pkts, RxFlowPktCnt); 349DEVICE_COUNTER(rx_icrc_errs, RxICRCErrCnt); 350DEVICE_COUNTER(rx_len_errs, RxLenErrCnt); 351DEVICE_COUNTER(rx_link_problems, RxLinkProblemCnt); 352DEVICE_COUNTER(rx_lpcrc_errs, RxLPCRCErrCnt); 353DEVICE_COUNTER(rx_max_min_len_errs, RxMaxMinLenErrCnt); 354DEVICE_COUNTER(rx_p0_hdr_egr_ovfls, RxP0HdrEgrOvflCnt); 355DEVICE_COUNTER(rx_p1_hdr_egr_ovfls, RxP1HdrEgrOvflCnt); 356DEVICE_COUNTER(rx_p2_hdr_egr_ovfls, RxP2HdrEgrOvflCnt); 357DEVICE_COUNTER(rx_p3_hdr_egr_ovfls, RxP3HdrEgrOvflCnt); 358DEVICE_COUNTER(rx_p4_hdr_egr_ovfls, RxP4HdrEgrOvflCnt); 359DEVICE_COUNTER(rx_p5_hdr_egr_ovfls, RxP5HdrEgrOvflCnt); 360DEVICE_COUNTER(rx_p6_hdr_egr_ovfls, RxP6HdrEgrOvflCnt); 361DEVICE_COUNTER(rx_p7_hdr_egr_ovfls, RxP7HdrEgrOvflCnt); 362DEVICE_COUNTER(rx_p8_hdr_egr_ovfls, RxP8HdrEgrOvflCnt); 363DEVICE_COUNTER(rx_pkey_mismatches, RxPKeyMismatchCnt); 364DEVICE_COUNTER(rx_tid_full_errs, RxTIDFullErrCnt); 365DEVICE_COUNTER(rx_tid_valid_errs, RxTIDValidErrCnt); 366DEVICE_COUNTER(rx_vcrc_errs, RxVCRCErrCnt); 367DEVICE_COUNTER(tx_data_pkts, TxDataPktCnt); 368DEVICE_COUNTER(tx_dropped_pkts, TxDroppedPktCnt); 369DEVICE_COUNTER(tx_dwords, TxDwordCnt); 370DEVICE_COUNTER(tx_flow_pkts, TxFlowPktCnt); 371DEVICE_COUNTER(tx_flow_stalls, TxFlowStallCnt); 372DEVICE_COUNTER(tx_len_errs, TxLenErrCnt); 373DEVICE_COUNTER(tx_max_min_len_errs, TxMaxMinLenErrCnt); 374DEVICE_COUNTER(tx_underruns, TxUnderrunCnt); 375DEVICE_COUNTER(tx_unsup_vl_errs, TxUnsupVLErrCnt); 376 377static struct attribute *dev_counter_attributes[] = { 378 &dev_attr_ib_link_downeds.attr, 379 &dev_attr_ib_link_err_recoveries.attr, 380 &dev_attr_ib_status_changes.attr, 381 &dev_attr_ib_symbol_errs.attr, 382 &dev_attr_lb_flow_stalls.attr, 383 &dev_attr_lb_ints.attr, 384 &dev_attr_rx_bad_formats.attr, 385 &dev_attr_rx_buf_ovfls.attr, 386 &dev_attr_rx_data_pkts.attr, 387 &dev_attr_rx_dropped_pkts.attr, 388 &dev_attr_rx_dwords.attr, 389 &dev_attr_rx_ebps.attr, 390 &dev_attr_rx_flow_ctrl_errs.attr, 391 &dev_attr_rx_flow_pkts.attr, 392 &dev_attr_rx_icrc_errs.attr, 393 &dev_attr_rx_len_errs.attr, 394 &dev_attr_rx_link_problems.attr, 395 &dev_attr_rx_lpcrc_errs.attr, 396 &dev_attr_rx_max_min_len_errs.attr, 397 &dev_attr_rx_p0_hdr_egr_ovfls.attr, 398 &dev_attr_rx_p1_hdr_egr_ovfls.attr, 399 &dev_attr_rx_p2_hdr_egr_ovfls.attr, 400 &dev_attr_rx_p3_hdr_egr_ovfls.attr, 401 &dev_attr_rx_p4_hdr_egr_ovfls.attr, 402 &dev_attr_rx_p5_hdr_egr_ovfls.attr, 403 &dev_attr_rx_p6_hdr_egr_ovfls.attr, 404 &dev_attr_rx_p7_hdr_egr_ovfls.attr, 405 &dev_attr_rx_p8_hdr_egr_ovfls.attr, 406 &dev_attr_rx_pkey_mismatches.attr, 407 &dev_attr_rx_tid_full_errs.attr, 408 &dev_attr_rx_tid_valid_errs.attr, 409 &dev_attr_rx_vcrc_errs.attr, 410 &dev_attr_tx_data_pkts.attr, 411 &dev_attr_tx_dropped_pkts.attr, 412 &dev_attr_tx_dwords.attr, 413 &dev_attr_tx_flow_pkts.attr, 414 &dev_attr_tx_flow_stalls.attr, 415 &dev_attr_tx_len_errs.attr, 416 &dev_attr_tx_max_min_len_errs.attr, 417 &dev_attr_tx_underruns.attr, 418 &dev_attr_tx_unsup_vl_errs.attr, 419 NULL 420}; 421 422static struct attribute_group dev_counter_attr_group = { 423 .name = "counters", 424 .attrs = dev_counter_attributes 425}; 426 427static ssize_t store_reset(struct device *dev, 428 struct device_attribute *attr, 429 const char *buf, 430 size_t count) 431{ 432 struct ipath_devdata *dd = dev_get_drvdata(dev); 433 int ret; 434 435 if (count < 5 || memcmp(buf, "reset", 5)) { 436 ret = -EINVAL; 437 goto bail; 438 } 439 440 if (dd->ipath_flags & IPATH_DISABLED) { 441 /* 442 * post-reset init would re-enable interrupts, etc. 443 * so don't allow reset on disabled devices. Not 444 * perfect error, but about the best choice. 445 */ 446 dev_info(dev,"Unit %d is disabled, can't reset\n", 447 dd->ipath_unit); 448 ret = -EINVAL; 449 } 450 ret = ipath_reset_device(dd->ipath_unit); 451bail: 452 return ret<0 ? ret : count; 453} 454 455static ssize_t store_link_state(struct device *dev, 456 struct device_attribute *attr, 457 const char *buf, 458 size_t count) 459{ 460 struct ipath_devdata *dd = dev_get_drvdata(dev); 461 int ret, r; 462 u16 state; 463 464 ret = ipath_parse_ushort(buf, &state); 465 if (ret < 0) 466 goto invalid; 467 468 r = ipath_set_linkstate(dd, state); 469 if (r < 0) { 470 ret = r; 471 goto bail; 472 } 473 474 goto bail; 475invalid: 476 ipath_dev_err(dd, "attempt to set invalid link state\n"); 477bail: 478 return ret; 479} 480 481static ssize_t show_mtu(struct device *dev, 482 struct device_attribute *attr, 483 char *buf) 484{ 485 struct ipath_devdata *dd = dev_get_drvdata(dev); 486 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_ibmtu); 487} 488 489static ssize_t store_mtu(struct device *dev, 490 struct device_attribute *attr, 491 const char *buf, 492 size_t count) 493{ 494 struct ipath_devdata *dd = dev_get_drvdata(dev); 495 ssize_t ret; 496 u16 mtu = 0; 497 int r; 498 499 ret = ipath_parse_ushort(buf, &mtu); 500 if (ret < 0) 501 goto invalid; 502 503 r = ipath_set_mtu(dd, mtu); 504 if (r < 0) 505 ret = r; 506 507 goto bail; 508invalid: 509 ipath_dev_err(dd, "attempt to set invalid MTU\n"); 510bail: 511 return ret; 512} 513 514static ssize_t show_enabled(struct device *dev, 515 struct device_attribute *attr, 516 char *buf) 517{ 518 struct ipath_devdata *dd = dev_get_drvdata(dev); 519 return scnprintf(buf, PAGE_SIZE, "%u\n", 520 (dd->ipath_flags & IPATH_DISABLED) ? 0 : 1); 521} 522 523static ssize_t store_enabled(struct device *dev, 524 struct device_attribute *attr, 525 const char *buf, 526 size_t count) 527{ 528 struct ipath_devdata *dd = dev_get_drvdata(dev); 529 ssize_t ret; 530 u16 enable = 0; 531 532 ret = ipath_parse_ushort(buf, &enable); 533 if (ret < 0) { 534 ipath_dev_err(dd, "attempt to use non-numeric on enable\n"); 535 goto bail; 536 } 537 538 if (enable) { 539 if (!(dd->ipath_flags & IPATH_DISABLED)) 540 goto bail; 541 542 dev_info(dev, "Enabling unit %d\n", dd->ipath_unit); 543 /* same as post-reset */ 544 ret = ipath_init_chip(dd, 1); 545 if (ret) 546 ipath_dev_err(dd, "Failed to enable unit %d\n", 547 dd->ipath_unit); 548 else { 549 dd->ipath_flags &= ~IPATH_DISABLED; 550 *dd->ipath_statusp &= ~IPATH_STATUS_ADMIN_DISABLED; 551 } 552 } 553 else if (!(dd->ipath_flags & IPATH_DISABLED)) { 554 dev_info(dev, "Disabling unit %d\n", dd->ipath_unit); 555 ipath_shutdown_device(dd); 556 dd->ipath_flags |= IPATH_DISABLED; 557 *dd->ipath_statusp |= IPATH_STATUS_ADMIN_DISABLED; 558 } 559 560bail: 561 return ret; 562} 563 564static ssize_t store_rx_pol_inv(struct device *dev, 565 struct device_attribute *attr, 566 const char *buf, 567 size_t count) 568{ 569 struct ipath_devdata *dd = dev_get_drvdata(dev); 570 int ret, r; 571 u16 val; 572 573 ret = ipath_parse_ushort(buf, &val); 574 if (ret < 0) 575 goto invalid; 576 577 r = ipath_set_rx_pol_inv(dd, val); 578 if (r < 0) { 579 ret = r; 580 goto bail; 581 } 582 583 goto bail; 584invalid: 585 ipath_dev_err(dd, "attempt to set invalid Rx Polarity invert\n"); 586bail: 587 return ret; 588} 589 590 591static DRIVER_ATTR(num_units, S_IRUGO, show_num_units, NULL); 592static DRIVER_ATTR(version, S_IRUGO, show_version, NULL); 593 594static struct attribute *driver_attributes[] = { 595 &driver_attr_num_units.attr, 596 &driver_attr_version.attr, 597 NULL 598}; 599 600static struct attribute_group driver_attr_group = { 601 .attrs = driver_attributes 602}; 603 604static DEVICE_ATTR(guid, S_IWUSR | S_IRUGO, show_guid, store_guid); 605static DEVICE_ATTR(lid, S_IWUSR | S_IRUGO, show_lid, store_lid); 606static DEVICE_ATTR(link_state, S_IWUSR, NULL, store_link_state); 607static DEVICE_ATTR(mlid, S_IWUSR | S_IRUGO, show_mlid, store_mlid); 608static DEVICE_ATTR(mtu, S_IWUSR | S_IRUGO, show_mtu, store_mtu); 609static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, show_enabled, store_enabled); 610static DEVICE_ATTR(nguid, S_IRUGO, show_nguid, NULL); 611static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset); 612static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); 613static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 614static DEVICE_ATTR(status_str, S_IRUGO, show_status_str, NULL); 615static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); 616static DEVICE_ATTR(unit, S_IRUGO, show_unit, NULL); 617static DEVICE_ATTR(rx_pol_inv, S_IWUSR, NULL, store_rx_pol_inv); 618 619static struct attribute *dev_attributes[] = { 620 &dev_attr_guid.attr, 621 &dev_attr_lid.attr, 622 &dev_attr_link_state.attr, 623 &dev_attr_mlid.attr, 624 &dev_attr_mtu.attr, 625 &dev_attr_nguid.attr, 626 &dev_attr_serial.attr, 627 &dev_attr_status.attr, 628 &dev_attr_status_str.attr, 629 &dev_attr_boardversion.attr, 630 &dev_attr_unit.attr, 631 &dev_attr_enabled.attr, 632 &dev_attr_rx_pol_inv.attr, 633 NULL 634}; 635 636static struct attribute_group dev_attr_group = { 637 .attrs = dev_attributes 638}; 639 640/** 641 * ipath_expose_reset - create a device reset file 642 * @dev: the device structure 643 * 644 * Only expose a file that lets us reset the device after someone 645 * enters diag mode. A device reset is quite likely to crash the 646 * machine entirely, so we don't want to normally make it 647 * available. 648 * 649 * Called with ipath_mutex held. 650 */ 651int ipath_expose_reset(struct device *dev) 652{ 653 static int exposed; 654 int ret; 655 656 if (!exposed) { 657 ret = device_create_file(dev, &dev_attr_reset); 658 exposed = 1; 659 } 660 else 661 ret = 0; 662 663 return ret; 664} 665 666int ipath_driver_create_group(struct device_driver *drv) 667{ 668 int ret; 669 670 ret = sysfs_create_group(&drv->kobj, &driver_attr_group); 671 672 return ret; 673} 674 675void ipath_driver_remove_group(struct device_driver *drv) 676{ 677 sysfs_remove_group(&drv->kobj, &driver_attr_group); 678} 679 680int ipath_device_create_group(struct device *dev, struct ipath_devdata *dd) 681{ 682 int ret; 683 char unit[5]; 684 685 ret = sysfs_create_group(&dev->kobj, &dev_attr_group); 686 if (ret) 687 goto bail; 688 689 ret = sysfs_create_group(&dev->kobj, &dev_counter_attr_group); 690 if (ret) 691 goto bail_attrs; 692 693 snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit); 694 ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj, unit); 695 if (ret == 0) 696 goto bail; 697 698 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 699bail_attrs: 700 sysfs_remove_group(&dev->kobj, &dev_attr_group); 701bail: 702 return ret; 703} 704 705void ipath_device_remove_group(struct device *dev, struct ipath_devdata *dd) 706{ 707 char unit[5]; 708 709 snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit); 710 sysfs_remove_link(&dev->driver->kobj, unit); 711 712 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 713 sysfs_remove_group(&dev->kobj, &dev_attr_group); 714 715 device_remove_file(dev, &dev_attr_reset); 716} 717