1 /* 2 * Copyright (c) 2012 Intel Corporation. All rights reserved. 3 * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved. 4 * Copyright (c) 2006 PathScale, Inc. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 */ 34 #include <linux/ctype.h> 35 36 #include "qib.h" 37 #include "qib_mad.h" 38 39 /* start of per-port functions */ 40 /* 41 * Get/Set heartbeat enable. OR of 1=enabled, 2=auto 42 */ 43 static ssize_t show_hrtbt_enb(struct qib_pportdata *ppd, char *buf) 44 { 45 struct qib_devdata *dd = ppd->dd; 46 int ret; 47 48 ret = dd->f_get_ib_cfg(ppd, QIB_IB_CFG_HRTBT); 49 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret); 50 return ret; 51 } 52 53 static ssize_t store_hrtbt_enb(struct qib_pportdata *ppd, const char *buf, 54 size_t count) 55 { 56 struct qib_devdata *dd = ppd->dd; 57 int ret; 58 u16 val; 59 60 ret = kstrtou16(buf, 0, &val); 61 if (ret) { 62 qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n"); 63 return ret; 64 } 65 66 /* 67 * Set the "intentional" heartbeat enable per either of 68 * "Enable" and "Auto", as these are normally set together. 69 * This bit is consulted when leaving loopback mode, 70 * because entering loopback mode overrides it and automatically 71 * disables heartbeat. 72 */ 73 ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val); 74 return ret < 0 ? ret : count; 75 } 76 77 static ssize_t store_loopback(struct qib_pportdata *ppd, const char *buf, 78 size_t count) 79 { 80 struct qib_devdata *dd = ppd->dd; 81 int ret = count, r; 82 83 r = dd->f_set_ib_loopback(ppd, buf); 84 if (r < 0) 85 ret = r; 86 87 return ret; 88 } 89 90 static ssize_t store_led_override(struct qib_pportdata *ppd, const char *buf, 91 size_t count) 92 { 93 struct qib_devdata *dd = ppd->dd; 94 int ret; 95 u16 val; 96 97 ret = kstrtou16(buf, 0, &val); 98 if (ret) { 99 qib_dev_err(dd, "attempt to set invalid LED override\n"); 100 return ret; 101 } 102 103 qib_set_led_override(ppd, val); 104 return count; 105 } 106 107 static ssize_t show_status(struct qib_pportdata *ppd, char *buf) 108 { 109 ssize_t ret; 110 111 if (!ppd->statusp) 112 ret = -EINVAL; 113 else 114 ret = scnprintf(buf, PAGE_SIZE, "0x%llx\n", 115 (unsigned long long) *(ppd->statusp)); 116 return ret; 117 } 118 119 /* 120 * For userland compatibility, these offsets must remain fixed. 121 * They are strings for QIB_STATUS_* 122 */ 123 static const char * const qib_status_str[] = { 124 "Initted", 125 "", 126 "", 127 "", 128 "", 129 "Present", 130 "IB_link_up", 131 "IB_configured", 132 "", 133 "Fatal_Hardware_Error", 134 NULL, 135 }; 136 137 static ssize_t show_status_str(struct qib_pportdata *ppd, char *buf) 138 { 139 int i, any; 140 u64 s; 141 ssize_t ret; 142 143 if (!ppd->statusp) { 144 ret = -EINVAL; 145 goto bail; 146 } 147 148 s = *(ppd->statusp); 149 *buf = '\0'; 150 for (any = i = 0; s && qib_status_str[i]; i++) { 151 if (s & 1) { 152 /* if overflow */ 153 if (any && strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE) 154 break; 155 if (strlcat(buf, qib_status_str[i], PAGE_SIZE) >= 156 PAGE_SIZE) 157 break; 158 any = 1; 159 } 160 s >>= 1; 161 } 162 if (any) 163 strlcat(buf, "\n", PAGE_SIZE); 164 165 ret = strlen(buf); 166 167 bail: 168 return ret; 169 } 170 171 /* end of per-port functions */ 172 173 /* 174 * Start of per-port file structures and support code 175 * Because we are fitting into other infrastructure, we have to supply the 176 * full set of kobject/sysfs_ops structures and routines. 177 */ 178 #define QIB_PORT_ATTR(name, mode, show, store) \ 179 static struct qib_port_attr qib_port_attr_##name = \ 180 __ATTR(name, mode, show, store) 181 182 struct qib_port_attr { 183 struct attribute attr; 184 ssize_t (*show)(struct qib_pportdata *, char *); 185 ssize_t (*store)(struct qib_pportdata *, const char *, size_t); 186 }; 187 188 QIB_PORT_ATTR(loopback, S_IWUSR, NULL, store_loopback); 189 QIB_PORT_ATTR(led_override, S_IWUSR, NULL, store_led_override); 190 QIB_PORT_ATTR(hrtbt_enable, S_IWUSR | S_IRUGO, show_hrtbt_enb, 191 store_hrtbt_enb); 192 QIB_PORT_ATTR(status, S_IRUGO, show_status, NULL); 193 QIB_PORT_ATTR(status_str, S_IRUGO, show_status_str, NULL); 194 195 static struct attribute *port_default_attributes[] = { 196 &qib_port_attr_loopback.attr, 197 &qib_port_attr_led_override.attr, 198 &qib_port_attr_hrtbt_enable.attr, 199 &qib_port_attr_status.attr, 200 &qib_port_attr_status_str.attr, 201 NULL 202 }; 203 204 /* 205 * Start of per-port congestion control structures and support code 206 */ 207 208 /* 209 * Congestion control table size followed by table entries 210 */ 211 static ssize_t read_cc_table_bin(struct file *filp, struct kobject *kobj, 212 struct bin_attribute *bin_attr, 213 char *buf, loff_t pos, size_t count) 214 { 215 int ret; 216 struct qib_pportdata *ppd = 217 container_of(kobj, struct qib_pportdata, pport_cc_kobj); 218 219 if (!qib_cc_table_size || !ppd->ccti_entries_shadow) 220 return -EINVAL; 221 222 ret = ppd->total_cct_entry * sizeof(struct ib_cc_table_entry_shadow) 223 + sizeof(__be16); 224 225 if (pos > ret) 226 return -EINVAL; 227 228 if (count > ret - pos) 229 count = ret - pos; 230 231 if (!count) 232 return count; 233 234 spin_lock(&ppd->cc_shadow_lock); 235 memcpy(buf, ppd->ccti_entries_shadow, count); 236 spin_unlock(&ppd->cc_shadow_lock); 237 238 return count; 239 } 240 241 static void qib_port_release(struct kobject *kobj) 242 { 243 /* nothing to do since memory is freed by qib_free_devdata() */ 244 } 245 246 static struct kobj_type qib_port_cc_ktype = { 247 .release = qib_port_release, 248 }; 249 250 static struct bin_attribute cc_table_bin_attr = { 251 .attr = {.name = "cc_table_bin", .mode = 0444}, 252 .read = read_cc_table_bin, 253 .size = PAGE_SIZE, 254 }; 255 256 /* 257 * Congestion settings: port control, control map and an array of 16 258 * entries for the congestion entries - increase, timer, event log 259 * trigger threshold and the minimum injection rate delay. 260 */ 261 static ssize_t read_cc_setting_bin(struct file *filp, struct kobject *kobj, 262 struct bin_attribute *bin_attr, 263 char *buf, loff_t pos, size_t count) 264 { 265 int ret; 266 struct qib_pportdata *ppd = 267 container_of(kobj, struct qib_pportdata, pport_cc_kobj); 268 269 if (!qib_cc_table_size || !ppd->congestion_entries_shadow) 270 return -EINVAL; 271 272 ret = sizeof(struct ib_cc_congestion_setting_attr_shadow); 273 274 if (pos > ret) 275 return -EINVAL; 276 if (count > ret - pos) 277 count = ret - pos; 278 279 if (!count) 280 return count; 281 282 spin_lock(&ppd->cc_shadow_lock); 283 memcpy(buf, ppd->congestion_entries_shadow, count); 284 spin_unlock(&ppd->cc_shadow_lock); 285 286 return count; 287 } 288 289 static struct bin_attribute cc_setting_bin_attr = { 290 .attr = {.name = "cc_settings_bin", .mode = 0444}, 291 .read = read_cc_setting_bin, 292 .size = PAGE_SIZE, 293 }; 294 295 296 static ssize_t qib_portattr_show(struct kobject *kobj, 297 struct attribute *attr, char *buf) 298 { 299 struct qib_port_attr *pattr = 300 container_of(attr, struct qib_port_attr, attr); 301 struct qib_pportdata *ppd = 302 container_of(kobj, struct qib_pportdata, pport_kobj); 303 304 return pattr->show(ppd, buf); 305 } 306 307 static ssize_t qib_portattr_store(struct kobject *kobj, 308 struct attribute *attr, const char *buf, size_t len) 309 { 310 struct qib_port_attr *pattr = 311 container_of(attr, struct qib_port_attr, attr); 312 struct qib_pportdata *ppd = 313 container_of(kobj, struct qib_pportdata, pport_kobj); 314 315 return pattr->store(ppd, buf, len); 316 } 317 318 319 static const struct sysfs_ops qib_port_ops = { 320 .show = qib_portattr_show, 321 .store = qib_portattr_store, 322 }; 323 324 static struct kobj_type qib_port_ktype = { 325 .release = qib_port_release, 326 .sysfs_ops = &qib_port_ops, 327 .default_attrs = port_default_attributes 328 }; 329 330 /* Start sl2vl */ 331 332 #define QIB_SL2VL_ATTR(N) \ 333 static struct qib_sl2vl_attr qib_sl2vl_attr_##N = { \ 334 .attr = { .name = __stringify(N), .mode = 0444 }, \ 335 .sl = N \ 336 } 337 338 struct qib_sl2vl_attr { 339 struct attribute attr; 340 int sl; 341 }; 342 343 QIB_SL2VL_ATTR(0); 344 QIB_SL2VL_ATTR(1); 345 QIB_SL2VL_ATTR(2); 346 QIB_SL2VL_ATTR(3); 347 QIB_SL2VL_ATTR(4); 348 QIB_SL2VL_ATTR(5); 349 QIB_SL2VL_ATTR(6); 350 QIB_SL2VL_ATTR(7); 351 QIB_SL2VL_ATTR(8); 352 QIB_SL2VL_ATTR(9); 353 QIB_SL2VL_ATTR(10); 354 QIB_SL2VL_ATTR(11); 355 QIB_SL2VL_ATTR(12); 356 QIB_SL2VL_ATTR(13); 357 QIB_SL2VL_ATTR(14); 358 QIB_SL2VL_ATTR(15); 359 360 static struct attribute *sl2vl_default_attributes[] = { 361 &qib_sl2vl_attr_0.attr, 362 &qib_sl2vl_attr_1.attr, 363 &qib_sl2vl_attr_2.attr, 364 &qib_sl2vl_attr_3.attr, 365 &qib_sl2vl_attr_4.attr, 366 &qib_sl2vl_attr_5.attr, 367 &qib_sl2vl_attr_6.attr, 368 &qib_sl2vl_attr_7.attr, 369 &qib_sl2vl_attr_8.attr, 370 &qib_sl2vl_attr_9.attr, 371 &qib_sl2vl_attr_10.attr, 372 &qib_sl2vl_attr_11.attr, 373 &qib_sl2vl_attr_12.attr, 374 &qib_sl2vl_attr_13.attr, 375 &qib_sl2vl_attr_14.attr, 376 &qib_sl2vl_attr_15.attr, 377 NULL 378 }; 379 380 static ssize_t sl2vl_attr_show(struct kobject *kobj, struct attribute *attr, 381 char *buf) 382 { 383 struct qib_sl2vl_attr *sattr = 384 container_of(attr, struct qib_sl2vl_attr, attr); 385 struct qib_pportdata *ppd = 386 container_of(kobj, struct qib_pportdata, sl2vl_kobj); 387 struct qib_ibport *qibp = &ppd->ibport_data; 388 389 return sprintf(buf, "%u\n", qibp->sl_to_vl[sattr->sl]); 390 } 391 392 static const struct sysfs_ops qib_sl2vl_ops = { 393 .show = sl2vl_attr_show, 394 }; 395 396 static struct kobj_type qib_sl2vl_ktype = { 397 .release = qib_port_release, 398 .sysfs_ops = &qib_sl2vl_ops, 399 .default_attrs = sl2vl_default_attributes 400 }; 401 402 /* End sl2vl */ 403 404 /* Start diag_counters */ 405 406 #define QIB_DIAGC_ATTR(N) \ 407 static struct qib_diagc_attr qib_diagc_attr_##N = { \ 408 .attr = { .name = __stringify(N), .mode = 0664 }, \ 409 .counter = offsetof(struct qib_ibport, rvp.n_##N) \ 410 } 411 412 #define QIB_DIAGC_ATTR_PER_CPU(N) \ 413 static struct qib_diagc_attr qib_diagc_attr_##N = { \ 414 .attr = { .name = __stringify(N), .mode = 0664 }, \ 415 .counter = offsetof(struct qib_ibport, rvp.z_##N) \ 416 } 417 418 struct qib_diagc_attr { 419 struct attribute attr; 420 size_t counter; 421 }; 422 423 QIB_DIAGC_ATTR_PER_CPU(rc_acks); 424 QIB_DIAGC_ATTR_PER_CPU(rc_qacks); 425 QIB_DIAGC_ATTR_PER_CPU(rc_delayed_comp); 426 427 QIB_DIAGC_ATTR(rc_resends); 428 QIB_DIAGC_ATTR(seq_naks); 429 QIB_DIAGC_ATTR(rdma_seq); 430 QIB_DIAGC_ATTR(rnr_naks); 431 QIB_DIAGC_ATTR(other_naks); 432 QIB_DIAGC_ATTR(rc_timeouts); 433 QIB_DIAGC_ATTR(loop_pkts); 434 QIB_DIAGC_ATTR(pkt_drops); 435 QIB_DIAGC_ATTR(dmawait); 436 QIB_DIAGC_ATTR(unaligned); 437 QIB_DIAGC_ATTR(rc_dupreq); 438 QIB_DIAGC_ATTR(rc_seqnak); 439 440 static struct attribute *diagc_default_attributes[] = { 441 &qib_diagc_attr_rc_resends.attr, 442 &qib_diagc_attr_rc_acks.attr, 443 &qib_diagc_attr_rc_qacks.attr, 444 &qib_diagc_attr_rc_delayed_comp.attr, 445 &qib_diagc_attr_seq_naks.attr, 446 &qib_diagc_attr_rdma_seq.attr, 447 &qib_diagc_attr_rnr_naks.attr, 448 &qib_diagc_attr_other_naks.attr, 449 &qib_diagc_attr_rc_timeouts.attr, 450 &qib_diagc_attr_loop_pkts.attr, 451 &qib_diagc_attr_pkt_drops.attr, 452 &qib_diagc_attr_dmawait.attr, 453 &qib_diagc_attr_unaligned.attr, 454 &qib_diagc_attr_rc_dupreq.attr, 455 &qib_diagc_attr_rc_seqnak.attr, 456 NULL 457 }; 458 459 static u64 get_all_cpu_total(u64 __percpu *cntr) 460 { 461 int cpu; 462 u64 counter = 0; 463 464 for_each_possible_cpu(cpu) 465 counter += *per_cpu_ptr(cntr, cpu); 466 return counter; 467 } 468 469 #define def_write_per_cpu(cntr) \ 470 static void write_per_cpu_##cntr(struct qib_pportdata *ppd, u32 data) \ 471 { \ 472 struct qib_devdata *dd = ppd->dd; \ 473 struct qib_ibport *qibp = &ppd->ibport_data; \ 474 /* A write can only zero the counter */ \ 475 if (data == 0) \ 476 qibp->rvp.z_##cntr = get_all_cpu_total(qibp->rvp.cntr); \ 477 else \ 478 qib_dev_err(dd, "Per CPU cntrs can only be zeroed"); \ 479 } 480 481 def_write_per_cpu(rc_acks) 482 def_write_per_cpu(rc_qacks) 483 def_write_per_cpu(rc_delayed_comp) 484 485 #define READ_PER_CPU_CNTR(cntr) (get_all_cpu_total(qibp->rvp.cntr) - \ 486 qibp->rvp.z_##cntr) 487 488 static ssize_t diagc_attr_show(struct kobject *kobj, struct attribute *attr, 489 char *buf) 490 { 491 struct qib_diagc_attr *dattr = 492 container_of(attr, struct qib_diagc_attr, attr); 493 struct qib_pportdata *ppd = 494 container_of(kobj, struct qib_pportdata, diagc_kobj); 495 struct qib_ibport *qibp = &ppd->ibport_data; 496 497 if (!strncmp(dattr->attr.name, "rc_acks", 7)) 498 return sprintf(buf, "%llu\n", READ_PER_CPU_CNTR(rc_acks)); 499 else if (!strncmp(dattr->attr.name, "rc_qacks", 8)) 500 return sprintf(buf, "%llu\n", READ_PER_CPU_CNTR(rc_qacks)); 501 else if (!strncmp(dattr->attr.name, "rc_delayed_comp", 15)) 502 return sprintf(buf, "%llu\n", 503 READ_PER_CPU_CNTR(rc_delayed_comp)); 504 else 505 return sprintf(buf, "%u\n", 506 *(u32 *)((char *)qibp + dattr->counter)); 507 } 508 509 static ssize_t diagc_attr_store(struct kobject *kobj, struct attribute *attr, 510 const char *buf, size_t size) 511 { 512 struct qib_diagc_attr *dattr = 513 container_of(attr, struct qib_diagc_attr, attr); 514 struct qib_pportdata *ppd = 515 container_of(kobj, struct qib_pportdata, diagc_kobj); 516 struct qib_ibport *qibp = &ppd->ibport_data; 517 u32 val; 518 int ret; 519 520 ret = kstrtou32(buf, 0, &val); 521 if (ret) 522 return ret; 523 524 if (!strncmp(dattr->attr.name, "rc_acks", 7)) 525 write_per_cpu_rc_acks(ppd, val); 526 else if (!strncmp(dattr->attr.name, "rc_qacks", 8)) 527 write_per_cpu_rc_qacks(ppd, val); 528 else if (!strncmp(dattr->attr.name, "rc_delayed_comp", 15)) 529 write_per_cpu_rc_delayed_comp(ppd, val); 530 else 531 *(u32 *)((char *)qibp + dattr->counter) = val; 532 return size; 533 } 534 535 static const struct sysfs_ops qib_diagc_ops = { 536 .show = diagc_attr_show, 537 .store = diagc_attr_store, 538 }; 539 540 static struct kobj_type qib_diagc_ktype = { 541 .release = qib_port_release, 542 .sysfs_ops = &qib_diagc_ops, 543 .default_attrs = diagc_default_attributes 544 }; 545 546 /* End diag_counters */ 547 548 /* end of per-port file structures and support code */ 549 550 /* 551 * Start of per-unit (or driver, in some cases, but replicated 552 * per unit) functions (these get a device *) 553 */ 554 static ssize_t show_rev(struct device *device, struct device_attribute *attr, 555 char *buf) 556 { 557 struct qib_ibdev *dev = 558 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 559 560 return sprintf(buf, "%x\n", dd_from_dev(dev)->minrev); 561 } 562 563 static ssize_t show_hca(struct device *device, struct device_attribute *attr, 564 char *buf) 565 { 566 struct qib_ibdev *dev = 567 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 568 struct qib_devdata *dd = dd_from_dev(dev); 569 int ret; 570 571 if (!dd->boardname) 572 ret = -EINVAL; 573 else 574 ret = scnprintf(buf, PAGE_SIZE, "%s\n", dd->boardname); 575 return ret; 576 } 577 578 static ssize_t show_version(struct device *device, 579 struct device_attribute *attr, char *buf) 580 { 581 /* The string printed here is already newline-terminated. */ 582 return scnprintf(buf, PAGE_SIZE, "%s", (char *)ib_qib_version); 583 } 584 585 static ssize_t show_boardversion(struct device *device, 586 struct device_attribute *attr, char *buf) 587 { 588 struct qib_ibdev *dev = 589 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 590 struct qib_devdata *dd = dd_from_dev(dev); 591 592 /* The string printed here is already newline-terminated. */ 593 return scnprintf(buf, PAGE_SIZE, "%s", dd->boardversion); 594 } 595 596 597 static ssize_t show_localbus_info(struct device *device, 598 struct device_attribute *attr, char *buf) 599 { 600 struct qib_ibdev *dev = 601 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 602 struct qib_devdata *dd = dd_from_dev(dev); 603 604 /* The string printed here is already newline-terminated. */ 605 return scnprintf(buf, PAGE_SIZE, "%s", dd->lbus_info); 606 } 607 608 609 static ssize_t show_nctxts(struct device *device, 610 struct device_attribute *attr, char *buf) 611 { 612 struct qib_ibdev *dev = 613 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 614 struct qib_devdata *dd = dd_from_dev(dev); 615 616 /* Return the number of user ports (contexts) available. */ 617 /* The calculation below deals with a special case where 618 * cfgctxts is set to 1 on a single-port board. */ 619 return scnprintf(buf, PAGE_SIZE, "%u\n", 620 (dd->first_user_ctxt > dd->cfgctxts) ? 0 : 621 (dd->cfgctxts - dd->first_user_ctxt)); 622 } 623 624 static ssize_t show_nfreectxts(struct device *device, 625 struct device_attribute *attr, char *buf) 626 { 627 struct qib_ibdev *dev = 628 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 629 struct qib_devdata *dd = dd_from_dev(dev); 630 631 /* Return the number of free user ports (contexts) available. */ 632 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->freectxts); 633 } 634 635 static ssize_t show_serial(struct device *device, 636 struct device_attribute *attr, char *buf) 637 { 638 struct qib_ibdev *dev = 639 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 640 struct qib_devdata *dd = dd_from_dev(dev); 641 642 buf[sizeof(dd->serial)] = '\0'; 643 memcpy(buf, dd->serial, sizeof(dd->serial)); 644 strcat(buf, "\n"); 645 return strlen(buf); 646 } 647 648 static ssize_t store_chip_reset(struct device *device, 649 struct device_attribute *attr, const char *buf, 650 size_t count) 651 { 652 struct qib_ibdev *dev = 653 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 654 struct qib_devdata *dd = dd_from_dev(dev); 655 int ret; 656 657 if (count < 5 || memcmp(buf, "reset", 5) || !dd->diag_client) { 658 ret = -EINVAL; 659 goto bail; 660 } 661 662 ret = qib_reset_device(dd->unit); 663 bail: 664 return ret < 0 ? ret : count; 665 } 666 667 /* 668 * Dump tempsense regs. in decimal, to ease shell-scripts. 669 */ 670 static ssize_t show_tempsense(struct device *device, 671 struct device_attribute *attr, char *buf) 672 { 673 struct qib_ibdev *dev = 674 container_of(device, struct qib_ibdev, rdi.ibdev.dev); 675 struct qib_devdata *dd = dd_from_dev(dev); 676 int ret; 677 int idx; 678 u8 regvals[8]; 679 680 ret = -ENXIO; 681 for (idx = 0; idx < 8; ++idx) { 682 if (idx == 6) 683 continue; 684 ret = dd->f_tempsense_rd(dd, idx); 685 if (ret < 0) 686 break; 687 regvals[idx] = ret; 688 } 689 if (idx == 8) 690 ret = scnprintf(buf, PAGE_SIZE, "%d %d %02X %02X %d %d\n", 691 *(signed char *)(regvals), 692 *(signed char *)(regvals + 1), 693 regvals[2], regvals[3], 694 *(signed char *)(regvals + 5), 695 *(signed char *)(regvals + 7)); 696 return ret; 697 } 698 699 /* 700 * end of per-unit (or driver, in some cases, but replicated 701 * per unit) functions 702 */ 703 704 /* start of per-unit file structures and support code */ 705 static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); 706 static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); 707 static DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL); 708 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); 709 static DEVICE_ATTR(nctxts, S_IRUGO, show_nctxts, NULL); 710 static DEVICE_ATTR(nfreectxts, S_IRUGO, show_nfreectxts, NULL); 711 static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); 712 static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); 713 static DEVICE_ATTR(tempsense, S_IRUGO, show_tempsense, NULL); 714 static DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL); 715 static DEVICE_ATTR(chip_reset, S_IWUSR, NULL, store_chip_reset); 716 717 static struct device_attribute *qib_attributes[] = { 718 &dev_attr_hw_rev, 719 &dev_attr_hca_type, 720 &dev_attr_board_id, 721 &dev_attr_version, 722 &dev_attr_nctxts, 723 &dev_attr_nfreectxts, 724 &dev_attr_serial, 725 &dev_attr_boardversion, 726 &dev_attr_tempsense, 727 &dev_attr_localbus_info, 728 &dev_attr_chip_reset, 729 }; 730 731 int qib_create_port_files(struct ib_device *ibdev, u8 port_num, 732 struct kobject *kobj) 733 { 734 struct qib_pportdata *ppd; 735 struct qib_devdata *dd = dd_from_ibdev(ibdev); 736 int ret; 737 738 if (!port_num || port_num > dd->num_pports) { 739 qib_dev_err(dd, 740 "Skipping infiniband class with invalid port %u\n", 741 port_num); 742 ret = -ENODEV; 743 goto bail; 744 } 745 ppd = &dd->pport[port_num - 1]; 746 747 ret = kobject_init_and_add(&ppd->pport_kobj, &qib_port_ktype, kobj, 748 "linkcontrol"); 749 if (ret) { 750 qib_dev_err(dd, 751 "Skipping linkcontrol sysfs info, (err %d) port %u\n", 752 ret, port_num); 753 goto bail; 754 } 755 kobject_uevent(&ppd->pport_kobj, KOBJ_ADD); 756 757 ret = kobject_init_and_add(&ppd->sl2vl_kobj, &qib_sl2vl_ktype, kobj, 758 "sl2vl"); 759 if (ret) { 760 qib_dev_err(dd, 761 "Skipping sl2vl sysfs info, (err %d) port %u\n", 762 ret, port_num); 763 goto bail_link; 764 } 765 kobject_uevent(&ppd->sl2vl_kobj, KOBJ_ADD); 766 767 ret = kobject_init_and_add(&ppd->diagc_kobj, &qib_diagc_ktype, kobj, 768 "diag_counters"); 769 if (ret) { 770 qib_dev_err(dd, 771 "Skipping diag_counters sysfs info, (err %d) port %u\n", 772 ret, port_num); 773 goto bail_sl; 774 } 775 kobject_uevent(&ppd->diagc_kobj, KOBJ_ADD); 776 777 if (!qib_cc_table_size || !ppd->congestion_entries_shadow) 778 return 0; 779 780 ret = kobject_init_and_add(&ppd->pport_cc_kobj, &qib_port_cc_ktype, 781 kobj, "CCMgtA"); 782 if (ret) { 783 qib_dev_err(dd, 784 "Skipping Congestion Control sysfs info, (err %d) port %u\n", 785 ret, port_num); 786 goto bail_diagc; 787 } 788 789 kobject_uevent(&ppd->pport_cc_kobj, KOBJ_ADD); 790 791 ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, 792 &cc_setting_bin_attr); 793 if (ret) { 794 qib_dev_err(dd, 795 "Skipping Congestion Control setting sysfs info, (err %d) port %u\n", 796 ret, port_num); 797 goto bail_cc; 798 } 799 800 ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, 801 &cc_table_bin_attr); 802 if (ret) { 803 qib_dev_err(dd, 804 "Skipping Congestion Control table sysfs info, (err %d) port %u\n", 805 ret, port_num); 806 goto bail_cc_entry_bin; 807 } 808 809 qib_devinfo(dd->pcidev, 810 "IB%u: Congestion Control Agent enabled for port %d\n", 811 dd->unit, port_num); 812 813 return 0; 814 815 bail_cc_entry_bin: 816 sysfs_remove_bin_file(&ppd->pport_cc_kobj, &cc_setting_bin_attr); 817 bail_cc: 818 kobject_put(&ppd->pport_cc_kobj); 819 bail_diagc: 820 kobject_put(&ppd->diagc_kobj); 821 bail_sl: 822 kobject_put(&ppd->sl2vl_kobj); 823 bail_link: 824 kobject_put(&ppd->pport_kobj); 825 bail: 826 return ret; 827 } 828 829 /* 830 * Register and create our files in /sys/class/infiniband. 831 */ 832 int qib_verbs_register_sysfs(struct qib_devdata *dd) 833 { 834 struct ib_device *dev = &dd->verbs_dev.rdi.ibdev; 835 int i, ret; 836 837 for (i = 0; i < ARRAY_SIZE(qib_attributes); ++i) { 838 ret = device_create_file(&dev->dev, qib_attributes[i]); 839 if (ret) 840 goto bail; 841 } 842 843 return 0; 844 bail: 845 for (i = 0; i < ARRAY_SIZE(qib_attributes); ++i) 846 device_remove_file(&dev->dev, qib_attributes[i]); 847 return ret; 848 } 849 850 /* 851 * Unregister and remove our files in /sys/class/infiniband. 852 */ 853 void qib_verbs_unregister_sysfs(struct qib_devdata *dd) 854 { 855 struct qib_pportdata *ppd; 856 int i; 857 858 for (i = 0; i < dd->num_pports; i++) { 859 ppd = &dd->pport[i]; 860 if (qib_cc_table_size && 861 ppd->congestion_entries_shadow) { 862 sysfs_remove_bin_file(&ppd->pport_cc_kobj, 863 &cc_setting_bin_attr); 864 sysfs_remove_bin_file(&ppd->pport_cc_kobj, 865 &cc_table_bin_attr); 866 kobject_put(&ppd->pport_cc_kobj); 867 } 868 kobject_put(&ppd->sl2vl_kobj); 869 kobject_put(&ppd->pport_kobj); 870 } 871 } 872