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 const 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 const 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 hw_rev_show(struct device *device, struct device_attribute *attr, 555 char *buf) 556 { 557 struct qib_ibdev *dev = 558 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 559 560 return sprintf(buf, "%x\n", dd_from_dev(dev)->minrev); 561 } 562 static DEVICE_ATTR_RO(hw_rev); 563 564 static ssize_t hca_type_show(struct device *device, 565 struct device_attribute *attr, char *buf) 566 { 567 struct qib_ibdev *dev = 568 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 569 struct qib_devdata *dd = dd_from_dev(dev); 570 int ret; 571 572 if (!dd->boardname) 573 ret = -EINVAL; 574 else 575 ret = scnprintf(buf, PAGE_SIZE, "%s\n", dd->boardname); 576 return ret; 577 } 578 static DEVICE_ATTR_RO(hca_type); 579 static DEVICE_ATTR(board_id, 0444, hca_type_show, NULL); 580 581 static ssize_t version_show(struct device *device, 582 struct device_attribute *attr, char *buf) 583 { 584 /* The string printed here is already newline-terminated. */ 585 return scnprintf(buf, PAGE_SIZE, "%s", (char *)ib_qib_version); 586 } 587 static DEVICE_ATTR_RO(version); 588 589 static ssize_t boardversion_show(struct device *device, 590 struct device_attribute *attr, char *buf) 591 { 592 struct qib_ibdev *dev = 593 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 594 struct qib_devdata *dd = dd_from_dev(dev); 595 596 /* The string printed here is already newline-terminated. */ 597 return scnprintf(buf, PAGE_SIZE, "%s", dd->boardversion); 598 } 599 static DEVICE_ATTR_RO(boardversion); 600 601 static ssize_t localbus_info_show(struct device *device, 602 struct device_attribute *attr, char *buf) 603 { 604 struct qib_ibdev *dev = 605 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 606 struct qib_devdata *dd = dd_from_dev(dev); 607 608 /* The string printed here is already newline-terminated. */ 609 return scnprintf(buf, PAGE_SIZE, "%s", dd->lbus_info); 610 } 611 static DEVICE_ATTR_RO(localbus_info); 612 613 static ssize_t nctxts_show(struct device *device, 614 struct device_attribute *attr, char *buf) 615 { 616 struct qib_ibdev *dev = 617 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 618 struct qib_devdata *dd = dd_from_dev(dev); 619 620 /* Return the number of user ports (contexts) available. */ 621 /* The calculation below deals with a special case where 622 * cfgctxts is set to 1 on a single-port board. */ 623 return scnprintf(buf, PAGE_SIZE, "%u\n", 624 (dd->first_user_ctxt > dd->cfgctxts) ? 0 : 625 (dd->cfgctxts - dd->first_user_ctxt)); 626 } 627 static DEVICE_ATTR_RO(nctxts); 628 629 static ssize_t nfreectxts_show(struct device *device, 630 struct device_attribute *attr, char *buf) 631 { 632 struct qib_ibdev *dev = 633 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 634 struct qib_devdata *dd = dd_from_dev(dev); 635 636 /* Return the number of free user ports (contexts) available. */ 637 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->freectxts); 638 } 639 static DEVICE_ATTR_RO(nfreectxts); 640 641 static ssize_t serial_show(struct device *device, 642 struct device_attribute *attr, char *buf) 643 { 644 struct qib_ibdev *dev = 645 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 646 struct qib_devdata *dd = dd_from_dev(dev); 647 648 buf[sizeof(dd->serial)] = '\0'; 649 memcpy(buf, dd->serial, sizeof(dd->serial)); 650 strcat(buf, "\n"); 651 return strlen(buf); 652 } 653 static DEVICE_ATTR_RO(serial); 654 655 static ssize_t chip_reset_store(struct device *device, 656 struct device_attribute *attr, const char *buf, 657 size_t count) 658 { 659 struct qib_ibdev *dev = 660 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 661 struct qib_devdata *dd = dd_from_dev(dev); 662 int ret; 663 664 if (count < 5 || memcmp(buf, "reset", 5) || !dd->diag_client) { 665 ret = -EINVAL; 666 goto bail; 667 } 668 669 ret = qib_reset_device(dd->unit); 670 bail: 671 return ret < 0 ? ret : count; 672 } 673 static DEVICE_ATTR_WO(chip_reset); 674 675 /* 676 * Dump tempsense regs. in decimal, to ease shell-scripts. 677 */ 678 static ssize_t tempsense_show(struct device *device, 679 struct device_attribute *attr, char *buf) 680 { 681 struct qib_ibdev *dev = 682 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev); 683 struct qib_devdata *dd = dd_from_dev(dev); 684 int ret; 685 int idx; 686 u8 regvals[8]; 687 688 ret = -ENXIO; 689 for (idx = 0; idx < 8; ++idx) { 690 if (idx == 6) 691 continue; 692 ret = dd->f_tempsense_rd(dd, idx); 693 if (ret < 0) 694 break; 695 regvals[idx] = ret; 696 } 697 if (idx == 8) 698 ret = scnprintf(buf, PAGE_SIZE, "%d %d %02X %02X %d %d\n", 699 *(signed char *)(regvals), 700 *(signed char *)(regvals + 1), 701 regvals[2], regvals[3], 702 *(signed char *)(regvals + 5), 703 *(signed char *)(regvals + 7)); 704 return ret; 705 } 706 static DEVICE_ATTR_RO(tempsense); 707 708 /* 709 * end of per-unit (or driver, in some cases, but replicated 710 * per unit) functions 711 */ 712 713 /* start of per-unit file structures and support code */ 714 static struct attribute *qib_attributes[] = { 715 &dev_attr_hw_rev.attr, 716 &dev_attr_hca_type.attr, 717 &dev_attr_board_id.attr, 718 &dev_attr_version.attr, 719 &dev_attr_nctxts.attr, 720 &dev_attr_nfreectxts.attr, 721 &dev_attr_serial.attr, 722 &dev_attr_boardversion.attr, 723 &dev_attr_tempsense.attr, 724 &dev_attr_localbus_info.attr, 725 &dev_attr_chip_reset.attr, 726 NULL, 727 }; 728 729 const struct attribute_group qib_attr_group = { 730 .attrs = qib_attributes, 731 }; 732 733 int qib_create_port_files(struct ib_device *ibdev, u8 port_num, 734 struct kobject *kobj) 735 { 736 struct qib_pportdata *ppd; 737 struct qib_devdata *dd = dd_from_ibdev(ibdev); 738 int ret; 739 740 if (!port_num || port_num > dd->num_pports) { 741 qib_dev_err(dd, 742 "Skipping infiniband class with invalid port %u\n", 743 port_num); 744 ret = -ENODEV; 745 goto bail; 746 } 747 ppd = &dd->pport[port_num - 1]; 748 749 ret = kobject_init_and_add(&ppd->pport_kobj, &qib_port_ktype, kobj, 750 "linkcontrol"); 751 if (ret) { 752 qib_dev_err(dd, 753 "Skipping linkcontrol sysfs info, (err %d) port %u\n", 754 ret, port_num); 755 goto bail; 756 } 757 kobject_uevent(&ppd->pport_kobj, KOBJ_ADD); 758 759 ret = kobject_init_and_add(&ppd->sl2vl_kobj, &qib_sl2vl_ktype, kobj, 760 "sl2vl"); 761 if (ret) { 762 qib_dev_err(dd, 763 "Skipping sl2vl sysfs info, (err %d) port %u\n", 764 ret, port_num); 765 goto bail_link; 766 } 767 kobject_uevent(&ppd->sl2vl_kobj, KOBJ_ADD); 768 769 ret = kobject_init_and_add(&ppd->diagc_kobj, &qib_diagc_ktype, kobj, 770 "diag_counters"); 771 if (ret) { 772 qib_dev_err(dd, 773 "Skipping diag_counters sysfs info, (err %d) port %u\n", 774 ret, port_num); 775 goto bail_sl; 776 } 777 kobject_uevent(&ppd->diagc_kobj, KOBJ_ADD); 778 779 if (!qib_cc_table_size || !ppd->congestion_entries_shadow) 780 return 0; 781 782 ret = kobject_init_and_add(&ppd->pport_cc_kobj, &qib_port_cc_ktype, 783 kobj, "CCMgtA"); 784 if (ret) { 785 qib_dev_err(dd, 786 "Skipping Congestion Control sysfs info, (err %d) port %u\n", 787 ret, port_num); 788 goto bail_diagc; 789 } 790 791 kobject_uevent(&ppd->pport_cc_kobj, KOBJ_ADD); 792 793 ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, 794 &cc_setting_bin_attr); 795 if (ret) { 796 qib_dev_err(dd, 797 "Skipping Congestion Control setting sysfs info, (err %d) port %u\n", 798 ret, port_num); 799 goto bail_cc; 800 } 801 802 ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, 803 &cc_table_bin_attr); 804 if (ret) { 805 qib_dev_err(dd, 806 "Skipping Congestion Control table sysfs info, (err %d) port %u\n", 807 ret, port_num); 808 goto bail_cc_entry_bin; 809 } 810 811 qib_devinfo(dd->pcidev, 812 "IB%u: Congestion Control Agent enabled for port %d\n", 813 dd->unit, port_num); 814 815 return 0; 816 817 bail_cc_entry_bin: 818 sysfs_remove_bin_file(&ppd->pport_cc_kobj, &cc_setting_bin_attr); 819 bail_cc: 820 kobject_put(&ppd->pport_cc_kobj); 821 bail_diagc: 822 kobject_put(&ppd->diagc_kobj); 823 bail_sl: 824 kobject_put(&ppd->sl2vl_kobj); 825 bail_link: 826 kobject_put(&ppd->pport_kobj); 827 bail: 828 return ret; 829 } 830 831 /* 832 * Unregister and remove our files in /sys/class/infiniband. 833 */ 834 void qib_verbs_unregister_sysfs(struct qib_devdata *dd) 835 { 836 struct qib_pportdata *ppd; 837 int i; 838 839 for (i = 0; i < dd->num_pports; i++) { 840 ppd = &dd->pport[i]; 841 if (qib_cc_table_size && 842 ppd->congestion_entries_shadow) { 843 sysfs_remove_bin_file(&ppd->pport_cc_kobj, 844 &cc_setting_bin_attr); 845 sysfs_remove_bin_file(&ppd->pport_cc_kobj, 846 &cc_table_bin_attr); 847 kobject_put(&ppd->pport_cc_kobj); 848 } 849 kobject_put(&ppd->sl2vl_kobj); 850 kobject_put(&ppd->pport_kobj); 851 } 852 } 853