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_assert(&((struct qib_ibport *)0)->rvp.n_##N != (u64 *)NULL);    \
 407         static struct qib_diagc_attr qib_diagc_attr_##N = {                    \
 408                 .attr = __ATTR(N, 0664, diagc_attr_show, diagc_attr_store),    \
 409                 .counter =                                                     \
 410                         offsetof(struct qib_ibport, rvp.n_##N) / sizeof(u64)   \
 411         }
 412
 413 QIB_DIAGC_ATTR(rc_resends);
 414 QIB_DIAGC_ATTR(seq_naks);
 415 QIB_DIAGC_ATTR(rdma_seq);
 416 QIB_DIAGC_ATTR(rnr_naks);
 417 QIB_DIAGC_ATTR(other_naks);
 418 QIB_DIAGC_ATTR(rc_timeouts);
 419 QIB_DIAGC_ATTR(loop_pkts);
 420 QIB_DIAGC_ATTR(pkt_drops);
 421 QIB_DIAGC_ATTR(dmawait);
 422 QIB_DIAGC_ATTR(unaligned);
 423 QIB_DIAGC_ATTR(rc_dupreq);
 424 QIB_DIAGC_ATTR(rc_seqnak);
 425 QIB_DIAGC_ATTR(rc_crwaits);
 426
 427 static u64 get_all_cpu_total(u64 __percpu *cntr)
 428 {
 429         int cpu;
 430         u64 counter = 0;
 431
 432         for_each_possible_cpu(cpu)
 433                 counter += *per_cpu_ptr(cntr, cpu);
 434         return counter;
 435 }
 436
 437 static ssize_t qib_store_per_cpu(struct qib_devdata *dd, const char *buf,
 438                                  size_t count, u64 *zero, u64 cur)
 439 {
 440         u32 val;
 441         int ret;
 442
 443         ret = kstrtou32(buf, 0, &val);
 444         if (ret)
 445                 return ret;
 446         if (val != 0) {
 447                 qib_dev_err(dd, "Per CPU cntrs can only be zeroed");
 448                 return count;
 449         }
 450         *zero = cur;
 451         return count;
 452 }
 453
 454 static ssize_t rc_acks_show(struct ib_device *ibdev, u32 port_num,
 455                             struct ib_port_attribute *attr, char *buf)
 456 {
 457         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 458         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 459
 460         return sysfs_emit(buf, "%llu\n",
 461                           get_all_cpu_total(qibp->rvp.rc_acks) -
 462                                   qibp->rvp.z_rc_acks);
 463 }
 464
 465 static ssize_t rc_acks_store(struct ib_device *ibdev, u32 port_num,
 466                              struct ib_port_attribute *attr, const char *buf,
 467                              size_t count)
 468 {
 469         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 470         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 471
 472         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_acks,
 473                                  get_all_cpu_total(qibp->rvp.rc_acks));
 474 }
 475 static IB_PORT_ATTR_RW(rc_acks);
 476
 477 static ssize_t rc_qacks_show(struct ib_device *ibdev, u32 port_num,
 478                              struct ib_port_attribute *attr, char *buf)
 479 {
 480         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 481         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 482
 483         return sysfs_emit(buf, "%llu\n",
 484                           get_all_cpu_total(qibp->rvp.rc_qacks) -
 485                                   qibp->rvp.z_rc_qacks);
 486 }
 487
 488 static ssize_t rc_qacks_store(struct ib_device *ibdev, u32 port_num,
 489                               struct ib_port_attribute *attr, const char *buf,
 490                               size_t count)
 491 {
 492         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 493         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 494
 495         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_qacks,
 496                                  get_all_cpu_total(qibp->rvp.rc_qacks));
 497 }
 498 static IB_PORT_ATTR_RW(rc_qacks);
 499
 500 static ssize_t rc_delayed_comp_show(struct ib_device *ibdev, u32 port_num,
 501                                     struct ib_port_attribute *attr, char *buf)
 502 {
 503         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 504         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 505
 506         return sysfs_emit(buf, "%llu\n",
 507                          get_all_cpu_total(qibp->rvp.rc_delayed_comp) -
 508                                  qibp->rvp.z_rc_delayed_comp);
 509 }
 510
 511 static ssize_t rc_delayed_comp_store(struct ib_device *ibdev, u32 port_num,
 512                                      struct ib_port_attribute *attr,
 513                                      const char *buf, size_t count)
 514 {
 515         struct qib_devdata *dd = dd_from_ibdev(ibdev);
 516         struct qib_ibport *qibp = &dd->pport[port_num - 1].ibport_data;
 517
 518         return qib_store_per_cpu(dd, buf, count, &qibp->rvp.z_rc_delayed_comp,
 519                                  get_all_cpu_total(qibp->rvp.rc_delayed_comp));
 520 }
 521 static IB_PORT_ATTR_RW(rc_delayed_comp);
 522
 523 static struct attribute *port_diagc_attributes[] = {
 524         &qib_diagc_attr_rc_resends.attr.attr,
 525         &qib_diagc_attr_seq_naks.attr.attr,
 526         &qib_diagc_attr_rdma_seq.attr.attr,
 527         &qib_diagc_attr_rnr_naks.attr.attr,
 528         &qib_diagc_attr_other_naks.attr.attr,
 529         &qib_diagc_attr_rc_timeouts.attr.attr,
 530         &qib_diagc_attr_loop_pkts.attr.attr,
 531         &qib_diagc_attr_pkt_drops.attr.attr,
 532         &qib_diagc_attr_dmawait.attr.attr,
 533         &qib_diagc_attr_unaligned.attr.attr,
 534         &qib_diagc_attr_rc_dupreq.attr.attr,
 535         &qib_diagc_attr_rc_seqnak.attr.attr,
 536         &qib_diagc_attr_rc_crwaits.attr.attr,
 537         &ib_port_attr_rc_acks.attr,
 538         &ib_port_attr_rc_qacks.attr,
 539         &ib_port_attr_rc_delayed_comp.attr,
 540         NULL
 541 };
 542
 543 static const struct attribute_group port_diagc_group = {
 544         .name = "linkcontrol",
 545         .attrs = port_diagc_attributes,
 546 };
 547
 548 /* End diag_counters */
 549
 550 const struct attribute_group *qib_attr_port_groups[] = {
 551         &port_linkcontrol_group,
 552         &port_ccmgta_attribute_group,
 553         &port_sl2vl_group,
 554         &port_diagc_group,
 555         NULL,
 556 };
 557
 558 /* end of per-port file structures and support code */
 559
 560 /*
 561  * Start of per-unit (or driver, in some cases, but replicated
 562  * per unit) functions (these get a device *)
 563  */
 564 static ssize_t hw_rev_show(struct device *device, struct device_attribute *attr,
 565                            char *buf)
 566 {
 567         struct qib_ibdev *dev =
 568                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 569
 570         return sysfs_emit(buf, "%x\n", dd_from_dev(dev)->minrev);
 571 }
 572 static DEVICE_ATTR_RO(hw_rev);
 573
 574 static ssize_t hca_type_show(struct device *device,
 575                              struct device_attribute *attr, char *buf)
 576 {
 577         struct qib_ibdev *dev =
 578                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 579         struct qib_devdata *dd = dd_from_dev(dev);
 580
 581         if (!dd->boardname)
 582                 return -EINVAL;
 583         return sysfs_emit(buf, "%s\n", dd->boardname);
 584 }
 585 static DEVICE_ATTR_RO(hca_type);
 586 static DEVICE_ATTR(board_id, 0444, hca_type_show, NULL);
 587
 588 static ssize_t version_show(struct device *device,
 589                             struct device_attribute *attr, char *buf)
 590 {
 591         /* The string printed here is already newline-terminated. */
 592         return sysfs_emit(buf, "%s", (char *)ib_qib_version);
 593 }
 594 static DEVICE_ATTR_RO(version);
 595
 596 static ssize_t boardversion_show(struct device *device,
 597                                  struct device_attribute *attr, char *buf)
 598 {
 599         struct qib_ibdev *dev =
 600                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 601         struct qib_devdata *dd = dd_from_dev(dev);
 602
 603         /* The string printed here is already newline-terminated. */
 604         return sysfs_emit(buf, "%s", dd->boardversion);
 605 }
 606 static DEVICE_ATTR_RO(boardversion);
 607
 608 static ssize_t localbus_info_show(struct device *device,
 609                                   struct device_attribute *attr, char *buf)
 610 {
 611         struct qib_ibdev *dev =
 612                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 613         struct qib_devdata *dd = dd_from_dev(dev);
 614
 615         /* The string printed here is already newline-terminated. */
 616         return sysfs_emit(buf, "%s", dd->lbus_info);
 617 }
 618 static DEVICE_ATTR_RO(localbus_info);
 619
 620 static ssize_t nctxts_show(struct device *device,
 621                            struct device_attribute *attr, char *buf)
 622 {
 623         struct qib_ibdev *dev =
 624                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 625         struct qib_devdata *dd = dd_from_dev(dev);
 626
 627         /* Return the number of user ports (contexts) available. */
 628         /* The calculation below deals with a special case where
 629          * cfgctxts is set to 1 on a single-port board. */
 630         return sysfs_emit(buf, "%u\n",
 631                           (dd->first_user_ctxt > dd->cfgctxts) ?
 632                                   0 :
 633                                   (dd->cfgctxts - dd->first_user_ctxt));
 634 }
 635 static DEVICE_ATTR_RO(nctxts);
 636
 637 static ssize_t nfreectxts_show(struct device *device,
 638                                struct device_attribute *attr, char *buf)
 639 {
 640         struct qib_ibdev *dev =
 641                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 642         struct qib_devdata *dd = dd_from_dev(dev);
 643
 644         /* Return the number of free user ports (contexts) available. */
 645         return sysfs_emit(buf, "%u\n", dd->freectxts);
 646 }
 647 static DEVICE_ATTR_RO(nfreectxts);
 648
 649 static ssize_t serial_show(struct device *device, struct device_attribute *attr,
 650                            char *buf)
 651 {
 652         struct qib_ibdev *dev =
 653                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 654         struct qib_devdata *dd = dd_from_dev(dev);
 655         const u8 *end = memchr(dd->serial, 0, ARRAY_SIZE(dd->serial));
 656         int size = end ? end - dd->serial : ARRAY_SIZE(dd->serial);
 657
 658         return sysfs_emit(buf, ".%*s\n", size, dd->serial);
 659 }
 660 static DEVICE_ATTR_RO(serial);
 661
 662 static ssize_t chip_reset_store(struct device *device,
 663                                 struct device_attribute *attr, const char *buf,
 664                                 size_t count)
 665 {
 666         struct qib_ibdev *dev =
 667                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 668         struct qib_devdata *dd = dd_from_dev(dev);
 669         int ret;
 670
 671         if (count < 5 || memcmp(buf, "reset", 5) || !dd->diag_client) {
 672                 ret = -EINVAL;
 673                 goto bail;
 674         }
 675
 676         ret = qib_reset_device(dd->unit);
 677 bail:
 678         return ret < 0 ? ret : count;
 679 }
 680 static DEVICE_ATTR_WO(chip_reset);
 681
 682 /*
 683  * Dump tempsense regs. in decimal, to ease shell-scripts.
 684  */
 685 static ssize_t tempsense_show(struct device *device,
 686                               struct device_attribute *attr, char *buf)
 687 {
 688         struct qib_ibdev *dev =
 689                 rdma_device_to_drv_device(device, struct qib_ibdev, rdi.ibdev);
 690         struct qib_devdata *dd = dd_from_dev(dev);
 691         int i;
 692         u8 regvals[8];
 693
 694         for (i = 0; i < 8; i++) {
 695                 int ret;
 696
 697                 if (i == 6)
 698                         continue;
 699                 ret = dd->f_tempsense_rd(dd, i);
 700                 if (ret < 0)
 701                         return ret;     /* return error on bad read */
 702                 regvals[i] = ret;
 703         }
 704         return sysfs_emit(buf, "%d %d %02X %02X %d %d\n",
 705                           (signed char)regvals[0],
 706                           (signed char)regvals[1],
 707                           regvals[2],
 708                           regvals[3],
 709                           (signed char)regvals[5],
 710                           (signed char)regvals[7]);
 711 }
 712 static DEVICE_ATTR_RO(tempsense);
 713
 714 /*
 715  * end of per-unit (or driver, in some cases, but replicated
 716  * per unit) functions
 717  */
 718
 719 /* start of per-unit file structures and support code */
 720 static struct attribute *qib_attributes[] = {
 721         &dev_attr_hw_rev.attr,
 722         &dev_attr_hca_type.attr,
 723         &dev_attr_board_id.attr,
 724         &dev_attr_version.attr,
 725         &dev_attr_nctxts.attr,
 726         &dev_attr_nfreectxts.attr,
 727         &dev_attr_serial.attr,
 728         &dev_attr_boardversion.attr,
 729         &dev_attr_tempsense.attr,
 730         &dev_attr_localbus_info.attr,
 731         &dev_attr_chip_reset.attr,
 732         NULL,
 733 };
 734
 735 const struct attribute_group qib_attr_group = {
 736         .attrs = qib_attributes,
 737 };