drivers/infiniband/hw/mlx4/sysfs.c

   1 /*
   2  * Copyright (c) 2012 Mellanox Technologies.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 /*#include "core_priv.h"*/
  34 #include "mlx4_ib.h"
  35 #include <linux/slab.h>
  36 #include <linux/string.h>
  37 #include <linux/stat.h>
  38
  39 #include <rdma/ib_mad.h>
  40 /*show_admin_alias_guid returns the administratively assigned value of that GUID.
  41  * Values returned in buf parameter string:
  42  *      0                       - requests opensm to assign a value.
  43  *      ffffffffffffffff        - delete this entry.
  44  *      other                   - value assigned by administrator.
  45  */
  46 static ssize_t show_admin_alias_guid(struct device *dev,
  47                               struct device_attribute *attr, char *buf)
  48 {
  49         int record_num;/*0-15*/
  50         int guid_index_in_rec; /*0 - 7*/
  51         struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
  52                 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
  53         struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
  54         struct mlx4_ib_dev *mdev = port->dev;
  55
  56         record_num = mlx4_ib_iov_dentry->entry_num / 8 ;
  57         guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8 ;
  58
  59         return sprintf(buf, "%llx\n",
  60                        be64_to_cpu(*(__be64 *)&mdev->sriov.alias_guid.
  61                                    ports_guid[port->num - 1].
  62                                    all_rec_per_port[record_num].
  63                                    all_recs[8 * guid_index_in_rec]));
  64 }
  65
  66 /* store_admin_alias_guid stores the (new) administratively assigned value of that GUID.
  67  * Values in buf parameter string:
  68  *      0                       - requests opensm to assign a value.
  69  *      0xffffffffffffffff      - delete this entry.
  70  *      other                   - guid value assigned by the administrator.
  71  */
  72 static ssize_t store_admin_alias_guid(struct device *dev,
  73                                       struct device_attribute *attr,
  74                                       const char *buf, size_t count)
  75 {
  76         int record_num;/*0-15*/
  77         int guid_index_in_rec; /*0 - 7*/
  78         struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
  79                 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
  80         struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
  81         struct mlx4_ib_dev *mdev = port->dev;
  82         u64 sysadmin_ag_val;
  83
  84         record_num = mlx4_ib_iov_dentry->entry_num / 8;
  85         guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8;
  86         if (0 == record_num && 0 == guid_index_in_rec) {
  87                 pr_err("GUID 0 block 0 is RO\n");
  88                 return count;
  89         }
  90         sscanf(buf, "%llx", &sysadmin_ag_val);
  91         *(__be64 *)&mdev->sriov.alias_guid.ports_guid[port->num - 1].
  92                 all_rec_per_port[record_num].
  93                 all_recs[GUID_REC_SIZE * guid_index_in_rec] =
  94                         cpu_to_be64(sysadmin_ag_val);
  95
  96         /* Change the state to be pending for update */
  97         mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].status
  98                 = MLX4_GUID_INFO_STATUS_IDLE ;
  99
 100         mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
 101                 = MLX4_GUID_INFO_RECORD_SET;
 102
 103         switch (sysadmin_ag_val) {
 104         case MLX4_GUID_FOR_DELETE_VAL:
 105                 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
 106                         = MLX4_GUID_INFO_RECORD_DELETE;
 107                 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
 108                         = MLX4_GUID_SYSADMIN_ASSIGN;
 109                 break;
 110         /* The sysadmin requests the SM to re-assign */
 111         case MLX4_NOT_SET_GUID:
 112                 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
 113                         = MLX4_GUID_DRIVER_ASSIGN;
 114                 break;
 115         /* The sysadmin requests a specific value.*/
 116         default:
 117                 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
 118                         = MLX4_GUID_SYSADMIN_ASSIGN;
 119                 break;
 120         }
 121
 122         /* set the record index */
 123         mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].guid_indexes
 124                 = mlx4_ib_get_aguid_comp_mask_from_ix(guid_index_in_rec);
 125
 126         mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
 127
 128         return count;
 129 }
 130
 131 static ssize_t show_port_gid(struct device *dev,
 132                              struct device_attribute *attr,
 133                              char *buf)
 134 {
 135         struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
 136                 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
 137         struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
 138         struct mlx4_ib_dev *mdev = port->dev;
 139         union ib_gid gid;
 140         ssize_t ret;
 141
 142         ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
 143                                   mlx4_ib_iov_dentry->entry_num, &gid, 1);
 144         if (ret)
 145                 return ret;
 146         ret = sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
 147                       be16_to_cpu(((__be16 *) gid.raw)[0]),
 148                       be16_to_cpu(((__be16 *) gid.raw)[1]),
 149                       be16_to_cpu(((__be16 *) gid.raw)[2]),
 150                       be16_to_cpu(((__be16 *) gid.raw)[3]),
 151                       be16_to_cpu(((__be16 *) gid.raw)[4]),
 152                       be16_to_cpu(((__be16 *) gid.raw)[5]),
 153                       be16_to_cpu(((__be16 *) gid.raw)[6]),
 154                       be16_to_cpu(((__be16 *) gid.raw)[7]));
 155         return ret;
 156 }
 157
 158 static ssize_t show_phys_port_pkey(struct device *dev,
 159                                    struct device_attribute *attr,
 160                                    char *buf)
 161 {
 162         struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
 163                 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
 164         struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
 165         struct mlx4_ib_dev *mdev = port->dev;
 166         u16 pkey;
 167         ssize_t ret;
 168
 169         ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
 170                                    mlx4_ib_iov_dentry->entry_num, &pkey, 1);
 171         if (ret)
 172                 return ret;
 173
 174         return sprintf(buf, "0x%04x\n", pkey);
 175 }
 176
 177 #define DENTRY_REMOVE(_dentry)                                          \
 178 do {                                                                    \
 179         sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr);    \
 180 } while (0);
 181
 182 static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,
 183                               char *_name, struct kobject *_kobj,
 184                               ssize_t (*show)(struct device *dev,
 185                                               struct device_attribute *attr,
 186                                               char *buf),
 187                               ssize_t (*store)(struct device *dev,
 188                                                struct device_attribute *attr,
 189                                                const char *buf, size_t count)
 190                               )
 191 {
 192         int ret = 0;
 193         struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
 194
 195         vdentry->ctx = _ctx;
 196         vdentry->dentry.show = show;
 197         vdentry->dentry.store = store;
 198         sysfs_attr_init(&vdentry->dentry.attr);
 199         vdentry->dentry.attr.name = vdentry->name;
 200         vdentry->dentry.attr.mode = 0;
 201         vdentry->kobj = _kobj;
 202         snprintf(vdentry->name, 15, "%s", _name);
 203
 204         if (vdentry->dentry.store)
 205                 vdentry->dentry.attr.mode |= S_IWUSR;
 206
 207         if (vdentry->dentry.show)
 208                 vdentry->dentry.attr.mode |= S_IRUGO;
 209
 210         ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
 211         if (ret) {
 212                 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
 213                 vdentry->ctx = NULL;
 214                 return ret;
 215         }
 216
 217         return ret;
 218 }
 219
 220 int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
 221                 struct attribute *attr)
 222 {
 223         struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
 224         int ret;
 225
 226         ret = sysfs_create_file(port->mcgs_parent, attr);
 227         if (ret)
 228                 pr_err("failed to create %s\n", attr->name);
 229
 230         return ret;
 231 }
 232
 233 void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
 234                 struct attribute *attr)
 235 {
 236         struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
 237
 238         sysfs_remove_file(port->mcgs_parent, attr);
 239 }
 240
 241 static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
 242 {
 243         int i;
 244         char buff[11];
 245         struct mlx4_ib_iov_port *port = NULL;
 246         int ret = 0 ;
 247         struct ib_port_attr attr;
 248
 249         /* get the physical gid and pkey table sizes.*/
 250         ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
 251         if (ret)
 252                 goto err;
 253
 254         port = &device->iov_ports[port_num - 1];
 255         port->dev = device;
 256         port->num = port_num;
 257         /* Directory structure:
 258          * iov -
 259          *   port num -
 260          *      admin_guids
 261          *      gids (operational)
 262          *      mcg_table
 263          */
 264         port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
 265                                  GFP_KERNEL);
 266         if (!port->dentr_ar) {
 267                 ret = -ENOMEM;
 268                 goto err;
 269         }
 270         sprintf(buff, "%d", port_num);
 271         port->cur_port = kobject_create_and_add(buff,
 272                                  kobject_get(device->ports_parent));
 273         if (!port->cur_port) {
 274                 ret = -ENOMEM;
 275                 goto kobj_create_err;
 276         }
 277         /* admin GUIDs */
 278         port->admin_alias_parent = kobject_create_and_add("admin_guids",
 279                                                   kobject_get(port->cur_port));
 280         if (!port->admin_alias_parent) {
 281                 ret = -ENOMEM;
 282                 goto err_admin_guids;
 283         }
 284         for (i = 0 ; i < attr.gid_tbl_len; i++) {
 285                 sprintf(buff, "%d", i);
 286                 port->dentr_ar->dentries[i].entry_num = i;
 287                 ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i],
 288                                           buff, port->admin_alias_parent,
 289                                           show_admin_alias_guid, store_admin_alias_guid);
 290                 if (ret)
 291                         goto err_admin_alias_parent;
 292         }
 293
 294         /* gids subdirectory (operational gids) */
 295         port->gids_parent = kobject_create_and_add("gids",
 296                                                   kobject_get(port->cur_port));
 297         if (!port->gids_parent) {
 298                 ret = -ENOMEM;
 299                 goto err_gids;
 300         }
 301
 302         for (i = 0 ; i < attr.gid_tbl_len; i++) {
 303                 sprintf(buff, "%d", i);
 304                 port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i;
 305                 ret = create_sysfs_entry(port,
 306                                          &port->dentr_ar->dentries[attr.gid_tbl_len + i],
 307                                          buff,
 308                                          port->gids_parent, show_port_gid, NULL);
 309                 if (ret)
 310                         goto err_gids_parent;
 311         }
 312
 313         /* physical port pkey table */
 314         port->pkeys_parent =
 315                 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
 316         if (!port->pkeys_parent) {
 317                 ret = -ENOMEM;
 318                 goto err_pkeys;
 319         }
 320
 321         for (i = 0 ; i < attr.pkey_tbl_len; i++) {
 322                 sprintf(buff, "%d", i);
 323                 port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i;
 324                 ret = create_sysfs_entry(port,
 325                                          &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i],
 326                                          buff, port->pkeys_parent,
 327                                          show_phys_port_pkey, NULL);
 328                 if (ret)
 329                         goto err_pkeys_parent;
 330         }
 331
 332         /* MCGs table */
 333         port->mcgs_parent =
 334                 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
 335         if (!port->mcgs_parent) {
 336                 ret = -ENOMEM;
 337                 goto err_mcgs;
 338         }
 339         return 0;
 340
 341 err_mcgs:
 342         kobject_put(port->cur_port);
 343
 344 err_pkeys_parent:
 345         kobject_put(port->pkeys_parent);
 346
 347 err_pkeys:
 348         kobject_put(port->cur_port);
 349
 350 err_gids_parent:
 351         kobject_put(port->gids_parent);
 352
 353 err_gids:
 354         kobject_put(port->cur_port);
 355
 356 err_admin_alias_parent:
 357         kobject_put(port->admin_alias_parent);
 358
 359 err_admin_guids:
 360         kobject_put(port->cur_port);
 361         kobject_put(port->cur_port); /* once more for create_and_add buff */
 362
 363 kobj_create_err:
 364         kobject_put(device->ports_parent);
 365         kfree(port->dentr_ar);
 366
 367 err:
 368         pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
 369                port_num, ret);
 370         return ret;
 371 }
 372
 373 static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
 374 {
 375         char base_name[9];
 376
 377         /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n */
 378         strlcpy(name, pci_name(dev->dev->pdev), max);
 379         strncpy(base_name, name, 8); /*till xxxx:yy:*/
 380         base_name[8] = '\0';
 381         /* with no ARI only 3 last bits are used so when the fn is higher than 8
 382          * need to add it to the dev num, so count in the last number will be
 383          * modulo 8 */
 384         sprintf(name, "%s%.2d.%d", base_name, (i/8), (i%8));
 385 }
 386
 387 struct mlx4_port {
 388         struct kobject         kobj;
 389         struct mlx4_ib_dev    *dev;
 390         struct attribute_group pkey_group;
 391         struct attribute_group gid_group;
 392         struct device_attribute enable_smi_admin;
 393         struct device_attribute smi_enabled;
 394         int                    slave;
 395         u8                     port_num;
 396 };
 397
 398
 399 static void mlx4_port_release(struct kobject *kobj)
 400 {
 401         struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
 402         struct attribute *a;
 403         int i;
 404
 405         for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
 406                 kfree(a);
 407         kfree(p->pkey_group.attrs);
 408         for (i = 0; (a = p->gid_group.attrs[i]); ++i)
 409                 kfree(a);
 410         kfree(p->gid_group.attrs);
 411         kfree(p);
 412 }
 413
 414 struct port_attribute {
 415         struct attribute attr;
 416         ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf);
 417         ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
 418                          const char *buf, size_t count);
 419 };
 420
 421 static ssize_t port_attr_show(struct kobject *kobj,
 422                               struct attribute *attr, char *buf)
 423 {
 424         struct port_attribute *port_attr =
 425                 container_of(attr, struct port_attribute, attr);
 426         struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
 427
 428         if (!port_attr->show)
 429                 return -EIO;
 430         return port_attr->show(p, port_attr, buf);
 431 }
 432
 433 static ssize_t port_attr_store(struct kobject *kobj,
 434                                struct attribute *attr,
 435                                const char *buf, size_t size)
 436 {
 437         struct port_attribute *port_attr =
 438                 container_of(attr, struct port_attribute, attr);
 439         struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
 440
 441         if (!port_attr->store)
 442                 return -EIO;
 443         return port_attr->store(p, port_attr, buf, size);
 444 }
 445
 446 static const struct sysfs_ops port_sysfs_ops = {
 447         .show = port_attr_show,
 448         .store = port_attr_store,
 449 };
 450
 451 static struct kobj_type port_type = {
 452         .release    = mlx4_port_release,
 453         .sysfs_ops  = &port_sysfs_ops,
 454 };
 455
 456 struct port_table_attribute {
 457         struct port_attribute   attr;
 458         char                    name[8];
 459         int                     index;
 460 };
 461
 462 static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
 463                               char *buf)
 464 {
 465         struct port_table_attribute *tab_attr =
 466                 container_of(attr, struct port_table_attribute, attr);
 467         ssize_t ret = -ENODEV;
 468
 469         if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >=
 470             (p->dev->dev->caps.pkey_table_len[p->port_num]))
 471                 ret = sprintf(buf, "none\n");
 472         else
 473                 ret = sprintf(buf, "%d\n",
 474                               p->dev->pkeys.virt2phys_pkey[p->slave]
 475                               [p->port_num - 1][tab_attr->index]);
 476         return ret;
 477 }
 478
 479 static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
 480                                const char *buf, size_t count)
 481 {
 482         struct port_table_attribute *tab_attr =
 483                 container_of(attr, struct port_table_attribute, attr);
 484         int idx;
 485         int err;
 486
 487         /* do not allow remapping Dom0 virtual pkey table */
 488         if (p->slave == mlx4_master_func_num(p->dev->dev))
 489                 return -EINVAL;
 490
 491         if (!strncasecmp(buf, "no", 2))
 492                 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
 493         else if (sscanf(buf, "%i", &idx) != 1 ||
 494                  idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
 495                  idx < 0)
 496                 return -EINVAL;
 497
 498         p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
 499                                     [tab_attr->index] = idx;
 500         mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
 501                              tab_attr->index, idx);
 502         err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
 503         if (err) {
 504                 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
 505                        " port %d, index %d\n", p->slave, p->port_num, idx);
 506                 return err;
 507         }
 508         return count;
 509 }
 510
 511 static ssize_t show_port_gid_idx(struct mlx4_port *p,
 512                                  struct port_attribute *attr, char *buf)
 513 {
 514         return sprintf(buf, "%d\n", p->slave);
 515 }
 516
 517 static struct attribute **
 518 alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
 519                                   struct port_attribute *, char *buf),
 520                   ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
 521                                    const char *buf, size_t count),
 522                   int len)
 523 {
 524         struct attribute **tab_attr;
 525         struct port_table_attribute *element;
 526         int i;
 527
 528         tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
 529         if (!tab_attr)
 530                 return NULL;
 531
 532         for (i = 0; i < len; i++) {
 533                 element = kzalloc(sizeof (struct port_table_attribute),
 534                                   GFP_KERNEL);
 535                 if (!element)
 536                         goto err;
 537                 if (snprintf(element->name, sizeof (element->name),
 538                              "%d", i) >= sizeof (element->name)) {
 539                         kfree(element);
 540                         goto err;
 541                 }
 542                 sysfs_attr_init(&element->attr.attr);
 543                 element->attr.attr.name  = element->name;
 544                 if (store) {
 545                         element->attr.attr.mode  = S_IWUSR | S_IRUGO;
 546                         element->attr.store      = store;
 547                 } else
 548                         element->attr.attr.mode  = S_IRUGO;
 549
 550                 element->attr.show       = show;
 551                 element->index           = i;
 552                 tab_attr[i] = &element->attr.attr;
 553         }
 554         return tab_attr;
 555
 556 err:
 557         while (--i >= 0)
 558                 kfree(tab_attr[i]);
 559         kfree(tab_attr);
 560         return NULL;
 561 }
 562
 563 static ssize_t sysfs_show_smi_enabled(struct device *dev,
 564                                       struct device_attribute *attr, char *buf)
 565 {
 566         struct mlx4_port *p =
 567                 container_of(attr, struct mlx4_port, smi_enabled);
 568         ssize_t len = 0;
 569
 570         if (mlx4_vf_smi_enabled(p->dev->dev, p->slave, p->port_num))
 571                 len = sprintf(buf, "%d\n", 1);
 572         else
 573                 len = sprintf(buf, "%d\n", 0);
 574
 575         return len;
 576 }
 577
 578 static ssize_t sysfs_show_enable_smi_admin(struct device *dev,
 579                                            struct device_attribute *attr,
 580                                            char *buf)
 581 {
 582         struct mlx4_port *p =
 583                 container_of(attr, struct mlx4_port, enable_smi_admin);
 584         ssize_t len = 0;
 585
 586         if (mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave, p->port_num))
 587                 len = sprintf(buf, "%d\n", 1);
 588         else
 589                 len = sprintf(buf, "%d\n", 0);
 590
 591         return len;
 592 }
 593
 594 static ssize_t sysfs_store_enable_smi_admin(struct device *dev,
 595                                             struct device_attribute *attr,
 596                                             const char *buf, size_t count)
 597 {
 598         struct mlx4_port *p =
 599                 container_of(attr, struct mlx4_port, enable_smi_admin);
 600         int enable;
 601
 602         if (sscanf(buf, "%i", &enable) != 1 ||
 603             enable < 0 || enable > 1)
 604                 return -EINVAL;
 605
 606         if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable))
 607                 return -EINVAL;
 608         return count;
 609 }
 610
 611 static int add_vf_smi_entries(struct mlx4_port *p)
 612 {
 613         int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
 614                         IB_LINK_LAYER_ETHERNET;
 615         int ret;
 616
 617         /* do not display entries if eth transport, or if master */
 618         if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
 619                 return 0;
 620
 621         sysfs_attr_init(&p->smi_enabled.attr);
 622         p->smi_enabled.show = sysfs_show_smi_enabled;
 623         p->smi_enabled.store = NULL;
 624         p->smi_enabled.attr.name = "smi_enabled";
 625         p->smi_enabled.attr.mode = 0444;
 626         ret = sysfs_create_file(&p->kobj, &p->smi_enabled.attr);
 627         if (ret) {
 628                 pr_err("failed to create smi_enabled\n");
 629                 return ret;
 630         }
 631
 632         sysfs_attr_init(&p->enable_smi_admin.attr);
 633         p->enable_smi_admin.show = sysfs_show_enable_smi_admin;
 634         p->enable_smi_admin.store = sysfs_store_enable_smi_admin;
 635         p->enable_smi_admin.attr.name = "enable_smi_admin";
 636         p->enable_smi_admin.attr.mode = 0644;
 637         ret = sysfs_create_file(&p->kobj, &p->enable_smi_admin.attr);
 638         if (ret) {
 639                 pr_err("failed to create enable_smi_admin\n");
 640                 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
 641                 return ret;
 642         }
 643         return 0;
 644 }
 645
 646 static void remove_vf_smi_entries(struct mlx4_port *p)
 647 {
 648         int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
 649                         IB_LINK_LAYER_ETHERNET;
 650
 651         if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
 652                 return;
 653
 654         sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
 655         sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr);
 656 }
 657
 658 static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
 659 {
 660         struct mlx4_port *p;
 661         int i;
 662         int ret;
 663         int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) ==
 664                         IB_LINK_LAYER_ETHERNET;
 665
 666         p = kzalloc(sizeof *p, GFP_KERNEL);
 667         if (!p)
 668                 return -ENOMEM;
 669
 670         p->dev = dev;
 671         p->port_num = port_num;
 672         p->slave = slave;
 673
 674         ret = kobject_init_and_add(&p->kobj, &port_type,
 675                                    kobject_get(dev->dev_ports_parent[slave]),
 676                                    "%d", port_num);
 677         if (ret)
 678                 goto err_alloc;
 679
 680         p->pkey_group.name  = "pkey_idx";
 681         p->pkey_group.attrs =
 682                 alloc_group_attrs(show_port_pkey,
 683                                   is_eth ? NULL : store_port_pkey,
 684                                   dev->dev->caps.pkey_table_len[port_num]);
 685         if (!p->pkey_group.attrs) {
 686                 ret = -ENOMEM;
 687                 goto err_alloc;
 688         }
 689
 690         ret = sysfs_create_group(&p->kobj, &p->pkey_group);
 691         if (ret)
 692                 goto err_free_pkey;
 693
 694         p->gid_group.name  = "gid_idx";
 695         p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
 696         if (!p->gid_group.attrs) {
 697                 ret = -ENOMEM;
 698                 goto err_free_pkey;
 699         }
 700
 701         ret = sysfs_create_group(&p->kobj, &p->gid_group);
 702         if (ret)
 703                 goto err_free_gid;
 704
 705         ret = add_vf_smi_entries(p);
 706         if (ret)
 707                 goto err_free_gid;
 708
 709         list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
 710         return 0;
 711
 712 err_free_gid:
 713         kfree(p->gid_group.attrs[0]);
 714         kfree(p->gid_group.attrs);
 715
 716 err_free_pkey:
 717         for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
 718                 kfree(p->pkey_group.attrs[i]);
 719         kfree(p->pkey_group.attrs);
 720
 721 err_alloc:
 722         kobject_put(dev->dev_ports_parent[slave]);
 723         kfree(p);
 724         return ret;
 725 }
 726
 727 static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
 728 {
 729         char name[32];
 730         int err;
 731         int port;
 732         struct kobject *p, *t;
 733         struct mlx4_port *mport;
 734         struct mlx4_active_ports actv_ports;
 735
 736         get_name(dev, name, slave, sizeof name);
 737
 738         dev->pkeys.device_parent[slave] =
 739                 kobject_create_and_add(name, kobject_get(dev->iov_parent));
 740
 741         if (!dev->pkeys.device_parent[slave]) {
 742                 err = -ENOMEM;
 743                 goto fail_dev;
 744         }
 745
 746         INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
 747
 748         dev->dev_ports_parent[slave] =
 749                 kobject_create_and_add("ports",
 750                                        kobject_get(dev->pkeys.device_parent[slave]));
 751
 752         if (!dev->dev_ports_parent[slave]) {
 753                 err = -ENOMEM;
 754                 goto err_ports;
 755         }
 756
 757         actv_ports = mlx4_get_active_ports(dev->dev, slave);
 758
 759         for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
 760                 if (!test_bit(port - 1, actv_ports.ports))
 761                         continue;
 762                 err = add_port(dev, port, slave);
 763                 if (err)
 764                         goto err_add;
 765         }
 766         return 0;
 767
 768 err_add:
 769         list_for_each_entry_safe(p, t,
 770                                  &dev->pkeys.pkey_port_list[slave],
 771                                  entry) {
 772                 list_del(&p->entry);
 773                 mport = container_of(p, struct mlx4_port, kobj);
 774                 sysfs_remove_group(p, &mport->pkey_group);
 775                 sysfs_remove_group(p, &mport->gid_group);
 776                 remove_vf_smi_entries(mport);
 777                 kobject_put(p);
 778         }
 779         kobject_put(dev->dev_ports_parent[slave]);
 780
 781 err_ports:
 782         kobject_put(dev->pkeys.device_parent[slave]);
 783         /* extra put for the device_parent create_and_add */
 784         kobject_put(dev->pkeys.device_parent[slave]);
 785
 786 fail_dev:
 787         kobject_put(dev->iov_parent);
 788         return err;
 789 }
 790
 791 static int register_pkey_tree(struct mlx4_ib_dev *device)
 792 {
 793         int i;
 794
 795         if (!mlx4_is_master(device->dev))
 796                 return 0;
 797
 798         for (i = 0; i <= device->dev->num_vfs; ++i)
 799                 register_one_pkey_tree(device, i);
 800
 801         return 0;
 802 }
 803
 804 static void unregister_pkey_tree(struct mlx4_ib_dev *device)
 805 {
 806         int slave;
 807         struct kobject *p, *t;
 808         struct mlx4_port *port;
 809
 810         if (!mlx4_is_master(device->dev))
 811                 return;
 812
 813         for (slave = device->dev->num_vfs; slave >= 0; --slave) {
 814                 list_for_each_entry_safe(p, t,
 815                                          &device->pkeys.pkey_port_list[slave],
 816                                          entry) {
 817                         list_del(&p->entry);
 818                         port = container_of(p, struct mlx4_port, kobj);
 819                         sysfs_remove_group(p, &port->pkey_group);
 820                         sysfs_remove_group(p, &port->gid_group);
 821                         remove_vf_smi_entries(port);
 822                         kobject_put(p);
 823                         kobject_put(device->dev_ports_parent[slave]);
 824                 }
 825                 kobject_put(device->dev_ports_parent[slave]);
 826                 kobject_put(device->pkeys.device_parent[slave]);
 827                 kobject_put(device->pkeys.device_parent[slave]);
 828                 kobject_put(device->iov_parent);
 829         }
 830 }
 831
 832 int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
 833 {
 834         int i;
 835         int ret = 0;
 836
 837         if (!mlx4_is_master(dev->dev))
 838                 return 0;
 839
 840         dev->iov_parent =
 841                 kobject_create_and_add("iov",
 842                                        kobject_get(dev->ib_dev.ports_parent->parent));
 843         if (!dev->iov_parent) {
 844                 ret = -ENOMEM;
 845                 goto err;
 846         }
 847         dev->ports_parent =
 848                 kobject_create_and_add("ports",
 849                                        kobject_get(dev->iov_parent));
 850         if (!dev->ports_parent) {
 851                 ret = -ENOMEM;
 852                 goto err_ports;
 853         }
 854
 855         for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
 856                 ret = add_port_entries(dev, i);
 857                 if (ret)
 858                         goto err_add_entries;
 859         }
 860
 861         ret = register_pkey_tree(dev);
 862         if (ret)
 863                 goto err_add_entries;
 864         return 0;
 865
 866 err_add_entries:
 867         kobject_put(dev->ports_parent);
 868
 869 err_ports:
 870         kobject_put(dev->iov_parent);
 871 err:
 872         kobject_put(dev->ib_dev.ports_parent->parent);
 873         pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
 874         return ret;
 875 }
 876
 877 static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
 878 {
 879         struct mlx4_ib_iov_port *p;
 880         int i;
 881
 882         if (!mlx4_is_master(device->dev))
 883                 return;
 884
 885         for (i = 0; i < device->dev->caps.num_ports; i++) {
 886                 p = &device->iov_ports[i];
 887                 kobject_put(p->admin_alias_parent);
 888                 kobject_put(p->gids_parent);
 889                 kobject_put(p->pkeys_parent);
 890                 kobject_put(p->mcgs_parent);
 891                 kobject_put(p->cur_port);
 892                 kobject_put(p->cur_port);
 893                 kobject_put(p->cur_port);
 894                 kobject_put(p->cur_port);
 895                 kobject_put(p->cur_port);
 896                 kobject_put(p->dev->ports_parent);
 897                 kfree(p->dentr_ar);
 898         }
 899 }
 900
 901 void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
 902 {
 903         unregister_alias_guid_tree(device);
 904         unregister_pkey_tree(device);
 905         kobject_put(device->ports_parent);
 906         kobject_put(device->iov_parent);
 907         kobject_put(device->iov_parent);
 908         kobject_put(device->ib_dev.ports_parent->parent);
 909 }