2 * Copyright (c) 2012 Mellanox Technologies. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
33 /*#include "core_priv.h"*/
35 #include <linux/slab.h>
36 #include <linux/string.h>
37 #include <linux/stat.h>
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.
46 static ssize_t show_admin_alias_guid(struct device *dev,
47 struct device_attribute *attr, char *buf)
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;
56 record_num = mlx4_ib_iov_dentry->entry_num / 8 ;
57 guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8 ;
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]));
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.
72 static ssize_t store_admin_alias_guid(struct device *dev,
73 struct device_attribute *attr,
74 const char *buf, size_t count)
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;
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");
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);
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 ;
100 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
101 = MLX4_GUID_INFO_RECORD_SET;
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;
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;
115 /* The sysadmin requests a specific value.*/
117 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
118 = MLX4_GUID_SYSADMIN_ASSIGN;
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);
126 mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
131 static ssize_t show_port_gid(struct device *dev,
132 struct device_attribute *attr,
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;
142 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
143 mlx4_ib_iov_dentry->entry_num, &gid, 1);
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]));
158 static ssize_t show_phys_port_pkey(struct device *dev,
159 struct device_attribute *attr,
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;
169 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
170 mlx4_ib_iov_dentry->entry_num, &pkey, 1);
174 return sprintf(buf, "0x%04x\n", pkey);
177 #define DENTRY_REMOVE(_dentry) \
179 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \
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,
187 ssize_t (*store)(struct device *dev,
188 struct device_attribute *attr,
189 const char *buf, size_t count)
193 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
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);
204 if (vdentry->dentry.store)
205 vdentry->dentry.attr.mode |= S_IWUSR;
207 if (vdentry->dentry.show)
208 vdentry->dentry.attr.mode |= S_IRUGO;
210 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
212 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
220 int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
221 struct attribute *attr)
223 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
226 ret = sysfs_create_file(port->mcgs_parent, attr);
228 pr_err("failed to create %s\n", attr->name);
233 void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
234 struct attribute *attr)
236 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
238 sysfs_remove_file(port->mcgs_parent, attr);
241 static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
245 struct mlx4_ib_iov_port *port = NULL;
247 struct ib_port_attr attr;
249 /* get the physical gid and pkey table sizes.*/
250 ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
254 port = &device->iov_ports[port_num - 1];
256 port->num = port_num;
257 /* Directory structure:
264 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
266 if (!port->dentr_ar) {
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) {
275 goto kobj_create_err;
278 port->admin_alias_parent = kobject_create_and_add("admin_guids",
279 kobject_get(port->cur_port));
280 if (!port->admin_alias_parent) {
282 goto err_admin_guids;
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);
291 goto err_admin_alias_parent;
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) {
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],
308 port->gids_parent, show_port_gid, NULL);
310 goto err_gids_parent;
313 /* physical port pkey table */
315 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
316 if (!port->pkeys_parent) {
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);
329 goto err_pkeys_parent;
334 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
335 if (!port->mcgs_parent) {
342 kobject_put(port->cur_port);
345 kobject_put(port->pkeys_parent);
348 kobject_put(port->cur_port);
351 kobject_put(port->gids_parent);
354 kobject_put(port->cur_port);
356 err_admin_alias_parent:
357 kobject_put(port->admin_alias_parent);
360 kobject_put(port->cur_port);
361 kobject_put(port->cur_port); /* once more for create_and_add buff */
364 kobject_put(device->ports_parent);
365 kfree(port->dentr_ar);
368 pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
373 static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
377 /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n */
378 strlcpy(name, pci_name(dev->dev->persist->pdev), max);
379 strncpy(base_name, name, 8); /*till xxxx:yy:*/
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
384 sprintf(name, "%s%.2d.%d", base_name, (i/8), (i%8));
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;
399 static void mlx4_port_release(struct kobject *kobj)
401 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
405 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
407 kfree(p->pkey_group.attrs);
408 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
410 kfree(p->gid_group.attrs);
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);
421 static ssize_t port_attr_show(struct kobject *kobj,
422 struct attribute *attr, char *buf)
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);
428 if (!port_attr->show)
430 return port_attr->show(p, port_attr, buf);
433 static ssize_t port_attr_store(struct kobject *kobj,
434 struct attribute *attr,
435 const char *buf, size_t size)
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);
441 if (!port_attr->store)
443 return port_attr->store(p, port_attr, buf, size);
446 static const struct sysfs_ops port_sysfs_ops = {
447 .show = port_attr_show,
448 .store = port_attr_store,
451 static struct kobj_type port_type = {
452 .release = mlx4_port_release,
453 .sysfs_ops = &port_sysfs_ops,
456 struct port_table_attribute {
457 struct port_attribute attr;
462 static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
465 struct port_table_attribute *tab_attr =
466 container_of(attr, struct port_table_attribute, attr);
467 ssize_t ret = -ENODEV;
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");
473 ret = sprintf(buf, "%d\n",
474 p->dev->pkeys.virt2phys_pkey[p->slave]
475 [p->port_num - 1][tab_attr->index]);
479 static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
480 const char *buf, size_t count)
482 struct port_table_attribute *tab_attr =
483 container_of(attr, struct port_table_attribute, attr);
487 /* do not allow remapping Dom0 virtual pkey table */
488 if (p->slave == mlx4_master_func_num(p->dev->dev))
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] ||
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);
504 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
505 " port %d, index %d\n", p->slave, p->port_num, idx);
511 static ssize_t show_port_gid_idx(struct mlx4_port *p,
512 struct port_attribute *attr, char *buf)
514 return sprintf(buf, "%d\n", p->slave);
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),
524 struct attribute **tab_attr;
525 struct port_table_attribute *element;
528 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
532 for (i = 0; i < len; i++) {
533 element = kzalloc(sizeof (struct port_table_attribute),
537 if (snprintf(element->name, sizeof (element->name),
538 "%d", i) >= sizeof (element->name)) {
542 sysfs_attr_init(&element->attr.attr);
543 element->attr.attr.name = element->name;
545 element->attr.attr.mode = S_IWUSR | S_IRUGO;
546 element->attr.store = store;
548 element->attr.attr.mode = S_IRUGO;
550 element->attr.show = show;
552 tab_attr[i] = &element->attr.attr;
563 static ssize_t sysfs_show_smi_enabled(struct device *dev,
564 struct device_attribute *attr, char *buf)
566 struct mlx4_port *p =
567 container_of(attr, struct mlx4_port, smi_enabled);
570 if (mlx4_vf_smi_enabled(p->dev->dev, p->slave, p->port_num))
571 len = sprintf(buf, "%d\n", 1);
573 len = sprintf(buf, "%d\n", 0);
578 static ssize_t sysfs_show_enable_smi_admin(struct device *dev,
579 struct device_attribute *attr,
582 struct mlx4_port *p =
583 container_of(attr, struct mlx4_port, enable_smi_admin);
586 if (mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave, p->port_num))
587 len = sprintf(buf, "%d\n", 1);
589 len = sprintf(buf, "%d\n", 0);
594 static ssize_t sysfs_store_enable_smi_admin(struct device *dev,
595 struct device_attribute *attr,
596 const char *buf, size_t count)
598 struct mlx4_port *p =
599 container_of(attr, struct mlx4_port, enable_smi_admin);
602 if (sscanf(buf, "%i", &enable) != 1 ||
603 enable < 0 || enable > 1)
606 if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable))
611 static int add_vf_smi_entries(struct mlx4_port *p)
613 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
614 IB_LINK_LAYER_ETHERNET;
617 /* do not display entries if eth transport, or if master */
618 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
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);
628 pr_err("failed to create smi_enabled\n");
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);
639 pr_err("failed to create enable_smi_admin\n");
640 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
646 static void remove_vf_smi_entries(struct mlx4_port *p)
648 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
649 IB_LINK_LAYER_ETHERNET;
651 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
654 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
655 sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr);
658 static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
664 p = kzalloc(sizeof *p, GFP_KERNEL);
669 p->port_num = port_num;
672 ret = kobject_init_and_add(&p->kobj, &port_type,
673 kobject_get(dev->dev_ports_parent[slave]),
678 p->pkey_group.name = "pkey_idx";
679 p->pkey_group.attrs =
680 alloc_group_attrs(show_port_pkey, store_port_pkey,
681 dev->dev->caps.pkey_table_len[port_num]);
682 if (!p->pkey_group.attrs) {
687 ret = sysfs_create_group(&p->kobj, &p->pkey_group);
691 p->gid_group.name = "gid_idx";
692 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
693 if (!p->gid_group.attrs) {
698 ret = sysfs_create_group(&p->kobj, &p->gid_group);
702 ret = add_vf_smi_entries(p);
706 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
710 kfree(p->gid_group.attrs[0]);
711 kfree(p->gid_group.attrs);
714 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
715 kfree(p->pkey_group.attrs[i]);
716 kfree(p->pkey_group.attrs);
719 kobject_put(dev->dev_ports_parent[slave]);
724 static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
729 struct kobject *p, *t;
730 struct mlx4_port *mport;
731 struct mlx4_active_ports actv_ports;
733 get_name(dev, name, slave, sizeof name);
735 dev->pkeys.device_parent[slave] =
736 kobject_create_and_add(name, kobject_get(dev->iov_parent));
738 if (!dev->pkeys.device_parent[slave]) {
743 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
745 dev->dev_ports_parent[slave] =
746 kobject_create_and_add("ports",
747 kobject_get(dev->pkeys.device_parent[slave]));
749 if (!dev->dev_ports_parent[slave]) {
754 actv_ports = mlx4_get_active_ports(dev->dev, slave);
756 for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
757 if (!test_bit(port - 1, actv_ports.ports))
759 err = add_port(dev, port, slave);
766 list_for_each_entry_safe(p, t,
767 &dev->pkeys.pkey_port_list[slave],
770 mport = container_of(p, struct mlx4_port, kobj);
771 sysfs_remove_group(p, &mport->pkey_group);
772 sysfs_remove_group(p, &mport->gid_group);
773 remove_vf_smi_entries(mport);
776 kobject_put(dev->dev_ports_parent[slave]);
779 kobject_put(dev->pkeys.device_parent[slave]);
780 /* extra put for the device_parent create_and_add */
781 kobject_put(dev->pkeys.device_parent[slave]);
784 kobject_put(dev->iov_parent);
788 static int register_pkey_tree(struct mlx4_ib_dev *device)
792 if (!mlx4_is_master(device->dev))
795 for (i = 0; i <= device->dev->persist->num_vfs; ++i)
796 register_one_pkey_tree(device, i);
801 static void unregister_pkey_tree(struct mlx4_ib_dev *device)
804 struct kobject *p, *t;
805 struct mlx4_port *port;
807 if (!mlx4_is_master(device->dev))
810 for (slave = device->dev->persist->num_vfs; slave >= 0; --slave) {
811 list_for_each_entry_safe(p, t,
812 &device->pkeys.pkey_port_list[slave],
815 port = container_of(p, struct mlx4_port, kobj);
816 sysfs_remove_group(p, &port->pkey_group);
817 sysfs_remove_group(p, &port->gid_group);
818 remove_vf_smi_entries(port);
820 kobject_put(device->dev_ports_parent[slave]);
822 kobject_put(device->dev_ports_parent[slave]);
823 kobject_put(device->pkeys.device_parent[slave]);
824 kobject_put(device->pkeys.device_parent[slave]);
825 kobject_put(device->iov_parent);
829 int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
834 if (!mlx4_is_master(dev->dev))
838 kobject_create_and_add("iov",
839 kobject_get(dev->ib_dev.ports_parent->parent));
840 if (!dev->iov_parent) {
845 kobject_create_and_add("ports",
846 kobject_get(dev->iov_parent));
847 if (!dev->ports_parent) {
852 for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
853 ret = add_port_entries(dev, i);
855 goto err_add_entries;
858 ret = register_pkey_tree(dev);
860 goto err_add_entries;
864 kobject_put(dev->ports_parent);
867 kobject_put(dev->iov_parent);
869 kobject_put(dev->ib_dev.ports_parent->parent);
870 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
874 static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
876 struct mlx4_ib_iov_port *p;
879 if (!mlx4_is_master(device->dev))
882 for (i = 0; i < device->dev->caps.num_ports; i++) {
883 p = &device->iov_ports[i];
884 kobject_put(p->admin_alias_parent);
885 kobject_put(p->gids_parent);
886 kobject_put(p->pkeys_parent);
887 kobject_put(p->mcgs_parent);
888 kobject_put(p->cur_port);
889 kobject_put(p->cur_port);
890 kobject_put(p->cur_port);
891 kobject_put(p->cur_port);
892 kobject_put(p->cur_port);
893 kobject_put(p->dev->ports_parent);
898 void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
900 unregister_alias_guid_tree(device);
901 unregister_pkey_tree(device);
902 kobject_put(device->ports_parent);
903 kobject_put(device->iov_parent);
904 kobject_put(device->iov_parent);
905 kobject_put(device->ib_dev.ports_parent->parent);