drivers/infiniband/hw/qib/qib_sysfs.c

   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 #include <rdma/ib_sysfs.h>
  36
  37 #include "qib.h"
  38 #include "qib_mad.h"
  39
  40 static struct qib_pportdata *qib_get_pportdata_kobj(struct kobject *kobj)
  41 {
  42         u32 port_num;
  43         struct ib_device *ibdev = ib_port_sysfs_get_ibdev_kobj(kobj, &port_num);
  44         struct qib_devdata *dd = dd_from_ibdev(ibdev);
  45
  46         return &dd->pport[port_num - 1];
  47 }
  48
  49 /*
  50  * Get/Set heartbeat enable. OR of 1=enabled, 2=auto
  51  */
  52 static ssize_t hrtbt_enable_show(struct ib_device *ibdev, u32 port_num,
  53                                  struct ib_port_attribute *attr, char *buf)
  54 {
  55         struct qib_devdata *dd = dd_from_ibdev(ibdev);
  56         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
  57
  58         return sysfs_emit(buf, "%d\n", dd->f_get_ib_cfg(ppd, QIB_IB_CFG_HRTBT));
  59 }
  60
  61 static ssize_t hrtbt_enable_store(struct ib_device *ibdev, u32 port_num,
  62                                   struct ib_port_attribute *attr,
  63                                   const char *buf, size_t count)
  64 {
  65         struct qib_devdata *dd = dd_from_ibdev(ibdev);
  66         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
  67         int ret;
  68         u16 val;
  69
  70         ret = kstrtou16(buf, 0, &val);
  71         if (ret) {
  72                 qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
  73                 return ret;
  74         }
  75
  76         /*
  77          * Set the "intentional" heartbeat enable per either of
  78          * "Enable" and "Auto", as these are normally set together.
  79          * This bit is consulted when leaving loopback mode,
  80          * because entering loopback mode overrides it and automatically
  81          * disables heartbeat.
  82          */
  83         ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val);
  84         return ret < 0 ? ret : count;
  85 }
  86 static IB_PORT_ATTR_RW(hrtbt_enable);
  87
  88 static ssize_t loopback_store(struct ib_device *ibdev, u32 port_num,
  89                               struct ib_port_attribute *attr, const char *buf,
  90                               size_t count)
  91 {
  92         struct qib_devdata *dd = dd_from_ibdev(ibdev);
  93         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
  94         int ret = count, r;
  95
  96         r = dd->f_set_ib_loopback(ppd, buf);
  97         if (r < 0)
  98                 ret = r;
  99
 100         return ret;
 101 }
 102 static IB_PORT_ATTR_WO(loopback);
 103
 104 static ssize_t led_override_store(struct ib_device *ibdev, u32 port_num,
 105                                   struct ib_port_attribute *attr,
 106                                   const char *buf, size_t count)
 107 {
 108         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 109         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
 110         int ret;
 111         u16 val;
 112
 113         ret = kstrtou16(buf, 0, &val);
 114         if (ret) {
 115                 qib_dev_err(dd, "attempt to set invalid LED override\n");
 116                 return ret;
 117         }
 118
 119         qib_set_led_override(ppd, val);
 120         return count;
 121 }
 122 static IB_PORT_ATTR_WO(led_override);
 123
 124 static ssize_t status_show(struct ib_device *ibdev, u32 port_num,
 125                            struct ib_port_attribute *attr, char *buf)
 126 {
 127         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 128         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
 129
 130         if (!ppd->statusp)
 131                 return -EINVAL;
 132
 133         return sysfs_emit(buf, "0x%llx\n", (unsigned long long)*(ppd->statusp));
 134 }
 135 static IB_PORT_ATTR_RO(status);
 136
 137 /*
 138  * For userland compatibility, these offsets must remain fixed.
 139  * They are strings for QIB_STATUS_*
 140  */
 141 static const char * const qib_status_str[] = {
 142         "Initted",
 143         "",
 144         "",
 145         "",
 146         "",
 147         "Present",
 148         "IB_link_up",
 149         "IB_configured",
 150         "",
 151         "Fatal_Hardware_Error",
 152         NULL,
 153 };
 154
 155 static ssize_t status_str_show(struct ib_device *ibdev, u32 port_num,
 156                                struct ib_port_attribute *attr, char *buf)
 157 {
 158         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 159         struct qib_pportdata *ppd = &dd->pport[port_num - 1];
 160         int i, any;
 161         u64 s;
 162         ssize_t ret;
 163
 164         if (!ppd->statusp) {
 165                 ret = -EINVAL;
 166                 goto bail;
 167         }
 168
 169         s = *(ppd->statusp);
 170         *buf = '\0';
 171         for (any = i = 0; s && qib_status_str[i]; i++) {
 172                 if (s & 1) {
 173                         /* if overflow */
 174                         if (any && strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE)
 175                                 break;
 176                         if (strlcat(buf, qib_status_str[i], PAGE_SIZE) >=
 177                                         PAGE_SIZE)
 178                                 break;
 179                         any = 1;
 180                 }
 181                 s >>= 1;
 182         }
 183         if (any)
 184                 strlcat(buf, "\n", PAGE_SIZE);
 185
 186         ret = strlen(buf);
 187
 188 bail:
 189         return ret;
 190 }
 191 static IB_PORT_ATTR_RO(status_str);
 192
 193 /* end of per-port functions */
 194
 195 static struct attribute *port_linkcontrol_attributes[] = {
 196         &ib_port_attr_loopback.attr,
 197         &ib_port_attr_led_override.attr,
 198         &ib_port_attr_hrtbt_enable.attr,
 199         &ib_port_attr_status.attr,
 200         &ib_port_attr_status_str.attr,
 201         NULL
 202 };
 203
 204 static const struct attribute_group port_linkcontrol_group = {
 205         .name = "linkcontrol",
 206         .attrs = port_linkcontrol_attributes,
 207 };
 208
 209 /*
 210  * Start of per-port congestion control structures and support code
 211  */
 212
 213 /*
 214  * Congestion control table size followed by table entries
 215  */
 216 static ssize_t cc_table_bin_read(struct file *filp, struct kobject *kobj,
 217                                  struct bin_attribute *bin_attr, char *buf,
 218                                  loff_t pos, size_t count)
 219 {
 220         struct qib_pportdata *ppd = qib_get_pportdata_kobj(kobj);
 221         int ret;
 222
 223         if (!qib_cc_table_size || !ppd->ccti_entries_shadow)
 224                 return -EINVAL;
 225
 226         ret = ppd->total_cct_entry * sizeof(struct ib_cc_table_entry_shadow)
 227                  + sizeof(__be16);
 228
 229         if (pos > ret)
 230                 return -EINVAL;
 231
 232         if (count > ret - pos)
 233                 count = ret - pos;
 234
 235         if (!count)
 236                 return count;
 237
 238         spin_lock(&ppd->cc_shadow_lock);
 239         memcpy(buf, ppd->ccti_entries_shadow, count);
 240         spin_unlock(&ppd->cc_shadow_lock);
 241
 242         return count;
 243 }
 244 static BIN_ATTR_RO(cc_table_bin, PAGE_SIZE);
 245
 246 /*
 247  * Congestion settings: port control, control map and an array of 16
 248  * entries for the congestion entries - increase, timer, event log
 249  * trigger threshold and the minimum injection rate delay.
 250  */
 251 static ssize_t cc_setting_bin_read(struct file *filp, struct kobject *kobj,
 252                                    struct bin_attribute *bin_attr, char *buf,
 253                                    loff_t pos, size_t count)
 254 {
 255         struct qib_pportdata *ppd = qib_get_pportdata_kobj(kobj);
 256         int ret;
 257
 258         if (!qib_cc_table_size || !ppd->congestion_entries_shadow)
 259                 return -EINVAL;
 260
 261         ret = sizeof(struct ib_cc_congestion_setting_attr_shadow);
 262
 263         if (pos > ret)
 264                 return -EINVAL;
 265         if (count > ret - pos)
 266                 count = ret - pos;
 267
 268         if (!count)
 269                 return count;
 270
 271         spin_lock(&ppd->cc_shadow_lock);
 272         memcpy(buf, ppd->congestion_entries_shadow, count);
 273         spin_unlock(&ppd->cc_shadow_lock);
 274
 275         return count;
 276 }
 277 static BIN_ATTR_RO(cc_setting_bin, PAGE_SIZE);
 278
 279 static struct bin_attribute *port_ccmgta_attributes[] = {
 280         &bin_attr_cc_setting_bin,
 281         &bin_attr_cc_table_bin,
 282         NULL,
 283 };
 284
 285 static umode_t qib_ccmgta_is_bin_visible(struct kobject *kobj,
 286                                  struct bin_attribute *attr, int n)
 287 {
 288         struct qib_pportdata *ppd = qib_get_pportdata_kobj(kobj);
 289
 290         if (!qib_cc_table_size || !ppd->congestion_entries_shadow)
 291                 return 0;
 292         return attr->attr.mode;
 293 }
 294
 295 static const struct attribute_group port_ccmgta_attribute_group = {
 296         .name = "CCMgtA",
 297         .is_bin_visible = qib_ccmgta_is_bin_visible,
 298         .bin_attrs = port_ccmgta_attributes,
 299 };
 300
 301 /* Start sl2vl */
 302
 303 struct qib_sl2vl_attr {
 304         struct ib_port_attribute attr;
 305         int sl;
 306 };
 307
 308 static ssize_t sl2vl_attr_show(struct ib_device *ibdev, u32 port_num,
 309                                struct ib_port_attribute *attr, char *buf)
 310 {
 311         struct qib_sl2vl_attr *sattr =
 312                 container_of(attr, struct qib_sl2vl_attr, attr);
 313         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 314         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 315
 316         return sysfs_emit(buf, "%u\n", qibp->sl_to_vl[sattr->sl]);
 317 }
 318
 319 #define QIB_SL2VL_ATTR(N)                                                      \
 320         static struct qib_sl2vl_attr qib_sl2vl_attr_##N = {                    \
 321                 .attr = __ATTR(N, 0444, sl2vl_attr_show, NULL),                \
 322                 .sl = N,                                                       \
 323         }
 324
 325 QIB_SL2VL_ATTR(0);
 326 QIB_SL2VL_ATTR(1);
 327 QIB_SL2VL_ATTR(2);
 328 QIB_SL2VL_ATTR(3);
 329 QIB_SL2VL_ATTR(4);
 330 QIB_SL2VL_ATTR(5);
 331 QIB_SL2VL_ATTR(6);
 332 QIB_SL2VL_ATTR(7);
 333 QIB_SL2VL_ATTR(8);
 334 QIB_SL2VL_ATTR(9);
 335 QIB_SL2VL_ATTR(10);
 336 QIB_SL2VL_ATTR(11);
 337 QIB_SL2VL_ATTR(12);
 338 QIB_SL2VL_ATTR(13);
 339 QIB_SL2VL_ATTR(14);
 340 QIB_SL2VL_ATTR(15);
 341
 342 static struct attribute *port_sl2vl_attributes[] = {
 343         &qib_sl2vl_attr_0.attr.attr,
 344         &qib_sl2vl_attr_1.attr.attr,
 345         &qib_sl2vl_attr_2.attr.attr,
 346         &qib_sl2vl_attr_3.attr.attr,
 347         &qib_sl2vl_attr_4.attr.attr,
 348         &qib_sl2vl_attr_5.attr.attr,
 349         &qib_sl2vl_attr_6.attr.attr,
 350         &qib_sl2vl_attr_7.attr.attr,
 351         &qib_sl2vl_attr_8.attr.attr,
 352         &qib_sl2vl_attr_9.attr.attr,
 353         &qib_sl2vl_attr_10.attr.attr,
 354         &qib_sl2vl_attr_11.attr.attr,
 355         &qib_sl2vl_attr_12.attr.attr,
 356         &qib_sl2vl_attr_13.attr.attr,
 357         &qib_sl2vl_attr_14.attr.attr,
 358         &qib_sl2vl_attr_15.attr.attr,
 359         NULL
 360 };
 361
 362 static const struct attribute_group port_sl2vl_group = {
 363         .name = "sl2vl",
 364         .attrs = port_sl2vl_attributes,
 365 };
 366
 367 /* End sl2vl */
 368
 369 /* Start diag_counters */
 370
 371 struct qib_diagc_attr {
 372         struct ib_port_attribute attr;
 373         size_t counter;
 374 };
 375
 376 static ssize_t diagc_attr_show(struct ib_device *ibdev, u32 port_num,
 377                                struct ib_port_attribute *attr, char *buf)
 378 {
 379         struct qib_diagc_attr *dattr =
 380                 container_of(attr, struct qib_diagc_attr, attr);
 381         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 382         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 383
 384         return sysfs_emit(buf, "%llu\n", *((u64 *)qibp + dattr->counter));
 385 }
 386
 387 static ssize_t diagc_attr_store(struct ib_device *ibdev, u32 port_num,
 388                                 struct ib_port_attribute *attr, const char *buf,
 389                                 size_t count)
 390 {
 391         struct qib_diagc_attr *dattr =
 392                 container_of(attr, struct qib_diagc_attr, attr);
 393         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 394         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 395         u64 val;
 396         int ret;
 397
 398         ret = kstrtou64(buf, 0, &val);
 399         if (ret)
 400                 return ret;
 401         *((u64 *)qibp + dattr->counter) = val;
 402         return count;
 403 }
 404
 405 #define QIB_DIAGC_ATTR(N)                                                      \
 406         static struct qib_diagc_attr qib_diagc_attr_##N = {                    \
 407                 .attr = __ATTR(N, 0664, diagc_attr_show, diagc_attr_store),    \
 408                 .counter = &((struct qib_ibport *)0)->rvp.n_##N - (u64 *)0,    \
 409         }
 410
 411 QIB_DIAGC_ATTR(rc_resends);
 412 QIB_DIAGC_ATTR(seq_naks);
 413 QIB_DIAGC_ATTR(rdma_seq);
 414 QIB_DIAGC_ATTR(rnr_naks);
 415 QIB_DIAGC_ATTR(other_naks);
 416 QIB_DIAGC_ATTR(rc_timeouts);
 417 QIB_DIAGC_ATTR(loop_pkts);
 418 QIB_DIAGC_ATTR(pkt_drops);
 419 QIB_DIAGC_ATTR(dmawait);
 420 QIB_DIAGC_ATTR(unaligned);
 421 QIB_DIAGC_ATTR(rc_dupreq);
 422 QIB_DIAGC_ATTR(rc_seqnak);
 423 QIB_DIAGC_ATTR(rc_crwaits);
 424
 425 static u64 get_all_cpu_total(u64 __percpu *cntr)
 426 {
 427         int cpu;
 428         u64 counter = 0;
 429
 430         for_each_possible_cpu(cpu)
 431                 counter += *per_cpu_ptr(cntr, cpu);
 432         return counter;
 433 }
 434
 435 static ssize_t qib_store_per_cpu(struct qib_devdata *dd, const char *buf,
 436                                  size_t count, u64 *zero, u64 cur)
 437 {
 438         u32 val;
 439         int ret;
 440
 441         ret = kstrtou32(buf, 0, &val);
 442         if (ret)
 443                 return ret;
 444         if (val != 0) {
 445                 qib_dev_err(dd, "Per CPU cntrs can only be zeroed");
 446                 return count;
 447         }
 448         *zero = cur;
 449         return count;
 450 }
 451
 452 static ssize_t rc_acks_show(struct ib_device *ibdev, u32 port_num,
 453                             struct ib_port_attribute *attr, char *buf)
 454 {
 455         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 456         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 457
 458         return sysfs_emit(buf, "%llu\n",
 459                           get_all_cpu_total(qibp->rvp.rc_acks) -
 460                                   qibp->rvp.z_rc_acks);
 461 }
 462
 463 static ssize_t rc_acks_store(struct ib_device *ibdev, u32 port_num,
 464                              struct ib_port_attribute *attr, const char *buf,
 465                              size_t count)
 466 {
 467         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 468         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 469
 470         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_acks,
 471                                  get_all_cpu_total(qibp->rvp.rc_acks));
 472 }
 473 static IB_PORT_ATTR_RW(rc_acks);
 474
 475 static ssize_t rc_qacks_show(struct ib_device *ibdev, u32 port_num,
 476                              struct ib_port_attribute *attr, char *buf)
 477 {
 478         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 479         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 480
 481         return sysfs_emit(buf, "%llu\n",
 482                           get_all_cpu_total(qibp->rvp.rc_qacks) -
 483                                   qibp->rvp.z_rc_qacks);
 484 }
 485
 486 static ssize_t rc_qacks_store(struct ib_device *ibdev, u32 port_num,
 487                               struct ib_port_attribute *attr, const char *buf,
 488                               size_t count)
 489 {
 490         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 491         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 492
 493         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_qacks,
 494                                  get_all_cpu_total(qibp->rvp.rc_qacks));
 495 }
 496 static IB_PORT_ATTR_RW(rc_qacks);
 497
 498 static ssize_t rc_delayed_comp_show(struct ib_device *ibdev, u32 port_num,
 499                                     struct ib_port_attribute *attr, char *buf)
 500 {
 501         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 502         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 503
 504         return sysfs_emit(buf, "%llu\n",
 505                          get_all_cpu_total(qibp->rvp.rc_delayed_comp) -
 506                                  qibp->rvp.z_rc_delayed_comp);
 507 }
 508
 509 static ssize_t rc_delayed_comp_store(struct ib_device *ibdev, u32 port_num,
 510                                      struct ib_port_attribute *attr,
 511                                      const char *buf, size_t count)
 512 {
 513         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 514         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 515
 516         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_delayed_comp,
 517                                  get_all_cpu_total(qibp->rvp.rc_delayed_comp));
 518 }
 519 static IB_PORT_ATTR_RW(rc_delayed_comp);
 520
 521 static struct attribute *port_diagc_attributes[] = {
 522         &qib_diagc_attr_rc_resends.attr.attr,
 523         &qib_diagc_attr_seq_naks.attr.attr,
 524         &qib_diagc_attr_rdma_seq.attr.attr,
 525         &qib_diagc_attr_rnr_naks.attr.attr,
 526         &qib_diagc_attr_other_naks.attr.attr,
 527         &qib_diagc_attr_rc_timeouts.attr.attr,
 528         &qib_diagc_attr_loop_pkts.attr.attr,
 529         &qib_diagc_attr_pkt_drops.attr.attr,
 530         &qib_diagc_attr_dmawait.attr.attr,
 531         &qib_diagc_attr_unaligned.attr.attr,
 532         &qib_diagc_attr_rc_dupreq.attr.attr,
 533         &qib_diagc_attr_rc_seqnak.attr.attr,
 534         &qib_diagc_attr_rc_crwaits.attr.attr,
 535         &ib_port_attr_rc_acks.attr,
 536         &ib_port_attr_rc_qacks.attr,
 537         &ib_port_attr_rc_delayed_comp.attr,
 538         NULL
 539 };
 540
 541 static const struct attribute_group port_diagc_group = {
 542         .name = "linkcontrol",
 543         .attrs = port_diagc_attributes,
 544 };
 545
 546 /* End diag_counters */
 547
 548 const struct attribute_group *qib_attr_port_groups[] = {
 549         &port_linkcontrol_group,
 550         &port_ccmgta_attribute_group,
 551         &port_sl2vl_group,
 552         &port_diagc_group,
 553         NULL,
 554 };
 555
 556 /* end of per-port file structures and support code */
 557
 558 /*
 559  * Start of per-unit (or driver, in some cases, but replicated
 560  * per unit) functions (these get a device *)
 561  */
 562 static ssize_t hw_rev_show(struct device *device, struct device_attribute *attr,
 563                            char *buf)
 564 {
 565         struct qib_ibdev *dev =
 566                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 567
 568         return sysfs_emit(buf, "%x\n", dd_from_dev(dev)->minrev);
 569 }
 570 static DEVICE_ATTR_RO(hw_rev);
 571
 572 static ssize_t hca_type_show(struct device *device,
 573                              struct device_attribute *attr, char *buf)
 574 {
 575         struct qib_ibdev *dev =
 576                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 577         struct qib_devdata *dd = dd_from_dev(dev);
 578
 579         if (!dd->boardname)
 580                 return -EINVAL;
 581         return sysfs_emit(buf, "%s\n", dd->boardname);
 582 }
 583 static DEVICE_ATTR_RO(hca_type);
 584 static DEVICE_ATTR(board_id, 0444, hca_type_show, NULL);
 585
 586 static ssize_t version_show(struct device *device,
 587                             struct device_attribute *attr, char *buf)
 588 {
 589         /* The string printed here is already newline-terminated. */
 590         return sysfs_emit(buf, "%s", (char *)ib_qib_version);
 591 }
 592 static DEVICE_ATTR_RO(version);
 593
 594 static ssize_t boardversion_show(struct device *device,
 595                                  struct device_attribute *attr, char *buf)
 596 {
 597         struct qib_ibdev *dev =
 598                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 599         struct qib_devdata *dd = dd_from_dev(dev);
 600
 601         /* The string printed here is already newline-terminated. */
 602         return sysfs_emit(buf, "%s", dd->boardversion);
 603 }
 604 static DEVICE_ATTR_RO(boardversion);
 605
 606 static ssize_t localbus_info_show(struct device *device,
 607                                   struct device_attribute *attr, char *buf)
 608 {
 609         struct qib_ibdev *dev =
 610                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 611         struct qib_devdata *dd = dd_from_dev(dev);
 612
 613         /* The string printed here is already newline-terminated. */
 614         return sysfs_emit(buf, "%s", dd->lbus_info);
 615 }
 616 static DEVICE_ATTR_RO(localbus_info);
 617
 618 static ssize_t nctxts_show(struct device *device,
 619                            struct device_attribute *attr, char *buf)
 620 {
 621         struct qib_ibdev *dev =
 622                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 623         struct qib_devdata *dd = dd_from_dev(dev);
 624
 625         /* Return the number of user ports (contexts) available. */
 626         /* The calculation below deals with a special case where
 627          * cfgctxts is set to 1 on a single-port board. */
 628         return sysfs_emit(buf, "%u\n",
 629                           (dd->first_user_ctxt > dd->cfgctxts) ?
 630                                   0 :
 631                                   (dd->cfgctxts - dd->first_user_ctxt));
 632 }
 633 static DEVICE_ATTR_RO(nctxts);
 634
 635 static ssize_t nfreectxts_show(struct device *device,
 636                                struct device_attribute *attr, char *buf)
 637 {
 638         struct qib_ibdev *dev =
 639                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 640         struct qib_devdata *dd = dd_from_dev(dev);
 641
 642         /* Return the number of free user ports (contexts) available. */
 643         return sysfs_emit(buf, "%u\n", dd->freectxts);
 644 }
 645 static DEVICE_ATTR_RO(nfreectxts);
 646
 647 static ssize_t serial_show(struct device *device, struct device_attribute *attr,
 648                            char *buf)
 649 {
 650         struct qib_ibdev *dev =
 651                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 652         struct qib_devdata *dd = dd_from_dev(dev);
 653         const u8 *end = memchr(dd->serial, 0, ARRAY_SIZE(dd->serial));
 654         int size = end ? end - dd->serial : ARRAY_SIZE(dd->serial);
 655
 656         return sysfs_emit(buf, ".%*s\n", size, dd->serial);
 657 }
 658 static DEVICE_ATTR_RO(serial);
 659
 660 static ssize_t chip_reset_store(struct device *device,
 661                                 struct device_attribute *attr, const char *buf,
 662                                 size_t count)
 663 {
 664         struct qib_ibdev *dev =
 665                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 666         struct qib_devdata *dd = dd_from_dev(dev);
 667         int ret;
 668
 669         if (count < 5 || memcmp(buf, "reset", 5) || !dd->diag_client) {
 670                 ret = -EINVAL;
 671                 goto bail;
 672         }
 673
 674         ret = qib_reset_device(dd->unit);
 675 bail:
 676         return ret < 0 ? ret : count;
 677 }
 678 static DEVICE_ATTR_WO(chip_reset);
 679
 680 /*
 681  * Dump tempsense regs. in decimal, to ease shell-scripts.
 682  */
 683 static ssize_t tempsense_show(struct device *device,
 684                               struct device_attribute *attr, char *buf)
 685 {
 686         struct qib_ibdev *dev =
 687                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 688         struct qib_devdata *dd = dd_from_dev(dev);
 689         int i;
 690         u8 regvals[8];
 691
 692         for (i = 0; i < 8; i++) {
 693                 int ret;
 694
 695                 if (i == 6)
 696                         continue;
 697                 ret = dd->f_tempsense_rd(dd, i);
 698                 if (ret < 0)
 699                         return ret;     /* return error on bad read */
 700                 regvals[i] = ret;
 701         }
 702         return sysfs_emit(buf, "%d %d %02X %02X %d %d\n",
 703                           (signed char)regvals[0],
 704                           (signed char)regvals[1],
 705                           regvals[2],
 706                           regvals[3],
 707                           (signed char)regvals[5],
 708                           (signed char)regvals[7]);
 709 }
 710 static DEVICE_ATTR_RO(tempsense);
 711
 712 /*
 713  * end of per-unit (or driver, in some cases, but replicated
 714  * per unit) functions
 715  */
 716
 717 /* start of per-unit file structures and support code */
 718 static struct attribute *qib_attributes[] = {
 719         &dev_attr_hw_rev.attr,
 720         &dev_attr_hca_type.attr,
 721         &dev_attr_board_id.attr,
 722         &dev_attr_version.attr,
 723         &dev_attr_nctxts.attr,
 724         &dev_attr_nfreectxts.attr,
 725         &dev_attr_serial.attr,
 726         &dev_attr_boardversion.attr,
 727         &dev_attr_tempsense.attr,
 728         &dev_attr_localbus_info.attr,
 729         &dev_attr_chip_reset.attr,
 730         NULL,
 731 };
 732
 733 const struct attribute_group qib_attr_group = {
 734         .attrs = qib_attributes,
 735 };