ipath_sysfs.c revision 11b054fe1d453954449a86de178bb98274bb86ef
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 new_guid; 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 *) &new_guid; 270 271 for (i = 0; i < 8; i++) { 272 if (guid[i] > 0xff) 273 goto invalid; 274 ng[i] = guid[i]; 275 } 276 277 if (new_guid == 0) 278 goto invalid; 279 280 dd->ipath_guid = new_guid; 281 dd->ipath_nguid = 1; 282 283 ret = strlen(buf); 284 goto bail; 285 286invalid: 287 ipath_dev_err(dd, "attempt to set invalid GUID\n"); 288 ret = -EINVAL; 289 290bail: 291 return ret; 292} 293 294static ssize_t show_nguid(struct device *dev, 295 struct device_attribute *attr, 296 char *buf) 297{ 298 struct ipath_devdata *dd = dev_get_drvdata(dev); 299 300 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_nguid); 301} 302 303static ssize_t show_nports(struct device *dev, 304 struct device_attribute *attr, 305 char *buf) 306{ 307 struct ipath_devdata *dd = dev_get_drvdata(dev); 308 309 /* Return the number of user ports available. */ 310 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_cfgports - 1); 311} 312 313static ssize_t show_serial(struct device *dev, 314 struct device_attribute *attr, 315 char *buf) 316{ 317 struct ipath_devdata *dd = dev_get_drvdata(dev); 318 319 buf[sizeof dd->ipath_serial] = '\0'; 320 memcpy(buf, dd->ipath_serial, sizeof dd->ipath_serial); 321 strcat(buf, "\n"); 322 return strlen(buf); 323} 324 325static ssize_t show_unit(struct device *dev, 326 struct device_attribute *attr, 327 char *buf) 328{ 329 struct ipath_devdata *dd = dev_get_drvdata(dev); 330 331 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_unit); 332} 333 334#define DEVICE_COUNTER(name, attr) \ 335 static ssize_t show_counter_##name(struct device *dev, \ 336 struct device_attribute *attr, \ 337 char *buf) \ 338 { \ 339 struct ipath_devdata *dd = dev_get_drvdata(dev); \ 340 return scnprintf(\ 341 buf, PAGE_SIZE, "%llu\n", (unsigned long long) \ 342 ipath_snap_cntr( \ 343 dd, offsetof(struct infinipath_counters, \ 344 attr) / sizeof(u64))); \ 345 } \ 346 static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL); 347 348DEVICE_COUNTER(ib_link_downeds, IBLinkDownedCnt); 349DEVICE_COUNTER(ib_link_err_recoveries, IBLinkErrRecoveryCnt); 350DEVICE_COUNTER(ib_status_changes, IBStatusChangeCnt); 351DEVICE_COUNTER(ib_symbol_errs, IBSymbolErrCnt); 352DEVICE_COUNTER(lb_flow_stalls, LBFlowStallCnt); 353DEVICE_COUNTER(lb_ints, LBIntCnt); 354DEVICE_COUNTER(rx_bad_formats, RxBadFormatCnt); 355DEVICE_COUNTER(rx_buf_ovfls, RxBufOvflCnt); 356DEVICE_COUNTER(rx_data_pkts, RxDataPktCnt); 357DEVICE_COUNTER(rx_dropped_pkts, RxDroppedPktCnt); 358DEVICE_COUNTER(rx_dwords, RxDwordCnt); 359DEVICE_COUNTER(rx_ebps, RxEBPCnt); 360DEVICE_COUNTER(rx_flow_ctrl_errs, RxFlowCtrlErrCnt); 361DEVICE_COUNTER(rx_flow_pkts, RxFlowPktCnt); 362DEVICE_COUNTER(rx_icrc_errs, RxICRCErrCnt); 363DEVICE_COUNTER(rx_len_errs, RxLenErrCnt); 364DEVICE_COUNTER(rx_link_problems, RxLinkProblemCnt); 365DEVICE_COUNTER(rx_lpcrc_errs, RxLPCRCErrCnt); 366DEVICE_COUNTER(rx_max_min_len_errs, RxMaxMinLenErrCnt); 367DEVICE_COUNTER(rx_p0_hdr_egr_ovfls, RxP0HdrEgrOvflCnt); 368DEVICE_COUNTER(rx_p1_hdr_egr_ovfls, RxP1HdrEgrOvflCnt); 369DEVICE_COUNTER(rx_p2_hdr_egr_ovfls, RxP2HdrEgrOvflCnt); 370DEVICE_COUNTER(rx_p3_hdr_egr_ovfls, RxP3HdrEgrOvflCnt); 371DEVICE_COUNTER(rx_p4_hdr_egr_ovfls, RxP4HdrEgrOvflCnt); 372DEVICE_COUNTER(rx_p5_hdr_egr_ovfls, RxP5HdrEgrOvflCnt); 373DEVICE_COUNTER(rx_p6_hdr_egr_ovfls, RxP6HdrEgrOvflCnt); 374DEVICE_COUNTER(rx_p7_hdr_egr_ovfls, RxP7HdrEgrOvflCnt); 375DEVICE_COUNTER(rx_p8_hdr_egr_ovfls, RxP8HdrEgrOvflCnt); 376DEVICE_COUNTER(rx_pkey_mismatches, RxPKeyMismatchCnt); 377DEVICE_COUNTER(rx_tid_full_errs, RxTIDFullErrCnt); 378DEVICE_COUNTER(rx_tid_valid_errs, RxTIDValidErrCnt); 379DEVICE_COUNTER(rx_vcrc_errs, RxVCRCErrCnt); 380DEVICE_COUNTER(tx_data_pkts, TxDataPktCnt); 381DEVICE_COUNTER(tx_dropped_pkts, TxDroppedPktCnt); 382DEVICE_COUNTER(tx_dwords, TxDwordCnt); 383DEVICE_COUNTER(tx_flow_pkts, TxFlowPktCnt); 384DEVICE_COUNTER(tx_flow_stalls, TxFlowStallCnt); 385DEVICE_COUNTER(tx_len_errs, TxLenErrCnt); 386DEVICE_COUNTER(tx_max_min_len_errs, TxMaxMinLenErrCnt); 387DEVICE_COUNTER(tx_underruns, TxUnderrunCnt); 388DEVICE_COUNTER(tx_unsup_vl_errs, TxUnsupVLErrCnt); 389 390static struct attribute *dev_counter_attributes[] = { 391 &dev_attr_ib_link_downeds.attr, 392 &dev_attr_ib_link_err_recoveries.attr, 393 &dev_attr_ib_status_changes.attr, 394 &dev_attr_ib_symbol_errs.attr, 395 &dev_attr_lb_flow_stalls.attr, 396 &dev_attr_lb_ints.attr, 397 &dev_attr_rx_bad_formats.attr, 398 &dev_attr_rx_buf_ovfls.attr, 399 &dev_attr_rx_data_pkts.attr, 400 &dev_attr_rx_dropped_pkts.attr, 401 &dev_attr_rx_dwords.attr, 402 &dev_attr_rx_ebps.attr, 403 &dev_attr_rx_flow_ctrl_errs.attr, 404 &dev_attr_rx_flow_pkts.attr, 405 &dev_attr_rx_icrc_errs.attr, 406 &dev_attr_rx_len_errs.attr, 407 &dev_attr_rx_link_problems.attr, 408 &dev_attr_rx_lpcrc_errs.attr, 409 &dev_attr_rx_max_min_len_errs.attr, 410 &dev_attr_rx_p0_hdr_egr_ovfls.attr, 411 &dev_attr_rx_p1_hdr_egr_ovfls.attr, 412 &dev_attr_rx_p2_hdr_egr_ovfls.attr, 413 &dev_attr_rx_p3_hdr_egr_ovfls.attr, 414 &dev_attr_rx_p4_hdr_egr_ovfls.attr, 415 &dev_attr_rx_p5_hdr_egr_ovfls.attr, 416 &dev_attr_rx_p6_hdr_egr_ovfls.attr, 417 &dev_attr_rx_p7_hdr_egr_ovfls.attr, 418 &dev_attr_rx_p8_hdr_egr_ovfls.attr, 419 &dev_attr_rx_pkey_mismatches.attr, 420 &dev_attr_rx_tid_full_errs.attr, 421 &dev_attr_rx_tid_valid_errs.attr, 422 &dev_attr_rx_vcrc_errs.attr, 423 &dev_attr_tx_data_pkts.attr, 424 &dev_attr_tx_dropped_pkts.attr, 425 &dev_attr_tx_dwords.attr, 426 &dev_attr_tx_flow_pkts.attr, 427 &dev_attr_tx_flow_stalls.attr, 428 &dev_attr_tx_len_errs.attr, 429 &dev_attr_tx_max_min_len_errs.attr, 430 &dev_attr_tx_underruns.attr, 431 &dev_attr_tx_unsup_vl_errs.attr, 432 NULL 433}; 434 435static struct attribute_group dev_counter_attr_group = { 436 .name = "counters", 437 .attrs = dev_counter_attributes 438}; 439 440static ssize_t store_reset(struct device *dev, 441 struct device_attribute *attr, 442 const char *buf, 443 size_t count) 444{ 445 struct ipath_devdata *dd = dev_get_drvdata(dev); 446 int ret; 447 448 if (count < 5 || memcmp(buf, "reset", 5)) { 449 ret = -EINVAL; 450 goto bail; 451 } 452 453 if (dd->ipath_flags & IPATH_DISABLED) { 454 /* 455 * post-reset init would re-enable interrupts, etc. 456 * so don't allow reset on disabled devices. Not 457 * perfect error, but about the best choice. 458 */ 459 dev_info(dev,"Unit %d is disabled, can't reset\n", 460 dd->ipath_unit); 461 ret = -EINVAL; 462 } 463 ret = ipath_reset_device(dd->ipath_unit); 464bail: 465 return ret<0 ? ret : count; 466} 467 468static ssize_t store_link_state(struct device *dev, 469 struct device_attribute *attr, 470 const char *buf, 471 size_t count) 472{ 473 struct ipath_devdata *dd = dev_get_drvdata(dev); 474 int ret, r; 475 u16 state; 476 477 ret = ipath_parse_ushort(buf, &state); 478 if (ret < 0) 479 goto invalid; 480 481 r = ipath_set_linkstate(dd, state); 482 if (r < 0) { 483 ret = r; 484 goto bail; 485 } 486 487 goto bail; 488invalid: 489 ipath_dev_err(dd, "attempt to set invalid link state\n"); 490bail: 491 return ret; 492} 493 494static ssize_t show_mtu(struct device *dev, 495 struct device_attribute *attr, 496 char *buf) 497{ 498 struct ipath_devdata *dd = dev_get_drvdata(dev); 499 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_ibmtu); 500} 501 502static ssize_t store_mtu(struct device *dev, 503 struct device_attribute *attr, 504 const char *buf, 505 size_t count) 506{ 507 struct ipath_devdata *dd = dev_get_drvdata(dev); 508 ssize_t ret; 509 u16 mtu = 0; 510 int r; 511 512 ret = ipath_parse_ushort(buf, &mtu); 513 if (ret < 0) 514 goto invalid; 515 516 r = ipath_set_mtu(dd, mtu); 517 if (r < 0) 518 ret = r; 519 520 goto bail; 521invalid: 522 ipath_dev_err(dd, "attempt to set invalid MTU\n"); 523bail: 524 return ret; 525} 526 527static ssize_t show_enabled(struct device *dev, 528 struct device_attribute *attr, 529 char *buf) 530{ 531 struct ipath_devdata *dd = dev_get_drvdata(dev); 532 return scnprintf(buf, PAGE_SIZE, "%u\n", 533 (dd->ipath_flags & IPATH_DISABLED) ? 0 : 1); 534} 535 536static ssize_t store_enabled(struct device *dev, 537 struct device_attribute *attr, 538 const char *buf, 539 size_t count) 540{ 541 struct ipath_devdata *dd = dev_get_drvdata(dev); 542 ssize_t ret; 543 u16 enable = 0; 544 545 ret = ipath_parse_ushort(buf, &enable); 546 if (ret < 0) { 547 ipath_dev_err(dd, "attempt to use non-numeric on enable\n"); 548 goto bail; 549 } 550 551 if (enable) { 552 if (!(dd->ipath_flags & IPATH_DISABLED)) 553 goto bail; 554 555 dev_info(dev, "Enabling unit %d\n", dd->ipath_unit); 556 /* same as post-reset */ 557 ret = ipath_init_chip(dd, 1); 558 if (ret) 559 ipath_dev_err(dd, "Failed to enable unit %d\n", 560 dd->ipath_unit); 561 else { 562 dd->ipath_flags &= ~IPATH_DISABLED; 563 *dd->ipath_statusp &= ~IPATH_STATUS_ADMIN_DISABLED; 564 } 565 } 566 else if (!(dd->ipath_flags & IPATH_DISABLED)) { 567 dev_info(dev, "Disabling unit %d\n", dd->ipath_unit); 568 ipath_shutdown_device(dd); 569 dd->ipath_flags |= IPATH_DISABLED; 570 *dd->ipath_statusp |= IPATH_STATUS_ADMIN_DISABLED; 571 } 572 573bail: 574 return ret; 575} 576 577static ssize_t store_rx_pol_inv(struct device *dev, 578 struct device_attribute *attr, 579 const char *buf, 580 size_t count) 581{ 582 struct ipath_devdata *dd = dev_get_drvdata(dev); 583 int ret, r; 584 u16 val; 585 586 ret = ipath_parse_ushort(buf, &val); 587 if (ret < 0) 588 goto invalid; 589 590 r = ipath_set_rx_pol_inv(dd, val); 591 if (r < 0) { 592 ret = r; 593 goto bail; 594 } 595 596 goto bail; 597invalid: 598 ipath_dev_err(dd, "attempt to set invalid Rx Polarity invert\n"); 599bail: 600 return ret; 601} 602 603 604static DRIVER_ATTR(num_units, S_IRUGO, show_num_units, NULL); 605static DRIVER_ATTR(version, S_IRUGO, show_version, NULL); 606 607static struct attribute *driver_attributes[] = { 608 &driver_attr_num_units.attr, 609 &driver_attr_version.attr, 610 NULL 611}; 612 613static struct attribute_group driver_attr_group = { 614 .attrs = driver_attributes 615}; 616 617static DEVICE_ATTR(guid, S_IWUSR | S_IRUGO, show_guid, store_guid); 618static DEVICE_ATTR(lid, S_IWUSR | S_IRUGO, show_lid, store_lid); 619static DEVICE_ATTR(link_state, S_IWUSR, NULL, store_link_state); 620static DEVICE_ATTR(mlid, S_IWUSR | S_IRUGO, show_mlid, store_mlid); 621static DEVICE_ATTR(mtu, S_IWUSR | S_IRUGO, show_mtu, store_mtu); 622static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, show_enabled, store_enabled); 623static DEVICE_ATTR(nguid, S_IRUGO, show_nguid, NULL); 624static DEVICE_ATTR(nports, S_IRUGO, show_nports, NULL); 625static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset); 626static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); 627static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 628static DEVICE_ATTR(status_str, S_IRUGO, show_status_str, NULL); 629static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); 630static DEVICE_ATTR(unit, S_IRUGO, show_unit, NULL); 631static DEVICE_ATTR(rx_pol_inv, S_IWUSR, NULL, store_rx_pol_inv); 632 633static struct attribute *dev_attributes[] = { 634 &dev_attr_guid.attr, 635 &dev_attr_lid.attr, 636 &dev_attr_link_state.attr, 637 &dev_attr_mlid.attr, 638 &dev_attr_mtu.attr, 639 &dev_attr_nguid.attr, 640 &dev_attr_nports.attr, 641 &dev_attr_serial.attr, 642 &dev_attr_status.attr, 643 &dev_attr_status_str.attr, 644 &dev_attr_boardversion.attr, 645 &dev_attr_unit.attr, 646 &dev_attr_enabled.attr, 647 &dev_attr_rx_pol_inv.attr, 648 NULL 649}; 650 651static struct attribute_group dev_attr_group = { 652 .attrs = dev_attributes 653}; 654 655/** 656 * ipath_expose_reset - create a device reset file 657 * @dev: the device structure 658 * 659 * Only expose a file that lets us reset the device after someone 660 * enters diag mode. A device reset is quite likely to crash the 661 * machine entirely, so we don't want to normally make it 662 * available. 663 * 664 * Called with ipath_mutex held. 665 */ 666int ipath_expose_reset(struct device *dev) 667{ 668 static int exposed; 669 int ret; 670 671 if (!exposed) { 672 ret = device_create_file(dev, &dev_attr_reset); 673 exposed = 1; 674 } 675 else 676 ret = 0; 677 678 return ret; 679} 680 681int ipath_driver_create_group(struct device_driver *drv) 682{ 683 int ret; 684 685 ret = sysfs_create_group(&drv->kobj, &driver_attr_group); 686 687 return ret; 688} 689 690void ipath_driver_remove_group(struct device_driver *drv) 691{ 692 sysfs_remove_group(&drv->kobj, &driver_attr_group); 693} 694 695int ipath_device_create_group(struct device *dev, struct ipath_devdata *dd) 696{ 697 int ret; 698 char unit[5]; 699 700 ret = sysfs_create_group(&dev->kobj, &dev_attr_group); 701 if (ret) 702 goto bail; 703 704 ret = sysfs_create_group(&dev->kobj, &dev_counter_attr_group); 705 if (ret) 706 goto bail_attrs; 707 708 snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit); 709 ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj, unit); 710 if (ret == 0) 711 goto bail; 712 713 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 714bail_attrs: 715 sysfs_remove_group(&dev->kobj, &dev_attr_group); 716bail: 717 return ret; 718} 719 720void ipath_device_remove_group(struct device *dev, struct ipath_devdata *dd) 721{ 722 char unit[5]; 723 724 snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit); 725 sysfs_remove_link(&dev->driver->kobj, unit); 726 727 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 728 sysfs_remove_group(&dev->kobj, &dev_attr_group); 729 730 device_remove_file(dev, &dev_attr_reset); 731} 732