drivers/infiniband/core/sysfs.c

   1 /*
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005 Mellanox Technologies Ltd.  All rights reserved.
   4  * Copyright (c) 2005 Sun Microsystems, 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
  35 #include "core_priv.h"
  36
  37 #include <linux/slab.h>
  38 #include <linux/stat.h>
  39 #include <linux/string.h>
  40 #include <linux/netdevice.h>
  41 #include <linux/ethtool.h>
  42
  43 #include <rdma/ib_mad.h>
  44 #include <rdma/ib_pma.h>
  45
  46 struct ib_port;
  47
  48 struct gid_attr_group {
  49         struct ib_port          *port;
  50         struct kobject          kobj;
  51         struct attribute_group  ndev;
  52         struct attribute_group  type;
  53 };
  54 struct ib_port {
  55         struct kobject         kobj;
  56         struct ib_device      *ibdev;
  57         struct gid_attr_group *gid_attr_group;
  58         struct attribute_group gid_group;
  59         struct attribute_group pkey_group;
  60         struct attribute_group *pma_table;
  61         struct attribute_group *hw_stats_ag;
  62         struct rdma_hw_stats   *hw_stats;
  63         u8                     port_num;
  64 };
  65
  66 struct port_attribute {
  67         struct attribute attr;
  68         ssize_t (*show)(struct ib_port *, struct port_attribute *, char *buf);
  69         ssize_t (*store)(struct ib_port *, struct port_attribute *,
  70                          const char *buf, size_t count);
  71 };
  72
  73 #define PORT_ATTR(_name, _mode, _show, _store) \
  74 struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store)
  75
  76 #define PORT_ATTR_RO(_name) \
  77 struct port_attribute port_attr_##_name = __ATTR_RO(_name)
  78
  79 struct port_table_attribute {
  80         struct port_attribute   attr;
  81         char                    name[8];
  82         int                     index;
  83         __be16                  attr_id;
  84 };
  85
  86 struct hw_stats_attribute {
  87         struct attribute        attr;
  88         ssize_t                 (*show)(struct kobject *kobj,
  89                                         struct attribute *attr, char *buf);
  90         ssize_t                 (*store)(struct kobject *kobj,
  91                                          struct attribute *attr,
  92                                          const char *buf,
  93                                          size_t count);
  94         int                     index;
  95         u8                      port_num;
  96 };
  97
  98 static ssize_t port_attr_show(struct kobject *kobj,
  99                               struct attribute *attr, char *buf)
 100 {
 101         struct port_attribute *port_attr =
 102                 container_of(attr, struct port_attribute, attr);
 103         struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 104
 105         if (!port_attr->show)
 106                 return -EIO;
 107
 108         return port_attr->show(p, port_attr, buf);
 109 }
 110
 111 static const struct sysfs_ops port_sysfs_ops = {
 112         .show = port_attr_show
 113 };
 114
 115 static ssize_t gid_attr_show(struct kobject *kobj,
 116                              struct attribute *attr, char *buf)
 117 {
 118         struct port_attribute *port_attr =
 119                 container_of(attr, struct port_attribute, attr);
 120         struct ib_port *p = container_of(kobj, struct gid_attr_group,
 121                                          kobj)->port;
 122
 123         if (!port_attr->show)
 124                 return -EIO;
 125
 126         return port_attr->show(p, port_attr, buf);
 127 }
 128
 129 static const struct sysfs_ops gid_attr_sysfs_ops = {
 130         .show = gid_attr_show
 131 };
 132
 133 static ssize_t state_show(struct ib_port *p, struct port_attribute *unused,
 134                           char *buf)
 135 {
 136         struct ib_port_attr attr;
 137         ssize_t ret;
 138
 139         static const char *state_name[] = {
 140                 [IB_PORT_NOP]           = "NOP",
 141                 [IB_PORT_DOWN]          = "DOWN",
 142                 [IB_PORT_INIT]          = "INIT",
 143                 [IB_PORT_ARMED]         = "ARMED",
 144                 [IB_PORT_ACTIVE]        = "ACTIVE",
 145                 [IB_PORT_ACTIVE_DEFER]  = "ACTIVE_DEFER"
 146         };
 147
 148         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 149         if (ret)
 150                 return ret;
 151
 152         return sprintf(buf, "%d: %s\n", attr.state,
 153                        attr.state >= 0 && attr.state < ARRAY_SIZE(state_name) ?
 154                        state_name[attr.state] : "UNKNOWN");
 155 }
 156
 157 static ssize_t lid_show(struct ib_port *p, struct port_attribute *unused,
 158                         char *buf)
 159 {
 160         struct ib_port_attr attr;
 161         ssize_t ret;
 162
 163         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 164         if (ret)
 165                 return ret;
 166
 167         return sprintf(buf, "0x%x\n", attr.lid);
 168 }
 169
 170 static ssize_t lid_mask_count_show(struct ib_port *p,
 171                                    struct port_attribute *unused,
 172                                    char *buf)
 173 {
 174         struct ib_port_attr attr;
 175         ssize_t ret;
 176
 177         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 178         if (ret)
 179                 return ret;
 180
 181         return sprintf(buf, "%d\n", attr.lmc);
 182 }
 183
 184 static ssize_t sm_lid_show(struct ib_port *p, struct port_attribute *unused,
 185                            char *buf)
 186 {
 187         struct ib_port_attr attr;
 188         ssize_t ret;
 189
 190         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 191         if (ret)
 192                 return ret;
 193
 194         return sprintf(buf, "0x%x\n", attr.sm_lid);
 195 }
 196
 197 static ssize_t sm_sl_show(struct ib_port *p, struct port_attribute *unused,
 198                           char *buf)
 199 {
 200         struct ib_port_attr attr;
 201         ssize_t ret;
 202
 203         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 204         if (ret)
 205                 return ret;
 206
 207         return sprintf(buf, "%d\n", attr.sm_sl);
 208 }
 209
 210 static ssize_t cap_mask_show(struct ib_port *p, struct port_attribute *unused,
 211                              char *buf)
 212 {
 213         struct ib_port_attr attr;
 214         ssize_t ret;
 215
 216         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 217         if (ret)
 218                 return ret;
 219
 220         return sprintf(buf, "0x%08x\n", attr.port_cap_flags);
 221 }
 222
 223 static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused,
 224                          char *buf)
 225 {
 226         struct ib_port_attr attr;
 227         char *speed = "";
 228         int rate;               /* in deci-Gb/sec */
 229         ssize_t ret;
 230
 231         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 232         if (ret)
 233                 return ret;
 234
 235         switch (attr.active_speed) {
 236         case IB_SPEED_DDR:
 237                 speed = " DDR";
 238                 rate = 50;
 239                 break;
 240         case IB_SPEED_QDR:
 241                 speed = " QDR";
 242                 rate = 100;
 243                 break;
 244         case IB_SPEED_FDR10:
 245                 speed = " FDR10";
 246                 rate = 100;
 247                 break;
 248         case IB_SPEED_FDR:
 249                 speed = " FDR";
 250                 rate = 140;
 251                 break;
 252         case IB_SPEED_EDR:
 253                 speed = " EDR";
 254                 rate = 250;
 255                 break;
 256         case IB_SPEED_HDR:
 257                 speed = " HDR";
 258                 rate = 500;
 259                 break;
 260         case IB_SPEED_SDR:
 261         default:                /* default to SDR for invalid rates */
 262                 rate = 25;
 263                 break;
 264         }
 265
 266         rate *= ib_width_enum_to_int(attr.active_width);
 267         if (rate < 0)
 268                 return -EINVAL;
 269
 270         return sprintf(buf, "%d%s Gb/sec (%dX%s)\n",
 271                        rate / 10, rate % 10 ? ".5" : "",
 272                        ib_width_enum_to_int(attr.active_width), speed);
 273 }
 274
 275 static ssize_t phys_state_show(struct ib_port *p, struct port_attribute *unused,
 276                                char *buf)
 277 {
 278         struct ib_port_attr attr;
 279
 280         ssize_t ret;
 281
 282         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 283         if (ret)
 284                 return ret;
 285
 286         switch (attr.phys_state) {
 287         case 1:  return sprintf(buf, "1: Sleep\n");
 288         case 2:  return sprintf(buf, "2: Polling\n");
 289         case 3:  return sprintf(buf, "3: Disabled\n");
 290         case 4:  return sprintf(buf, "4: PortConfigurationTraining\n");
 291         case 5:  return sprintf(buf, "5: LinkUp\n");
 292         case 6:  return sprintf(buf, "6: LinkErrorRecovery\n");
 293         case 7:  return sprintf(buf, "7: Phy Test\n");
 294         default: return sprintf(buf, "%d: <unknown>\n", attr.phys_state);
 295         }
 296 }
 297
 298 static ssize_t link_layer_show(struct ib_port *p, struct port_attribute *unused,
 299                                char *buf)
 300 {
 301         switch (rdma_port_get_link_layer(p->ibdev, p->port_num)) {
 302         case IB_LINK_LAYER_INFINIBAND:
 303                 return sprintf(buf, "%s\n", "InfiniBand");
 304         case IB_LINK_LAYER_ETHERNET:
 305                 return sprintf(buf, "%s\n", "Ethernet");
 306         default:
 307                 return sprintf(buf, "%s\n", "Unknown");
 308         }
 309 }
 310
 311 static PORT_ATTR_RO(state);
 312 static PORT_ATTR_RO(lid);
 313 static PORT_ATTR_RO(lid_mask_count);
 314 static PORT_ATTR_RO(sm_lid);
 315 static PORT_ATTR_RO(sm_sl);
 316 static PORT_ATTR_RO(cap_mask);
 317 static PORT_ATTR_RO(rate);
 318 static PORT_ATTR_RO(phys_state);
 319 static PORT_ATTR_RO(link_layer);
 320
 321 static struct attribute *port_default_attrs[] = {
 322         &port_attr_state.attr,
 323         &port_attr_lid.attr,
 324         &port_attr_lid_mask_count.attr,
 325         &port_attr_sm_lid.attr,
 326         &port_attr_sm_sl.attr,
 327         &port_attr_cap_mask.attr,
 328         &port_attr_rate.attr,
 329         &port_attr_phys_state.attr,
 330         &port_attr_link_layer.attr,
 331         NULL
 332 };
 333
 334 static size_t print_ndev(struct ib_gid_attr *gid_attr, char *buf)
 335 {
 336         if (!gid_attr->ndev)
 337                 return -EINVAL;
 338
 339         return sprintf(buf, "%s\n", gid_attr->ndev->name);
 340 }
 341
 342 static size_t print_gid_type(struct ib_gid_attr *gid_attr, char *buf)
 343 {
 344         return sprintf(buf, "%s\n", ib_cache_gid_type_str(gid_attr->gid_type));
 345 }
 346
 347 static ssize_t _show_port_gid_attr(struct ib_port *p,
 348                                    struct port_attribute *attr,
 349                                    char *buf,
 350                                    size_t (*print)(struct ib_gid_attr *gid_attr,
 351                                                    char *buf))
 352 {
 353         struct port_table_attribute *tab_attr =
 354                 container_of(attr, struct port_table_attribute, attr);
 355         union ib_gid gid;
 356         struct ib_gid_attr gid_attr = {};
 357         ssize_t ret;
 358
 359         ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid,
 360                            &gid_attr);
 361         if (ret)
 362                 goto err;
 363
 364         ret = print(&gid_attr, buf);
 365
 366 err:
 367         if (gid_attr.ndev)
 368                 dev_put(gid_attr.ndev);
 369         return ret;
 370 }
 371
 372 static ssize_t show_port_gid(struct ib_port *p, struct port_attribute *attr,
 373                              char *buf)
 374 {
 375         struct port_table_attribute *tab_attr =
 376                 container_of(attr, struct port_table_attribute, attr);
 377         union ib_gid gid;
 378         ssize_t ret;
 379
 380         ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid, NULL);
 381         if (ret)
 382                 return ret;
 383
 384         return sprintf(buf, "%pI6\n", gid.raw);
 385 }
 386
 387 static ssize_t show_port_gid_attr_ndev(struct ib_port *p,
 388                                        struct port_attribute *attr, char *buf)
 389 {
 390         return _show_port_gid_attr(p, attr, buf, print_ndev);
 391 }
 392
 393 static ssize_t show_port_gid_attr_gid_type(struct ib_port *p,
 394                                            struct port_attribute *attr,
 395                                            char *buf)
 396 {
 397         return _show_port_gid_attr(p, attr, buf, print_gid_type);
 398 }
 399
 400 static ssize_t show_port_pkey(struct ib_port *p, struct port_attribute *attr,
 401                               char *buf)
 402 {
 403         struct port_table_attribute *tab_attr =
 404                 container_of(attr, struct port_table_attribute, attr);
 405         u16 pkey;
 406         ssize_t ret;
 407
 408         ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey);
 409         if (ret)
 410                 return ret;
 411
 412         return sprintf(buf, "0x%04x\n", pkey);
 413 }
 414
 415 #define PORT_PMA_ATTR(_name, _counter, _width, _offset)                 \
 416 struct port_table_attribute port_pma_attr_##_name = {                   \
 417         .attr  = __ATTR(_name, S_IRUGO, show_pma_counter, NULL),        \
 418         .index = (_offset) | ((_width) << 16) | ((_counter) << 24),     \
 419         .attr_id = IB_PMA_PORT_COUNTERS ,                               \
 420 }
 421
 422 #define PORT_PMA_ATTR_EXT(_name, _width, _offset)                       \
 423 struct port_table_attribute port_pma_attr_ext_##_name = {               \
 424         .attr  = __ATTR(_name, S_IRUGO, show_pma_counter, NULL),        \
 425         .index = (_offset) | ((_width) << 16),                          \
 426         .attr_id = IB_PMA_PORT_COUNTERS_EXT ,                           \
 427 }
 428
 429 /*
 430  * Get a Perfmgmt MAD block of data.
 431  * Returns error code or the number of bytes retrieved.
 432  */
 433 static int get_perf_mad(struct ib_device *dev, int port_num, __be16 attr,
 434                 void *data, int offset, size_t size)
 435 {
 436         struct ib_mad *in_mad;
 437         struct ib_mad *out_mad;
 438         size_t mad_size = sizeof(*out_mad);
 439         u16 out_mad_pkey_index = 0;
 440         ssize_t ret;
 441
 442         if (!dev->process_mad)
 443                 return -ENOSYS;
 444
 445         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 446         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 447         if (!in_mad || !out_mad) {
 448                 ret = -ENOMEM;
 449                 goto out;
 450         }
 451
 452         in_mad->mad_hdr.base_version  = 1;
 453         in_mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_PERF_MGMT;
 454         in_mad->mad_hdr.class_version = 1;
 455         in_mad->mad_hdr.method        = IB_MGMT_METHOD_GET;
 456         in_mad->mad_hdr.attr_id       = attr;
 457
 458         if (attr != IB_PMA_CLASS_PORT_INFO)
 459                 in_mad->data[41] = port_num;    /* PortSelect field */
 460
 461         if ((dev->process_mad(dev, IB_MAD_IGNORE_MKEY,
 462                  port_num, NULL, NULL,
 463                  (const struct ib_mad_hdr *)in_mad, mad_size,
 464                  (struct ib_mad_hdr *)out_mad, &mad_size,
 465                  &out_mad_pkey_index) &
 466              (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) !=
 467             (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) {
 468                 ret = -EINVAL;
 469                 goto out;
 470         }
 471         memcpy(data, out_mad->data + offset, size);
 472         ret = size;
 473 out:
 474         kfree(in_mad);
 475         kfree(out_mad);
 476         return ret;
 477 }
 478
 479 static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
 480                                 char *buf)
 481 {
 482         struct port_table_attribute *tab_attr =
 483                 container_of(attr, struct port_table_attribute, attr);
 484         int offset = tab_attr->index & 0xffff;
 485         int width  = (tab_attr->index >> 16) & 0xff;
 486         ssize_t ret;
 487         u8 data[8];
 488
 489         ret = get_perf_mad(p->ibdev, p->port_num, tab_attr->attr_id, &data,
 490                         40 + offset / 8, sizeof(data));
 491         if (ret < 0)
 492                 return ret;
 493
 494         switch (width) {
 495         case 4:
 496                 ret = sprintf(buf, "%u\n", (*data >>
 497                                             (4 - (offset % 8))) & 0xf);
 498                 break;
 499         case 8:
 500                 ret = sprintf(buf, "%u\n", *data);
 501                 break;
 502         case 16:
 503                 ret = sprintf(buf, "%u\n",
 504                               be16_to_cpup((__be16 *)data));
 505                 break;
 506         case 32:
 507                 ret = sprintf(buf, "%u\n",
 508                               be32_to_cpup((__be32 *)data));
 509                 break;
 510         case 64:
 511                 ret = sprintf(buf, "%llu\n",
 512                                 be64_to_cpup((__be64 *)data));
 513                 break;
 514
 515         default:
 516                 ret = 0;
 517         }
 518
 519         return ret;
 520 }
 521
 522 static PORT_PMA_ATTR(symbol_error                   ,  0, 16,  32);
 523 static PORT_PMA_ATTR(link_error_recovery            ,  1,  8,  48);
 524 static PORT_PMA_ATTR(link_downed                    ,  2,  8,  56);
 525 static PORT_PMA_ATTR(port_rcv_errors                ,  3, 16,  64);
 526 static PORT_PMA_ATTR(port_rcv_remote_physical_errors,  4, 16,  80);
 527 static PORT_PMA_ATTR(port_rcv_switch_relay_errors   ,  5, 16,  96);
 528 static PORT_PMA_ATTR(port_xmit_discards             ,  6, 16, 112);
 529 static PORT_PMA_ATTR(port_xmit_constraint_errors    ,  7,  8, 128);
 530 static PORT_PMA_ATTR(port_rcv_constraint_errors     ,  8,  8, 136);
 531 static PORT_PMA_ATTR(local_link_integrity_errors    ,  9,  4, 152);
 532 static PORT_PMA_ATTR(excessive_buffer_overrun_errors, 10,  4, 156);
 533 static PORT_PMA_ATTR(VL15_dropped                   , 11, 16, 176);
 534 static PORT_PMA_ATTR(port_xmit_data                 , 12, 32, 192);
 535 static PORT_PMA_ATTR(port_rcv_data                  , 13, 32, 224);
 536 static PORT_PMA_ATTR(port_xmit_packets              , 14, 32, 256);
 537 static PORT_PMA_ATTR(port_rcv_packets               , 15, 32, 288);
 538 static PORT_PMA_ATTR(port_xmit_wait                 ,  0, 32, 320);
 539
 540 /*
 541  * Counters added by extended set
 542  */
 543 static PORT_PMA_ATTR_EXT(port_xmit_data             , 64,  64);
 544 static PORT_PMA_ATTR_EXT(port_rcv_data              , 64, 128);
 545 static PORT_PMA_ATTR_EXT(port_xmit_packets          , 64, 192);
 546 static PORT_PMA_ATTR_EXT(port_rcv_packets           , 64, 256);
 547 static PORT_PMA_ATTR_EXT(unicast_xmit_packets       , 64, 320);
 548 static PORT_PMA_ATTR_EXT(unicast_rcv_packets        , 64, 384);
 549 static PORT_PMA_ATTR_EXT(multicast_xmit_packets     , 64, 448);
 550 static PORT_PMA_ATTR_EXT(multicast_rcv_packets      , 64, 512);
 551
 552 static struct attribute *pma_attrs[] = {
 553         &port_pma_attr_symbol_error.attr.attr,
 554         &port_pma_attr_link_error_recovery.attr.attr,
 555         &port_pma_attr_link_downed.attr.attr,
 556         &port_pma_attr_port_rcv_errors.attr.attr,
 557         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 558         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 559         &port_pma_attr_port_xmit_discards.attr.attr,
 560         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 561         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 562         &port_pma_attr_local_link_integrity_errors.attr.attr,
 563         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 564         &port_pma_attr_VL15_dropped.attr.attr,
 565         &port_pma_attr_port_xmit_data.attr.attr,
 566         &port_pma_attr_port_rcv_data.attr.attr,
 567         &port_pma_attr_port_xmit_packets.attr.attr,
 568         &port_pma_attr_port_rcv_packets.attr.attr,
 569         &port_pma_attr_port_xmit_wait.attr.attr,
 570         NULL
 571 };
 572
 573 static struct attribute *pma_attrs_ext[] = {
 574         &port_pma_attr_symbol_error.attr.attr,
 575         &port_pma_attr_link_error_recovery.attr.attr,
 576         &port_pma_attr_link_downed.attr.attr,
 577         &port_pma_attr_port_rcv_errors.attr.attr,
 578         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 579         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 580         &port_pma_attr_port_xmit_discards.attr.attr,
 581         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 582         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 583         &port_pma_attr_local_link_integrity_errors.attr.attr,
 584         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 585         &port_pma_attr_VL15_dropped.attr.attr,
 586         &port_pma_attr_ext_port_xmit_data.attr.attr,
 587         &port_pma_attr_ext_port_rcv_data.attr.attr,
 588         &port_pma_attr_ext_port_xmit_packets.attr.attr,
 589         &port_pma_attr_port_xmit_wait.attr.attr,
 590         &port_pma_attr_ext_port_rcv_packets.attr.attr,
 591         &port_pma_attr_ext_unicast_rcv_packets.attr.attr,
 592         &port_pma_attr_ext_unicast_xmit_packets.attr.attr,
 593         &port_pma_attr_ext_multicast_rcv_packets.attr.attr,
 594         &port_pma_attr_ext_multicast_xmit_packets.attr.attr,
 595         NULL
 596 };
 597
 598 static struct attribute *pma_attrs_noietf[] = {
 599         &port_pma_attr_symbol_error.attr.attr,
 600         &port_pma_attr_link_error_recovery.attr.attr,
 601         &port_pma_attr_link_downed.attr.attr,
 602         &port_pma_attr_port_rcv_errors.attr.attr,
 603         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 604         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 605         &port_pma_attr_port_xmit_discards.attr.attr,
 606         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 607         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 608         &port_pma_attr_local_link_integrity_errors.attr.attr,
 609         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 610         &port_pma_attr_VL15_dropped.attr.attr,
 611         &port_pma_attr_ext_port_xmit_data.attr.attr,
 612         &port_pma_attr_ext_port_rcv_data.attr.attr,
 613         &port_pma_attr_ext_port_xmit_packets.attr.attr,
 614         &port_pma_attr_ext_port_rcv_packets.attr.attr,
 615         &port_pma_attr_port_xmit_wait.attr.attr,
 616         NULL
 617 };
 618
 619 static struct attribute_group pma_group = {
 620         .name  = "counters",
 621         .attrs  = pma_attrs
 622 };
 623
 624 static struct attribute_group pma_group_ext = {
 625         .name  = "counters",
 626         .attrs  = pma_attrs_ext
 627 };
 628
 629 static struct attribute_group pma_group_noietf = {
 630         .name  = "counters",
 631         .attrs  = pma_attrs_noietf
 632 };
 633
 634 static void ib_port_release(struct kobject *kobj)
 635 {
 636         struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 637         struct attribute *a;
 638         int i;
 639
 640         if (p->gid_group.attrs) {
 641                 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
 642                         kfree(a);
 643
 644                 kfree(p->gid_group.attrs);
 645         }
 646
 647         if (p->pkey_group.attrs) {
 648                 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
 649                         kfree(a);
 650
 651                 kfree(p->pkey_group.attrs);
 652         }
 653
 654         kfree(p);
 655 }
 656
 657 static void ib_port_gid_attr_release(struct kobject *kobj)
 658 {
 659         struct gid_attr_group *g = container_of(kobj, struct gid_attr_group,
 660                                                 kobj);
 661         struct attribute *a;
 662         int i;
 663
 664         if (g->ndev.attrs) {
 665                 for (i = 0; (a = g->ndev.attrs[i]); ++i)
 666                         kfree(a);
 667
 668                 kfree(g->ndev.attrs);
 669         }
 670
 671         if (g->type.attrs) {
 672                 for (i = 0; (a = g->type.attrs[i]); ++i)
 673                         kfree(a);
 674
 675                 kfree(g->type.attrs);
 676         }
 677
 678         kfree(g);
 679 }
 680
 681 static struct kobj_type port_type = {
 682         .release       = ib_port_release,
 683         .sysfs_ops     = &port_sysfs_ops,
 684         .default_attrs = port_default_attrs
 685 };
 686
 687 static struct kobj_type gid_attr_type = {
 688         .sysfs_ops      = &gid_attr_sysfs_ops,
 689         .release        = ib_port_gid_attr_release
 690 };
 691
 692 static struct attribute **
 693 alloc_group_attrs(ssize_t (*show)(struct ib_port *,
 694                                   struct port_attribute *, char *buf),
 695                   int len)
 696 {
 697         struct attribute **tab_attr;
 698         struct port_table_attribute *element;
 699         int i;
 700
 701         tab_attr = kcalloc(1 + len, sizeof(struct attribute *), GFP_KERNEL);
 702         if (!tab_attr)
 703                 return NULL;
 704
 705         for (i = 0; i < len; i++) {
 706                 element = kzalloc(sizeof(struct port_table_attribute),
 707                                   GFP_KERNEL);
 708                 if (!element)
 709                         goto err;
 710
 711                 if (snprintf(element->name, sizeof(element->name),
 712                              "%d", i) >= sizeof(element->name)) {
 713                         kfree(element);
 714                         goto err;
 715                 }
 716
 717                 element->attr.attr.name  = element->name;
 718                 element->attr.attr.mode  = S_IRUGO;
 719                 element->attr.show       = show;
 720                 element->index           = i;
 721                 sysfs_attr_init(&element->attr.attr);
 722
 723                 tab_attr[i] = &element->attr.attr;
 724         }
 725
 726         return tab_attr;
 727
 728 err:
 729         while (--i >= 0)
 730                 kfree(tab_attr[i]);
 731         kfree(tab_attr);
 732         return NULL;
 733 }
 734
 735 /*
 736  * Figure out which counter table to use depending on
 737  * the device capabilities.
 738  */
 739 static struct attribute_group *get_counter_table(struct ib_device *dev,
 740                                                  int port_num)
 741 {
 742         struct ib_class_port_info cpi;
 743
 744         if (get_perf_mad(dev, port_num, IB_PMA_CLASS_PORT_INFO,
 745                                 &cpi, 40, sizeof(cpi)) >= 0) {
 746                 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH)
 747                         /* We have extended counters */
 748                         return &pma_group_ext;
 749
 750                 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF)
 751                         /* But not the IETF ones */
 752                         return &pma_group_noietf;
 753         }
 754
 755         /* Fall back to normal counters */
 756         return &pma_group;
 757 }
 758
 759 static int update_hw_stats(struct ib_device *dev, struct rdma_hw_stats *stats,
 760                            u8 port_num, int index)
 761 {
 762         int ret;
 763
 764         if (time_is_after_eq_jiffies(stats->timestamp + stats->lifespan))
 765                 return 0;
 766         ret = dev->get_hw_stats(dev, stats, port_num, index);
 767         if (ret < 0)
 768                 return ret;
 769         if (ret == stats->num_counters)
 770                 stats->timestamp = jiffies;
 771
 772         return 0;
 773 }
 774
 775 static ssize_t print_hw_stat(struct rdma_hw_stats *stats, int index, char *buf)
 776 {
 777         return sprintf(buf, "%llu\n", stats->value[index]);
 778 }
 779
 780 static ssize_t show_hw_stats(struct kobject *kobj, struct attribute *attr,
 781                              char *buf)
 782 {
 783         struct ib_device *dev;
 784         struct ib_port *port;
 785         struct hw_stats_attribute *hsa;
 786         struct rdma_hw_stats *stats;
 787         int ret;
 788
 789         hsa = container_of(attr, struct hw_stats_attribute, attr);
 790         if (!hsa->port_num) {
 791                 dev = container_of((struct device *)kobj,
 792                                    struct ib_device, dev);
 793                 stats = dev->hw_stats;
 794         } else {
 795                 port = container_of(kobj, struct ib_port, kobj);
 796                 dev = port->ibdev;
 797                 stats = port->hw_stats;
 798         }
 799         ret = update_hw_stats(dev, stats, hsa->port_num, hsa->index);
 800         if (ret)
 801                 return ret;
 802         return print_hw_stat(stats, hsa->index, buf);
 803 }
 804
 805 static ssize_t show_stats_lifespan(struct kobject *kobj,
 806                                    struct attribute *attr,
 807                                    char *buf)
 808 {
 809         struct hw_stats_attribute *hsa;
 810         int msecs;
 811
 812         hsa = container_of(attr, struct hw_stats_attribute, attr);
 813         if (!hsa->port_num) {
 814                 struct ib_device *dev = container_of((struct device *)kobj,
 815                                                      struct ib_device, dev);
 816                 msecs = jiffies_to_msecs(dev->hw_stats->lifespan);
 817         } else {
 818                 struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 819                 msecs = jiffies_to_msecs(p->hw_stats->lifespan);
 820         }
 821         return sprintf(buf, "%d\n", msecs);
 822 }
 823
 824 static ssize_t set_stats_lifespan(struct kobject *kobj,
 825                                   struct attribute *attr,
 826                                   const char *buf, size_t count)
 827 {
 828         struct hw_stats_attribute *hsa;
 829         int msecs;
 830         int jiffies;
 831         int ret;
 832
 833         ret = kstrtoint(buf, 10, &msecs);
 834         if (ret)
 835                 return ret;
 836         if (msecs < 0 || msecs > 10000)
 837                 return -EINVAL;
 838         jiffies = msecs_to_jiffies(msecs);
 839         hsa = container_of(attr, struct hw_stats_attribute, attr);
 840         if (!hsa->port_num) {
 841                 struct ib_device *dev = container_of((struct device *)kobj,
 842                                                      struct ib_device, dev);
 843                 dev->hw_stats->lifespan = jiffies;
 844         } else {
 845                 struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 846                 p->hw_stats->lifespan = jiffies;
 847         }
 848         return count;
 849 }
 850
 851 static void free_hsag(struct kobject *kobj, struct attribute_group *attr_group)
 852 {
 853         struct attribute **attr;
 854
 855         sysfs_remove_group(kobj, attr_group);
 856
 857         for (attr = attr_group->attrs; *attr; attr++)
 858                 kfree(*attr);
 859         kfree(attr_group);
 860 }
 861
 862 static struct attribute *alloc_hsa(int index, u8 port_num, const char *name)
 863 {
 864         struct hw_stats_attribute *hsa;
 865
 866         hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
 867         if (!hsa)
 868                 return NULL;
 869
 870         hsa->attr.name = (char *)name;
 871         hsa->attr.mode = S_IRUGO;
 872         hsa->show = show_hw_stats;
 873         hsa->store = NULL;
 874         hsa->index = index;
 875         hsa->port_num = port_num;
 876
 877         return &hsa->attr;
 878 }
 879
 880 static struct attribute *alloc_hsa_lifespan(char *name, u8 port_num)
 881 {
 882         struct hw_stats_attribute *hsa;
 883
 884         hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
 885         if (!hsa)
 886                 return NULL;
 887
 888         hsa->attr.name = name;
 889         hsa->attr.mode = S_IWUSR | S_IRUGO;
 890         hsa->show = show_stats_lifespan;
 891         hsa->store = set_stats_lifespan;
 892         hsa->index = 0;
 893         hsa->port_num = port_num;
 894
 895         return &hsa->attr;
 896 }
 897
 898 static void setup_hw_stats(struct ib_device *device, struct ib_port *port,
 899                            u8 port_num)
 900 {
 901         struct attribute_group *hsag;
 902         struct rdma_hw_stats *stats;
 903         int i, ret;
 904
 905         stats = device->alloc_hw_stats(device, port_num);
 906
 907         if (!stats)
 908                 return;
 909
 910         if (!stats->names || stats->num_counters <= 0)
 911                 goto err_free_stats;
 912
 913         /*
 914          * Two extra attribue elements here, one for the lifespan entry and
 915          * one to NULL terminate the list for the sysfs core code
 916          */
 917         hsag = kzalloc(sizeof(*hsag) +
 918                        sizeof(void *) * (stats->num_counters + 2),
 919                        GFP_KERNEL);
 920         if (!hsag)
 921                 goto err_free_stats;
 922
 923         ret = device->get_hw_stats(device, stats, port_num,
 924                                    stats->num_counters);
 925         if (ret != stats->num_counters)
 926                 goto err_free_hsag;
 927
 928         stats->timestamp = jiffies;
 929
 930         hsag->name = "hw_counters";
 931         hsag->attrs = (void *)hsag + sizeof(*hsag);
 932
 933         for (i = 0; i < stats->num_counters; i++) {
 934                 hsag->attrs[i] = alloc_hsa(i, port_num, stats->names[i]);
 935                 if (!hsag->attrs[i])
 936                         goto err;
 937                 sysfs_attr_init(hsag->attrs[i]);
 938         }
 939
 940         /* treat an error here as non-fatal */
 941         hsag->attrs[i] = alloc_hsa_lifespan("lifespan", port_num);
 942         if (hsag->attrs[i])
 943                 sysfs_attr_init(hsag->attrs[i]);
 944
 945         if (port) {
 946                 struct kobject *kobj = &port->kobj;
 947                 ret = sysfs_create_group(kobj, hsag);
 948                 if (ret)
 949                         goto err;
 950                 port->hw_stats_ag = hsag;
 951                 port->hw_stats = stats;
 952         } else {
 953                 struct kobject *kobj = &device->dev.kobj;
 954                 ret = sysfs_create_group(kobj, hsag);
 955                 if (ret)
 956                         goto err;
 957                 device->hw_stats_ag = hsag;
 958                 device->hw_stats = stats;
 959         }
 960
 961         return;
 962
 963 err:
 964         for (; i >= 0; i--)
 965                 kfree(hsag->attrs[i]);
 966 err_free_hsag:
 967         kfree(hsag);
 968 err_free_stats:
 969         kfree(stats);
 970         return;
 971 }
 972
 973 static int add_port(struct ib_device *device, int port_num,
 974                     int (*port_callback)(struct ib_device *,
 975                                          u8, struct kobject *))
 976 {
 977         struct ib_port *p;
 978         struct ib_port_attr attr;
 979         int i;
 980         int ret;
 981
 982         ret = ib_query_port(device, port_num, &attr);
 983         if (ret)
 984                 return ret;
 985
 986         p = kzalloc(sizeof *p, GFP_KERNEL);
 987         if (!p)
 988                 return -ENOMEM;
 989
 990         p->ibdev      = device;
 991         p->port_num   = port_num;
 992
 993         ret = kobject_init_and_add(&p->kobj, &port_type,
 994                                    device->ports_parent,
 995                                    "%d", port_num);
 996         if (ret) {
 997                 kfree(p);
 998                 return ret;
 999         }
1000
1001         p->gid_attr_group = kzalloc(sizeof(*p->gid_attr_group), GFP_KERNEL);
1002         if (!p->gid_attr_group) {
1003                 ret = -ENOMEM;
1004                 goto err_put;
1005         }
1006
1007         p->gid_attr_group->port = p;
1008         ret = kobject_init_and_add(&p->gid_attr_group->kobj, &gid_attr_type,
1009                                    &p->kobj, "gid_attrs");
1010         if (ret) {
1011                 kfree(p->gid_attr_group);
1012                 goto err_put;
1013         }
1014
1015         if (device->process_mad) {
1016                 p->pma_table = get_counter_table(device, port_num);
1017                 ret = sysfs_create_group(&p->kobj, p->pma_table);
1018                 if (ret)
1019                         goto err_put_gid_attrs;
1020         }
1021
1022         p->gid_group.name  = "gids";
1023         p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len);
1024         if (!p->gid_group.attrs) {
1025                 ret = -ENOMEM;
1026                 goto err_remove_pma;
1027         }
1028
1029         ret = sysfs_create_group(&p->kobj, &p->gid_group);
1030         if (ret)
1031                 goto err_free_gid;
1032
1033         p->gid_attr_group->ndev.name = "ndevs";
1034         p->gid_attr_group->ndev.attrs = alloc_group_attrs(show_port_gid_attr_ndev,
1035                                                           attr.gid_tbl_len);
1036         if (!p->gid_attr_group->ndev.attrs) {
1037                 ret = -ENOMEM;
1038                 goto err_remove_gid;
1039         }
1040
1041         ret = sysfs_create_group(&p->gid_attr_group->kobj,
1042                                  &p->gid_attr_group->ndev);
1043         if (ret)
1044                 goto err_free_gid_ndev;
1045
1046         p->gid_attr_group->type.name = "types";
1047         p->gid_attr_group->type.attrs = alloc_group_attrs(show_port_gid_attr_gid_type,
1048                                                           attr.gid_tbl_len);
1049         if (!p->gid_attr_group->type.attrs) {
1050                 ret = -ENOMEM;
1051                 goto err_remove_gid_ndev;
1052         }
1053
1054         ret = sysfs_create_group(&p->gid_attr_group->kobj,
1055                                  &p->gid_attr_group->type);
1056         if (ret)
1057                 goto err_free_gid_type;
1058
1059         p->pkey_group.name  = "pkeys";
1060         p->pkey_group.attrs = alloc_group_attrs(show_port_pkey,
1061                                                 attr.pkey_tbl_len);
1062         if (!p->pkey_group.attrs) {
1063                 ret = -ENOMEM;
1064                 goto err_remove_gid_type;
1065         }
1066
1067         ret = sysfs_create_group(&p->kobj, &p->pkey_group);
1068         if (ret)
1069                 goto err_free_pkey;
1070
1071         if (port_callback) {
1072                 ret = port_callback(device, port_num, &p->kobj);
1073                 if (ret)
1074                         goto err_remove_pkey;
1075         }
1076
1077         /*
1078          * If port == 0, it means we have only one port and the parent
1079          * device, not this port device, should be the holder of the
1080          * hw_counters
1081          */
1082         if (device->alloc_hw_stats && port_num)
1083                 setup_hw_stats(device, p, port_num);
1084
1085         list_add_tail(&p->kobj.entry, &device->port_list);
1086
1087         kobject_uevent(&p->kobj, KOBJ_ADD);
1088         return 0;
1089
1090 err_remove_pkey:
1091         sysfs_remove_group(&p->kobj, &p->pkey_group);
1092
1093 err_free_pkey:
1094         for (i = 0; i < attr.pkey_tbl_len; ++i)
1095                 kfree(p->pkey_group.attrs[i]);
1096
1097         kfree(p->pkey_group.attrs);
1098         p->pkey_group.attrs = NULL;
1099
1100 err_remove_gid_type:
1101         sysfs_remove_group(&p->gid_attr_group->kobj,
1102                            &p->gid_attr_group->type);
1103
1104 err_free_gid_type:
1105         for (i = 0; i < attr.gid_tbl_len; ++i)
1106                 kfree(p->gid_attr_group->type.attrs[i]);
1107
1108         kfree(p->gid_attr_group->type.attrs);
1109         p->gid_attr_group->type.attrs = NULL;
1110
1111 err_remove_gid_ndev:
1112         sysfs_remove_group(&p->gid_attr_group->kobj,
1113                            &p->gid_attr_group->ndev);
1114
1115 err_free_gid_ndev:
1116         for (i = 0; i < attr.gid_tbl_len; ++i)
1117                 kfree(p->gid_attr_group->ndev.attrs[i]);
1118
1119         kfree(p->gid_attr_group->ndev.attrs);
1120         p->gid_attr_group->ndev.attrs = NULL;
1121
1122 err_remove_gid:
1123         sysfs_remove_group(&p->kobj, &p->gid_group);
1124
1125 err_free_gid:
1126         for (i = 0; i < attr.gid_tbl_len; ++i)
1127                 kfree(p->gid_group.attrs[i]);
1128
1129         kfree(p->gid_group.attrs);
1130         p->gid_group.attrs = NULL;
1131
1132 err_remove_pma:
1133         if (p->pma_table)
1134                 sysfs_remove_group(&p->kobj, p->pma_table);
1135
1136 err_put_gid_attrs:
1137         kobject_put(&p->gid_attr_group->kobj);
1138
1139 err_put:
1140         kobject_put(&p->kobj);
1141         return ret;
1142 }
1143
1144 static ssize_t show_node_type(struct device *device,
1145                               struct device_attribute *attr, char *buf)
1146 {
1147         struct ib_device *dev = container_of(device, struct ib_device, dev);
1148
1149         switch (dev->node_type) {
1150         case RDMA_NODE_IB_CA:     return sprintf(buf, "%d: CA\n", dev->node_type);
1151         case RDMA_NODE_RNIC:      return sprintf(buf, "%d: RNIC\n", dev->node_type);
1152         case RDMA_NODE_USNIC:     return sprintf(buf, "%d: usNIC\n", dev->node_type);
1153         case RDMA_NODE_USNIC_UDP: return sprintf(buf, "%d: usNIC UDP\n", dev->node_type);
1154         case RDMA_NODE_IB_SWITCH: return sprintf(buf, "%d: switch\n", dev->node_type);
1155         case RDMA_NODE_IB_ROUTER: return sprintf(buf, "%d: router\n", dev->node_type);
1156         default:                  return sprintf(buf, "%d: <unknown>\n", dev->node_type);
1157         }
1158 }
1159
1160 static ssize_t show_sys_image_guid(struct device *device,
1161                                    struct device_attribute *dev_attr, char *buf)
1162 {
1163         struct ib_device *dev = container_of(device, struct ib_device, dev);
1164
1165         return sprintf(buf, "%04x:%04x:%04x:%04x\n",
1166                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[0]),
1167                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[1]),
1168                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[2]),
1169                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[3]));
1170 }
1171
1172 static ssize_t show_node_guid(struct device *device,
1173                               struct device_attribute *attr, char *buf)
1174 {
1175         struct ib_device *dev = container_of(device, struct ib_device, dev);
1176
1177         return sprintf(buf, "%04x:%04x:%04x:%04x\n",
1178                        be16_to_cpu(((__be16 *) &dev->node_guid)[0]),
1179                        be16_to_cpu(((__be16 *) &dev->node_guid)[1]),
1180                        be16_to_cpu(((__be16 *) &dev->node_guid)[2]),
1181                        be16_to_cpu(((__be16 *) &dev->node_guid)[3]));
1182 }
1183
1184 static ssize_t show_node_desc(struct device *device,
1185                               struct device_attribute *attr, char *buf)
1186 {
1187         struct ib_device *dev = container_of(device, struct ib_device, dev);
1188
1189         return sprintf(buf, "%.64s\n", dev->node_desc);
1190 }
1191
1192 static ssize_t set_node_desc(struct device *device,
1193                              struct device_attribute *attr,
1194                              const char *buf, size_t count)
1195 {
1196         struct ib_device *dev = container_of(device, struct ib_device, dev);
1197         struct ib_device_modify desc = {};
1198         int ret;
1199
1200         if (!dev->modify_device)
1201                 return -EIO;
1202
1203         memcpy(desc.node_desc, buf, min_t(int, count, IB_DEVICE_NODE_DESC_MAX));
1204         ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc);
1205         if (ret)
1206                 return ret;
1207
1208         return count;
1209 }
1210
1211 static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
1212                            char *buf)
1213 {
1214         struct ib_device *dev = container_of(device, struct ib_device, dev);
1215
1216         ib_get_device_fw_str(dev, buf);
1217         strlcat(buf, "\n", IB_FW_VERSION_NAME_MAX);
1218         return strlen(buf);
1219 }
1220
1221 static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
1222 static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);
1223 static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);
1224 static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc);
1225 static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
1226
1227 static struct device_attribute *ib_class_attributes[] = {
1228         &dev_attr_node_type,
1229         &dev_attr_sys_image_guid,
1230         &dev_attr_node_guid,
1231         &dev_attr_node_desc,
1232         &dev_attr_fw_ver,
1233 };
1234
1235 static void free_port_list_attributes(struct ib_device *device)
1236 {
1237         struct kobject *p, *t;
1238
1239         list_for_each_entry_safe(p, t, &device->port_list, entry) {
1240                 struct ib_port *port = container_of(p, struct ib_port, kobj);
1241                 list_del(&p->entry);
1242                 if (port->hw_stats) {
1243                         kfree(port->hw_stats);
1244                         free_hsag(&port->kobj, port->hw_stats_ag);
1245                 }
1246
1247                 if (port->pma_table)
1248                         sysfs_remove_group(p, port->pma_table);
1249                 sysfs_remove_group(p, &port->pkey_group);
1250                 sysfs_remove_group(p, &port->gid_group);
1251                 sysfs_remove_group(&port->gid_attr_group->kobj,
1252                                    &port->gid_attr_group->ndev);
1253                 sysfs_remove_group(&port->gid_attr_group->kobj,
1254                                    &port->gid_attr_group->type);
1255                 kobject_put(&port->gid_attr_group->kobj);
1256                 kobject_put(p);
1257         }
1258
1259         kobject_put(device->ports_parent);
1260 }
1261
1262 int ib_device_register_sysfs(struct ib_device *device,
1263                              int (*port_callback)(struct ib_device *,
1264                                                   u8, struct kobject *))
1265 {
1266         struct device *class_dev = &device->dev;
1267         int ret;
1268         int i;
1269
1270         ret = dev_set_name(class_dev, "%s", device->name);
1271         if (ret)
1272                 return ret;
1273
1274         ret = device_add(class_dev);
1275         if (ret)
1276                 goto err;
1277
1278         for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {
1279                 ret = device_create_file(class_dev, ib_class_attributes[i]);
1280                 if (ret)
1281                         goto err_unregister;
1282         }
1283
1284         device->ports_parent = kobject_create_and_add("ports",
1285                                                       &class_dev->kobj);
1286         if (!device->ports_parent) {
1287                 ret = -ENOMEM;
1288                 goto err_put;
1289         }
1290
1291         if (rdma_cap_ib_switch(device)) {
1292                 ret = add_port(device, 0, port_callback);
1293                 if (ret)
1294                         goto err_put;
1295         } else {
1296                 for (i = 1; i <= device->phys_port_cnt; ++i) {
1297                         ret = add_port(device, i, port_callback);
1298                         if (ret)
1299                                 goto err_put;
1300                 }
1301         }
1302
1303         if (device->alloc_hw_stats)
1304                 setup_hw_stats(device, NULL, 0);
1305
1306         return 0;
1307
1308 err_put:
1309         free_port_list_attributes(device);
1310
1311 err_unregister:
1312         device_del(class_dev);
1313
1314 err:
1315         return ret;
1316 }
1317
1318 void ib_device_unregister_sysfs(struct ib_device *device)
1319 {
1320         int i;
1321
1322         /* Hold kobject until ib_dealloc_device() */
1323         kobject_get(&device->dev.kobj);
1324
1325         free_port_list_attributes(device);
1326
1327         if (device->hw_stats) {
1328                 kfree(device->hw_stats);
1329                 free_hsag(&device->dev.kobj, device->hw_stats_ag);
1330         }
1331
1332         for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i)
1333                 device_remove_file(&device->dev, ib_class_attributes[i]);
1334
1335         device_unregister(&device->dev);
1336 }