ipath_sysfs.c revision 2a543904ddcb463db9d56d1efcb2f80884ea55f3
1/* 2 * Copyright (c) 2006, 2007, 2008 QLogic Corporation. 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 36#include "ipath_kernel.h" 37#include "ipath_verbs.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_localbus_info(struct device *dev, 168 struct device_attribute *attr, 169 char *buf) 170{ 171 struct ipath_devdata *dd = dev_get_drvdata(dev); 172 /* The string printed here is already newline-terminated. */ 173 return scnprintf(buf, PAGE_SIZE, "%s", dd->ipath_lbus_info); 174} 175 176static ssize_t show_lmc(struct device *dev, 177 struct device_attribute *attr, 178 char *buf) 179{ 180 struct ipath_devdata *dd = dev_get_drvdata(dev); 181 182 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_lmc); 183} 184 185static ssize_t store_lmc(struct device *dev, 186 struct device_attribute *attr, 187 const char *buf, 188 size_t count) 189{ 190 struct ipath_devdata *dd = dev_get_drvdata(dev); 191 u16 lmc = 0; 192 int ret; 193 194 ret = ipath_parse_ushort(buf, &lmc); 195 if (ret < 0) 196 goto invalid; 197 198 if (lmc > 7) { 199 ret = -EINVAL; 200 goto invalid; 201 } 202 203 ipath_set_lid(dd, dd->ipath_lid, lmc); 204 205 goto bail; 206invalid: 207 ipath_dev_err(dd, "attempt to set invalid LMC %u\n", lmc); 208bail: 209 return ret; 210} 211 212static ssize_t show_lid(struct device *dev, 213 struct device_attribute *attr, 214 char *buf) 215{ 216 struct ipath_devdata *dd = dev_get_drvdata(dev); 217 218 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_lid); 219} 220 221static ssize_t store_lid(struct device *dev, 222 struct device_attribute *attr, 223 const char *buf, 224 size_t count) 225{ 226 struct ipath_devdata *dd = dev_get_drvdata(dev); 227 u16 lid = 0; 228 int ret; 229 230 ret = ipath_parse_ushort(buf, &lid); 231 if (ret < 0) 232 goto invalid; 233 234 if (lid == 0 || lid >= IPATH_MULTICAST_LID_BASE) { 235 ret = -EINVAL; 236 goto invalid; 237 } 238 239 ipath_set_lid(dd, lid, dd->ipath_lmc); 240 241 goto bail; 242invalid: 243 ipath_dev_err(dd, "attempt to set invalid LID 0x%x\n", lid); 244bail: 245 return ret; 246} 247 248static ssize_t show_mlid(struct device *dev, 249 struct device_attribute *attr, 250 char *buf) 251{ 252 struct ipath_devdata *dd = dev_get_drvdata(dev); 253 254 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_mlid); 255} 256 257static ssize_t store_mlid(struct device *dev, 258 struct device_attribute *attr, 259 const char *buf, 260 size_t count) 261{ 262 struct ipath_devdata *dd = dev_get_drvdata(dev); 263 u16 mlid; 264 int ret; 265 266 ret = ipath_parse_ushort(buf, &mlid); 267 if (ret < 0 || mlid < IPATH_MULTICAST_LID_BASE) 268 goto invalid; 269 270 dd->ipath_mlid = mlid; 271 272 goto bail; 273invalid: 274 ipath_dev_err(dd, "attempt to set invalid MLID\n"); 275bail: 276 return ret; 277} 278 279static ssize_t show_guid(struct device *dev, 280 struct device_attribute *attr, 281 char *buf) 282{ 283 struct ipath_devdata *dd = dev_get_drvdata(dev); 284 u8 *guid; 285 286 guid = (u8 *) & (dd->ipath_guid); 287 288 return scnprintf(buf, PAGE_SIZE, 289 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", 290 guid[0], guid[1], guid[2], guid[3], 291 guid[4], guid[5], guid[6], guid[7]); 292} 293 294static ssize_t store_guid(struct device *dev, 295 struct device_attribute *attr, 296 const char *buf, 297 size_t count) 298{ 299 struct ipath_devdata *dd = dev_get_drvdata(dev); 300 ssize_t ret; 301 unsigned short guid[8]; 302 __be64 new_guid; 303 u8 *ng; 304 int i; 305 306 if (sscanf(buf, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx", 307 &guid[0], &guid[1], &guid[2], &guid[3], 308 &guid[4], &guid[5], &guid[6], &guid[7]) != 8) 309 goto invalid; 310 311 ng = (u8 *) &new_guid; 312 313 for (i = 0; i < 8; i++) { 314 if (guid[i] > 0xff) 315 goto invalid; 316 ng[i] = guid[i]; 317 } 318 319 if (new_guid == 0) 320 goto invalid; 321 322 dd->ipath_guid = new_guid; 323 dd->ipath_nguid = 1; 324 if (dd->verbs_dev) 325 dd->verbs_dev->ibdev.node_guid = new_guid; 326 327 ret = strlen(buf); 328 goto bail; 329 330invalid: 331 ipath_dev_err(dd, "attempt to set invalid GUID\n"); 332 ret = -EINVAL; 333 334bail: 335 return ret; 336} 337 338static ssize_t show_nguid(struct device *dev, 339 struct device_attribute *attr, 340 char *buf) 341{ 342 struct ipath_devdata *dd = dev_get_drvdata(dev); 343 344 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_nguid); 345} 346 347static ssize_t show_nports(struct device *dev, 348 struct device_attribute *attr, 349 char *buf) 350{ 351 struct ipath_devdata *dd = dev_get_drvdata(dev); 352 353 /* Return the number of user ports available. */ 354 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_cfgports - 1); 355} 356 357static ssize_t show_serial(struct device *dev, 358 struct device_attribute *attr, 359 char *buf) 360{ 361 struct ipath_devdata *dd = dev_get_drvdata(dev); 362 363 buf[sizeof dd->ipath_serial] = '\0'; 364 memcpy(buf, dd->ipath_serial, sizeof dd->ipath_serial); 365 strcat(buf, "\n"); 366 return strlen(buf); 367} 368 369static ssize_t show_unit(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372{ 373 struct ipath_devdata *dd = dev_get_drvdata(dev); 374 375 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_unit); 376} 377 378static ssize_t show_jint_max_packets(struct device *dev, 379 struct device_attribute *attr, 380 char *buf) 381{ 382 struct ipath_devdata *dd = dev_get_drvdata(dev); 383 384 return scnprintf(buf, PAGE_SIZE, "%hu\n", dd->ipath_jint_max_packets); 385} 386 387static ssize_t store_jint_max_packets(struct device *dev, 388 struct device_attribute *attr, 389 const char *buf, 390 size_t count) 391{ 392 struct ipath_devdata *dd = dev_get_drvdata(dev); 393 u16 v = 0; 394 int ret; 395 396 ret = ipath_parse_ushort(buf, &v); 397 if (ret < 0) 398 ipath_dev_err(dd, "invalid jint_max_packets.\n"); 399 else 400 dd->ipath_f_config_jint(dd, dd->ipath_jint_idle_ticks, v); 401 402 return ret; 403} 404 405static ssize_t show_jint_idle_ticks(struct device *dev, 406 struct device_attribute *attr, 407 char *buf) 408{ 409 struct ipath_devdata *dd = dev_get_drvdata(dev); 410 411 return scnprintf(buf, PAGE_SIZE, "%hu\n", dd->ipath_jint_idle_ticks); 412} 413 414static ssize_t store_jint_idle_ticks(struct device *dev, 415 struct device_attribute *attr, 416 const char *buf, 417 size_t count) 418{ 419 struct ipath_devdata *dd = dev_get_drvdata(dev); 420 u16 v = 0; 421 int ret; 422 423 ret = ipath_parse_ushort(buf, &v); 424 if (ret < 0) 425 ipath_dev_err(dd, "invalid jint_idle_ticks.\n"); 426 else 427 dd->ipath_f_config_jint(dd, v, dd->ipath_jint_max_packets); 428 429 return ret; 430} 431 432#define DEVICE_COUNTER(name, attr) \ 433 static ssize_t show_counter_##name(struct device *dev, \ 434 struct device_attribute *attr, \ 435 char *buf) \ 436 { \ 437 struct ipath_devdata *dd = dev_get_drvdata(dev); \ 438 return scnprintf(\ 439 buf, PAGE_SIZE, "%llu\n", (unsigned long long) \ 440 ipath_snap_cntr( \ 441 dd, offsetof(struct infinipath_counters, \ 442 attr) / sizeof(u64))); \ 443 } \ 444 static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL); 445 446DEVICE_COUNTER(ib_link_downeds, IBLinkDownedCnt); 447DEVICE_COUNTER(ib_link_err_recoveries, IBLinkErrRecoveryCnt); 448DEVICE_COUNTER(ib_status_changes, IBStatusChangeCnt); 449DEVICE_COUNTER(ib_symbol_errs, IBSymbolErrCnt); 450DEVICE_COUNTER(lb_flow_stalls, LBFlowStallCnt); 451DEVICE_COUNTER(lb_ints, LBIntCnt); 452DEVICE_COUNTER(rx_bad_formats, RxBadFormatCnt); 453DEVICE_COUNTER(rx_buf_ovfls, RxBufOvflCnt); 454DEVICE_COUNTER(rx_data_pkts, RxDataPktCnt); 455DEVICE_COUNTER(rx_dropped_pkts, RxDroppedPktCnt); 456DEVICE_COUNTER(rx_dwords, RxDwordCnt); 457DEVICE_COUNTER(rx_ebps, RxEBPCnt); 458DEVICE_COUNTER(rx_flow_ctrl_errs, RxFlowCtrlErrCnt); 459DEVICE_COUNTER(rx_flow_pkts, RxFlowPktCnt); 460DEVICE_COUNTER(rx_icrc_errs, RxICRCErrCnt); 461DEVICE_COUNTER(rx_len_errs, RxLenErrCnt); 462DEVICE_COUNTER(rx_link_problems, RxLinkProblemCnt); 463DEVICE_COUNTER(rx_lpcrc_errs, RxLPCRCErrCnt); 464DEVICE_COUNTER(rx_max_min_len_errs, RxMaxMinLenErrCnt); 465DEVICE_COUNTER(rx_p0_hdr_egr_ovfls, RxP0HdrEgrOvflCnt); 466DEVICE_COUNTER(rx_p1_hdr_egr_ovfls, RxP1HdrEgrOvflCnt); 467DEVICE_COUNTER(rx_p2_hdr_egr_ovfls, RxP2HdrEgrOvflCnt); 468DEVICE_COUNTER(rx_p3_hdr_egr_ovfls, RxP3HdrEgrOvflCnt); 469DEVICE_COUNTER(rx_p4_hdr_egr_ovfls, RxP4HdrEgrOvflCnt); 470DEVICE_COUNTER(rx_p5_hdr_egr_ovfls, RxP5HdrEgrOvflCnt); 471DEVICE_COUNTER(rx_p6_hdr_egr_ovfls, RxP6HdrEgrOvflCnt); 472DEVICE_COUNTER(rx_p7_hdr_egr_ovfls, RxP7HdrEgrOvflCnt); 473DEVICE_COUNTER(rx_p8_hdr_egr_ovfls, RxP8HdrEgrOvflCnt); 474DEVICE_COUNTER(rx_pkey_mismatches, RxPKeyMismatchCnt); 475DEVICE_COUNTER(rx_tid_full_errs, RxTIDFullErrCnt); 476DEVICE_COUNTER(rx_tid_valid_errs, RxTIDValidErrCnt); 477DEVICE_COUNTER(rx_vcrc_errs, RxVCRCErrCnt); 478DEVICE_COUNTER(tx_data_pkts, TxDataPktCnt); 479DEVICE_COUNTER(tx_dropped_pkts, TxDroppedPktCnt); 480DEVICE_COUNTER(tx_dwords, TxDwordCnt); 481DEVICE_COUNTER(tx_flow_pkts, TxFlowPktCnt); 482DEVICE_COUNTER(tx_flow_stalls, TxFlowStallCnt); 483DEVICE_COUNTER(tx_len_errs, TxLenErrCnt); 484DEVICE_COUNTER(tx_max_min_len_errs, TxMaxMinLenErrCnt); 485DEVICE_COUNTER(tx_underruns, TxUnderrunCnt); 486DEVICE_COUNTER(tx_unsup_vl_errs, TxUnsupVLErrCnt); 487 488static struct attribute *dev_counter_attributes[] = { 489 &dev_attr_ib_link_downeds.attr, 490 &dev_attr_ib_link_err_recoveries.attr, 491 &dev_attr_ib_status_changes.attr, 492 &dev_attr_ib_symbol_errs.attr, 493 &dev_attr_lb_flow_stalls.attr, 494 &dev_attr_lb_ints.attr, 495 &dev_attr_rx_bad_formats.attr, 496 &dev_attr_rx_buf_ovfls.attr, 497 &dev_attr_rx_data_pkts.attr, 498 &dev_attr_rx_dropped_pkts.attr, 499 &dev_attr_rx_dwords.attr, 500 &dev_attr_rx_ebps.attr, 501 &dev_attr_rx_flow_ctrl_errs.attr, 502 &dev_attr_rx_flow_pkts.attr, 503 &dev_attr_rx_icrc_errs.attr, 504 &dev_attr_rx_len_errs.attr, 505 &dev_attr_rx_link_problems.attr, 506 &dev_attr_rx_lpcrc_errs.attr, 507 &dev_attr_rx_max_min_len_errs.attr, 508 &dev_attr_rx_p0_hdr_egr_ovfls.attr, 509 &dev_attr_rx_p1_hdr_egr_ovfls.attr, 510 &dev_attr_rx_p2_hdr_egr_ovfls.attr, 511 &dev_attr_rx_p3_hdr_egr_ovfls.attr, 512 &dev_attr_rx_p4_hdr_egr_ovfls.attr, 513 &dev_attr_rx_p5_hdr_egr_ovfls.attr, 514 &dev_attr_rx_p6_hdr_egr_ovfls.attr, 515 &dev_attr_rx_p7_hdr_egr_ovfls.attr, 516 &dev_attr_rx_p8_hdr_egr_ovfls.attr, 517 &dev_attr_rx_pkey_mismatches.attr, 518 &dev_attr_rx_tid_full_errs.attr, 519 &dev_attr_rx_tid_valid_errs.attr, 520 &dev_attr_rx_vcrc_errs.attr, 521 &dev_attr_tx_data_pkts.attr, 522 &dev_attr_tx_dropped_pkts.attr, 523 &dev_attr_tx_dwords.attr, 524 &dev_attr_tx_flow_pkts.attr, 525 &dev_attr_tx_flow_stalls.attr, 526 &dev_attr_tx_len_errs.attr, 527 &dev_attr_tx_max_min_len_errs.attr, 528 &dev_attr_tx_underruns.attr, 529 &dev_attr_tx_unsup_vl_errs.attr, 530 NULL 531}; 532 533static struct attribute_group dev_counter_attr_group = { 534 .name = "counters", 535 .attrs = dev_counter_attributes 536}; 537 538static ssize_t store_reset(struct device *dev, 539 struct device_attribute *attr, 540 const char *buf, 541 size_t count) 542{ 543 struct ipath_devdata *dd = dev_get_drvdata(dev); 544 int ret; 545 546 if (count < 5 || memcmp(buf, "reset", 5)) { 547 ret = -EINVAL; 548 goto bail; 549 } 550 551 if (dd->ipath_flags & IPATH_DISABLED) { 552 /* 553 * post-reset init would re-enable interrupts, etc. 554 * so don't allow reset on disabled devices. Not 555 * perfect error, but about the best choice. 556 */ 557 dev_info(dev,"Unit %d is disabled, can't reset\n", 558 dd->ipath_unit); 559 ret = -EINVAL; 560 goto bail; 561 } 562 ret = ipath_reset_device(dd->ipath_unit); 563bail: 564 return ret<0 ? ret : count; 565} 566 567static ssize_t store_link_state(struct device *dev, 568 struct device_attribute *attr, 569 const char *buf, 570 size_t count) 571{ 572 struct ipath_devdata *dd = dev_get_drvdata(dev); 573 int ret, r; 574 u16 state; 575 576 ret = ipath_parse_ushort(buf, &state); 577 if (ret < 0) 578 goto invalid; 579 580 r = ipath_set_linkstate(dd, state); 581 if (r < 0) { 582 ret = r; 583 goto bail; 584 } 585 586 goto bail; 587invalid: 588 ipath_dev_err(dd, "attempt to set invalid link state\n"); 589bail: 590 return ret; 591} 592 593static ssize_t show_mtu(struct device *dev, 594 struct device_attribute *attr, 595 char *buf) 596{ 597 struct ipath_devdata *dd = dev_get_drvdata(dev); 598 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_ibmtu); 599} 600 601static ssize_t store_mtu(struct device *dev, 602 struct device_attribute *attr, 603 const char *buf, 604 size_t count) 605{ 606 struct ipath_devdata *dd = dev_get_drvdata(dev); 607 ssize_t ret; 608 u16 mtu = 0; 609 int r; 610 611 ret = ipath_parse_ushort(buf, &mtu); 612 if (ret < 0) 613 goto invalid; 614 615 r = ipath_set_mtu(dd, mtu); 616 if (r < 0) 617 ret = r; 618 619 goto bail; 620invalid: 621 ipath_dev_err(dd, "attempt to set invalid MTU\n"); 622bail: 623 return ret; 624} 625 626static ssize_t show_enabled(struct device *dev, 627 struct device_attribute *attr, 628 char *buf) 629{ 630 struct ipath_devdata *dd = dev_get_drvdata(dev); 631 return scnprintf(buf, PAGE_SIZE, "%u\n", 632 (dd->ipath_flags & IPATH_DISABLED) ? 0 : 1); 633} 634 635static ssize_t store_enabled(struct device *dev, 636 struct device_attribute *attr, 637 const char *buf, 638 size_t count) 639{ 640 struct ipath_devdata *dd = dev_get_drvdata(dev); 641 ssize_t ret; 642 u16 enable = 0; 643 644 ret = ipath_parse_ushort(buf, &enable); 645 if (ret < 0) { 646 ipath_dev_err(dd, "attempt to use non-numeric on enable\n"); 647 goto bail; 648 } 649 650 if (enable) { 651 if (!(dd->ipath_flags & IPATH_DISABLED)) 652 goto bail; 653 654 dev_info(dev, "Enabling unit %d\n", dd->ipath_unit); 655 /* same as post-reset */ 656 ret = ipath_init_chip(dd, 1); 657 if (ret) 658 ipath_dev_err(dd, "Failed to enable unit %d\n", 659 dd->ipath_unit); 660 else { 661 dd->ipath_flags &= ~IPATH_DISABLED; 662 *dd->ipath_statusp &= ~IPATH_STATUS_ADMIN_DISABLED; 663 } 664 } 665 else if (!(dd->ipath_flags & IPATH_DISABLED)) { 666 dev_info(dev, "Disabling unit %d\n", dd->ipath_unit); 667 ipath_shutdown_device(dd); 668 dd->ipath_flags |= IPATH_DISABLED; 669 *dd->ipath_statusp |= IPATH_STATUS_ADMIN_DISABLED; 670 } 671 672bail: 673 return ret; 674} 675 676static ssize_t store_rx_pol_inv(struct device *dev, 677 struct device_attribute *attr, 678 const char *buf, 679 size_t count) 680{ 681 struct ipath_devdata *dd = dev_get_drvdata(dev); 682 int ret, r; 683 u16 val; 684 685 ret = ipath_parse_ushort(buf, &val); 686 if (ret < 0) 687 goto invalid; 688 689 r = ipath_set_rx_pol_inv(dd, val); 690 if (r < 0) { 691 ret = r; 692 goto bail; 693 } 694 695 goto bail; 696invalid: 697 ipath_dev_err(dd, "attempt to set invalid Rx Polarity invert\n"); 698bail: 699 return ret; 700} 701 702static ssize_t store_led_override(struct device *dev, 703 struct device_attribute *attr, 704 const char *buf, 705 size_t count) 706{ 707 struct ipath_devdata *dd = dev_get_drvdata(dev); 708 int ret; 709 u16 val; 710 711 ret = ipath_parse_ushort(buf, &val); 712 if (ret > 0) 713 ipath_set_led_override(dd, val); 714 else 715 ipath_dev_err(dd, "attempt to set invalid LED override\n"); 716 return ret; 717} 718 719static ssize_t show_logged_errs(struct device *dev, 720 struct device_attribute *attr, 721 char *buf) 722{ 723 struct ipath_devdata *dd = dev_get_drvdata(dev); 724 int idx, count; 725 726 /* force consistency with actual EEPROM */ 727 if (ipath_update_eeprom_log(dd) != 0) 728 return -ENXIO; 729 730 count = 0; 731 for (idx = 0; idx < IPATH_EEP_LOG_CNT; ++idx) { 732 count += scnprintf(buf + count, PAGE_SIZE - count, "%d%c", 733 dd->ipath_eep_st_errs[idx], 734 idx == (IPATH_EEP_LOG_CNT - 1) ? '\n' : ' '); 735 } 736 737 return count; 738} 739 740/* 741 * New sysfs entries to control various IB config. These all turn into 742 * accesses via ipath_f_get/set_ib_cfg. 743 * 744 * Get/Set heartbeat enable. Or of 1=enabled, 2=auto 745 */ 746static ssize_t show_hrtbt_enb(struct device *dev, 747 struct device_attribute *attr, 748 char *buf) 749{ 750 struct ipath_devdata *dd = dev_get_drvdata(dev); 751 int ret; 752 753 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_HRTBT); 754 if (ret >= 0) 755 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 756 return ret; 757} 758 759static ssize_t store_hrtbt_enb(struct device *dev, 760 struct device_attribute *attr, 761 const char *buf, 762 size_t count) 763{ 764 struct ipath_devdata *dd = dev_get_drvdata(dev); 765 int ret, r; 766 u16 val; 767 768 ret = ipath_parse_ushort(buf, &val); 769 if (ret >= 0 && val > 3) 770 ret = -EINVAL; 771 if (ret < 0) { 772 ipath_dev_err(dd, "attempt to set invalid Heartbeat enable\n"); 773 goto bail; 774 } 775 776 /* 777 * Set the "intentional" heartbeat enable per either of 778 * "Enable" and "Auto", as these are normally set together. 779 * This bit is consulted when leaving loopback mode, 780 * because entering loopback mode overrides it and automatically 781 * disables heartbeat. 782 */ 783 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_HRTBT, val); 784 if (r < 0) 785 ret = r; 786 else if (val == IPATH_IB_HRTBT_OFF) 787 dd->ipath_flags |= IPATH_NO_HRTBT; 788 else 789 dd->ipath_flags &= ~IPATH_NO_HRTBT; 790 791bail: 792 return ret; 793} 794 795/* 796 * Get/Set Link-widths enabled. Or of 1=1x, 2=4x (this is human/IB centric, 797 * _not_ the particular encoding of any given chip) 798 */ 799static ssize_t show_lwid_enb(struct device *dev, 800 struct device_attribute *attr, 801 char *buf) 802{ 803 struct ipath_devdata *dd = dev_get_drvdata(dev); 804 int ret; 805 806 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LWID_ENB); 807 if (ret >= 0) 808 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 809 return ret; 810} 811 812static ssize_t store_lwid_enb(struct device *dev, 813 struct device_attribute *attr, 814 const char *buf, 815 size_t count) 816{ 817 struct ipath_devdata *dd = dev_get_drvdata(dev); 818 int ret, r; 819 u16 val; 820 821 ret = ipath_parse_ushort(buf, &val); 822 if (ret >= 0 && (val == 0 || val > 3)) 823 ret = -EINVAL; 824 if (ret < 0) { 825 ipath_dev_err(dd, 826 "attempt to set invalid Link Width (enable)\n"); 827 goto bail; 828 } 829 830 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_LWID_ENB, val); 831 if (r < 0) 832 ret = r; 833 834bail: 835 return ret; 836} 837 838/* Get current link width */ 839static ssize_t show_lwid(struct device *dev, 840 struct device_attribute *attr, 841 char *buf) 842 843{ 844 struct ipath_devdata *dd = dev_get_drvdata(dev); 845 int ret; 846 847 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LWID); 848 if (ret >= 0) 849 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 850 return ret; 851} 852 853/* 854 * Get/Set Link-speeds enabled. Or of 1=SDR 2=DDR. 855 */ 856static ssize_t show_spd_enb(struct device *dev, 857 struct device_attribute *attr, 858 char *buf) 859{ 860 struct ipath_devdata *dd = dev_get_drvdata(dev); 861 int ret; 862 863 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_SPD_ENB); 864 if (ret >= 0) 865 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 866 return ret; 867} 868 869static ssize_t store_spd_enb(struct device *dev, 870 struct device_attribute *attr, 871 const char *buf, 872 size_t count) 873{ 874 struct ipath_devdata *dd = dev_get_drvdata(dev); 875 int ret, r; 876 u16 val; 877 878 ret = ipath_parse_ushort(buf, &val); 879 if (ret >= 0 && (val == 0 || val > (IPATH_IB_SDR | IPATH_IB_DDR))) 880 ret = -EINVAL; 881 if (ret < 0) { 882 ipath_dev_err(dd, 883 "attempt to set invalid Link Speed (enable)\n"); 884 goto bail; 885 } 886 887 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_SPD_ENB, val); 888 if (r < 0) 889 ret = r; 890 891bail: 892 return ret; 893} 894 895/* Get current link speed */ 896static ssize_t show_spd(struct device *dev, 897 struct device_attribute *attr, 898 char *buf) 899{ 900 struct ipath_devdata *dd = dev_get_drvdata(dev); 901 int ret; 902 903 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_SPD); 904 if (ret >= 0) 905 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 906 return ret; 907} 908 909/* 910 * Get/Set RX polarity-invert enable. 0=no, 1=yes. 911 */ 912static ssize_t show_rx_polinv_enb(struct device *dev, 913 struct device_attribute *attr, 914 char *buf) 915{ 916 struct ipath_devdata *dd = dev_get_drvdata(dev); 917 int ret; 918 919 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_RXPOL_ENB); 920 if (ret >= 0) 921 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 922 return ret; 923} 924 925static ssize_t store_rx_polinv_enb(struct device *dev, 926 struct device_attribute *attr, 927 const char *buf, 928 size_t count) 929{ 930 struct ipath_devdata *dd = dev_get_drvdata(dev); 931 int ret, r; 932 u16 val; 933 934 ret = ipath_parse_ushort(buf, &val); 935 if (ret >= 0 && val > 1) { 936 ipath_dev_err(dd, 937 "attempt to set invalid Rx Polarity (enable)\n"); 938 ret = -EINVAL; 939 goto bail; 940 } 941 942 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_RXPOL_ENB, val); 943 if (r < 0) 944 ret = r; 945 946bail: 947 return ret; 948} 949 950/* 951 * Get/Set RX lane-reversal enable. 0=no, 1=yes. 952 */ 953static ssize_t show_lanerev_enb(struct device *dev, 954 struct device_attribute *attr, 955 char *buf) 956{ 957 struct ipath_devdata *dd = dev_get_drvdata(dev); 958 int ret; 959 960 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LREV_ENB); 961 if (ret >= 0) 962 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 963 return ret; 964} 965 966static ssize_t store_lanerev_enb(struct device *dev, 967 struct device_attribute *attr, 968 const char *buf, 969 size_t count) 970{ 971 struct ipath_devdata *dd = dev_get_drvdata(dev); 972 int ret, r; 973 u16 val; 974 975 ret = ipath_parse_ushort(buf, &val); 976 if (ret >= 0 && val > 1) { 977 ret = -EINVAL; 978 ipath_dev_err(dd, 979 "attempt to set invalid Lane reversal (enable)\n"); 980 goto bail; 981 } 982 983 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_LREV_ENB, val); 984 if (r < 0) 985 ret = r; 986 987bail: 988 return ret; 989} 990 991static DRIVER_ATTR(num_units, S_IRUGO, show_num_units, NULL); 992static DRIVER_ATTR(version, S_IRUGO, show_version, NULL); 993 994static struct attribute *driver_attributes[] = { 995 &driver_attr_num_units.attr, 996 &driver_attr_version.attr, 997 NULL 998}; 999 1000static struct attribute_group driver_attr_group = { 1001 .attrs = driver_attributes 1002}; 1003 1004static ssize_t store_tempsense(struct device *dev, 1005 struct device_attribute *attr, 1006 const char *buf, 1007 size_t count) 1008{ 1009 struct ipath_devdata *dd = dev_get_drvdata(dev); 1010 int ret, stat; 1011 u16 val; 1012 1013 ret = ipath_parse_ushort(buf, &val); 1014 if (ret <= 0) { 1015 ipath_dev_err(dd, "attempt to set invalid tempsense config\n"); 1016 goto bail; 1017 } 1018 /* If anything but the highest limit, enable T_CRIT_A "interrupt" */ 1019 stat = ipath_tempsense_write(dd, 9, (val == 0x7f7f) ? 0x80 : 0); 1020 if (stat) { 1021 ipath_dev_err(dd, "Unable to set tempsense config\n"); 1022 ret = -1; 1023 goto bail; 1024 } 1025 stat = ipath_tempsense_write(dd, 0xB, (u8) (val & 0xFF)); 1026 if (stat) { 1027 ipath_dev_err(dd, "Unable to set local Tcrit\n"); 1028 ret = -1; 1029 goto bail; 1030 } 1031 stat = ipath_tempsense_write(dd, 0xD, (u8) (val >> 8)); 1032 if (stat) { 1033 ipath_dev_err(dd, "Unable to set remote Tcrit\n"); 1034 ret = -1; 1035 goto bail; 1036 } 1037 1038bail: 1039 return ret; 1040} 1041 1042/* 1043 * dump tempsense regs. in decimal, to ease shell-scripts. 1044 */ 1045static ssize_t show_tempsense(struct device *dev, 1046 struct device_attribute *attr, 1047 char *buf) 1048{ 1049 struct ipath_devdata *dd = dev_get_drvdata(dev); 1050 int ret; 1051 int idx; 1052 u8 regvals[8]; 1053 1054 ret = -ENXIO; 1055 for (idx = 0; idx < 8; ++idx) { 1056 if (idx == 6) 1057 continue; 1058 ret = ipath_tempsense_read(dd, idx); 1059 if (ret < 0) 1060 break; 1061 regvals[idx] = ret; 1062 } 1063 if (idx == 8) 1064 ret = scnprintf(buf, PAGE_SIZE, "%d %d %02X %02X %d %d\n", 1065 *(signed char *)(regvals), 1066 *(signed char *)(regvals + 1), 1067 regvals[2], regvals[3], 1068 *(signed char *)(regvals + 5), 1069 *(signed char *)(regvals + 7)); 1070 return ret; 1071} 1072 1073const struct attribute_group *ipath_driver_attr_groups[] = { 1074 &driver_attr_group, 1075 NULL, 1076}; 1077 1078static DEVICE_ATTR(guid, S_IWUSR | S_IRUGO, show_guid, store_guid); 1079static DEVICE_ATTR(lmc, S_IWUSR | S_IRUGO, show_lmc, store_lmc); 1080static DEVICE_ATTR(lid, S_IWUSR | S_IRUGO, show_lid, store_lid); 1081static DEVICE_ATTR(link_state, S_IWUSR, NULL, store_link_state); 1082static DEVICE_ATTR(mlid, S_IWUSR | S_IRUGO, show_mlid, store_mlid); 1083static DEVICE_ATTR(mtu, S_IWUSR | S_IRUGO, show_mtu, store_mtu); 1084static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, show_enabled, store_enabled); 1085static DEVICE_ATTR(nguid, S_IRUGO, show_nguid, NULL); 1086static DEVICE_ATTR(nports, S_IRUGO, show_nports, NULL); 1087static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset); 1088static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); 1089static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 1090static DEVICE_ATTR(status_str, S_IRUGO, show_status_str, NULL); 1091static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); 1092static DEVICE_ATTR(unit, S_IRUGO, show_unit, NULL); 1093static DEVICE_ATTR(rx_pol_inv, S_IWUSR, NULL, store_rx_pol_inv); 1094static DEVICE_ATTR(led_override, S_IWUSR, NULL, store_led_override); 1095static DEVICE_ATTR(logged_errors, S_IRUGO, show_logged_errs, NULL); 1096static DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL); 1097static DEVICE_ATTR(jint_max_packets, S_IWUSR | S_IRUGO, 1098 show_jint_max_packets, store_jint_max_packets); 1099static DEVICE_ATTR(jint_idle_ticks, S_IWUSR | S_IRUGO, 1100 show_jint_idle_ticks, store_jint_idle_ticks); 1101static DEVICE_ATTR(tempsense, S_IWUSR | S_IRUGO, 1102 show_tempsense, store_tempsense); 1103 1104static struct attribute *dev_attributes[] = { 1105 &dev_attr_guid.attr, 1106 &dev_attr_lmc.attr, 1107 &dev_attr_lid.attr, 1108 &dev_attr_link_state.attr, 1109 &dev_attr_mlid.attr, 1110 &dev_attr_mtu.attr, 1111 &dev_attr_nguid.attr, 1112 &dev_attr_nports.attr, 1113 &dev_attr_serial.attr, 1114 &dev_attr_status.attr, 1115 &dev_attr_status_str.attr, 1116 &dev_attr_boardversion.attr, 1117 &dev_attr_unit.attr, 1118 &dev_attr_enabled.attr, 1119 &dev_attr_rx_pol_inv.attr, 1120 &dev_attr_led_override.attr, 1121 &dev_attr_logged_errors.attr, 1122 &dev_attr_tempsense.attr, 1123 &dev_attr_localbus_info.attr, 1124 NULL 1125}; 1126 1127static struct attribute_group dev_attr_group = { 1128 .attrs = dev_attributes 1129}; 1130 1131static DEVICE_ATTR(hrtbt_enable, S_IWUSR | S_IRUGO, show_hrtbt_enb, 1132 store_hrtbt_enb); 1133static DEVICE_ATTR(link_width_enable, S_IWUSR | S_IRUGO, show_lwid_enb, 1134 store_lwid_enb); 1135static DEVICE_ATTR(link_width, S_IRUGO, show_lwid, NULL); 1136static DEVICE_ATTR(link_speed_enable, S_IWUSR | S_IRUGO, show_spd_enb, 1137 store_spd_enb); 1138static DEVICE_ATTR(link_speed, S_IRUGO, show_spd, NULL); 1139static DEVICE_ATTR(rx_pol_inv_enable, S_IWUSR | S_IRUGO, show_rx_polinv_enb, 1140 store_rx_polinv_enb); 1141static DEVICE_ATTR(rx_lane_rev_enable, S_IWUSR | S_IRUGO, show_lanerev_enb, 1142 store_lanerev_enb); 1143 1144static struct attribute *dev_ibcfg_attributes[] = { 1145 &dev_attr_hrtbt_enable.attr, 1146 &dev_attr_link_width_enable.attr, 1147 &dev_attr_link_width.attr, 1148 &dev_attr_link_speed_enable.attr, 1149 &dev_attr_link_speed.attr, 1150 &dev_attr_rx_pol_inv_enable.attr, 1151 &dev_attr_rx_lane_rev_enable.attr, 1152 NULL 1153}; 1154 1155static struct attribute_group dev_ibcfg_attr_group = { 1156 .attrs = dev_ibcfg_attributes 1157}; 1158 1159/** 1160 * ipath_expose_reset - create a device reset file 1161 * @dev: the device structure 1162 * 1163 * Only expose a file that lets us reset the device after someone 1164 * enters diag mode. A device reset is quite likely to crash the 1165 * machine entirely, so we don't want to normally make it 1166 * available. 1167 * 1168 * Called with ipath_mutex held. 1169 */ 1170int ipath_expose_reset(struct device *dev) 1171{ 1172 static int exposed; 1173 int ret; 1174 1175 if (!exposed) { 1176 ret = device_create_file(dev, &dev_attr_reset); 1177 exposed = 1; 1178 } 1179 else 1180 ret = 0; 1181 1182 return ret; 1183} 1184 1185int ipath_device_create_group(struct device *dev, struct ipath_devdata *dd) 1186{ 1187 int ret; 1188 1189 ret = sysfs_create_group(&dev->kobj, &dev_attr_group); 1190 if (ret) 1191 goto bail; 1192 1193 ret = sysfs_create_group(&dev->kobj, &dev_counter_attr_group); 1194 if (ret) 1195 goto bail_attrs; 1196 1197 if (dd->ipath_flags & IPATH_HAS_MULT_IB_SPEED) { 1198 ret = device_create_file(dev, &dev_attr_jint_idle_ticks); 1199 if (ret) 1200 goto bail_counter; 1201 ret = device_create_file(dev, &dev_attr_jint_max_packets); 1202 if (ret) 1203 goto bail_idle; 1204 1205 ret = sysfs_create_group(&dev->kobj, &dev_ibcfg_attr_group); 1206 if (ret) 1207 goto bail_max; 1208 } 1209 1210 return 0; 1211 1212bail_max: 1213 device_remove_file(dev, &dev_attr_jint_max_packets); 1214bail_idle: 1215 device_remove_file(dev, &dev_attr_jint_idle_ticks); 1216bail_counter: 1217 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 1218bail_attrs: 1219 sysfs_remove_group(&dev->kobj, &dev_attr_group); 1220bail: 1221 return ret; 1222} 1223 1224void ipath_device_remove_group(struct device *dev, struct ipath_devdata *dd) 1225{ 1226 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group); 1227 1228 if (dd->ipath_flags & IPATH_HAS_MULT_IB_SPEED) { 1229 sysfs_remove_group(&dev->kobj, &dev_ibcfg_attr_group); 1230 device_remove_file(dev, &dev_attr_jint_idle_ticks); 1231 device_remove_file(dev, &dev_attr_jint_max_packets); 1232 } 1233 1234 sysfs_remove_group(&dev->kobj, &dev_attr_group); 1235 1236 device_remove_file(dev, &dev_attr_reset); 1237} 1238