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