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 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
50 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
51 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
52 struct mlx4_ib_dev *mdev = port->dev;
53 __be64 sysadmin_ag_val;
55 sysadmin_ag_val = mlx4_get_admin_guid(mdev->dev,
56 mlx4_ib_iov_dentry->entry_num,
59 return sysfs_emit(buf, "%llx\n", be64_to_cpu(sysadmin_ag_val));
62 /* store_admin_alias_guid stores the (new) administratively assigned value of that GUID.
63 * Values in buf parameter string:
64 * 0 - requests opensm to assign a value.
65 * 0xffffffffffffffff - delete this entry.
66 * other - guid value assigned by the administrator.
68 static ssize_t store_admin_alias_guid(struct device *dev,
69 struct device_attribute *attr,
70 const char *buf, size_t count)
72 int record_num;/*0-15*/
73 int guid_index_in_rec; /*0 - 7*/
74 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
75 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
76 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
77 struct mlx4_ib_dev *mdev = port->dev;
81 record_num = mlx4_ib_iov_dentry->entry_num / 8;
82 guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8;
83 if (0 == record_num && 0 == guid_index_in_rec) {
84 pr_err("GUID 0 block 0 is RO\n");
87 spin_lock_irqsave(&mdev->sriov.alias_guid.ag_work_lock, flags);
88 sscanf(buf, "%llx", &sysadmin_ag_val);
89 *(__be64 *)&mdev->sriov.alias_guid.ports_guid[port->num - 1].
90 all_rec_per_port[record_num].
91 all_recs[GUID_REC_SIZE * guid_index_in_rec] =
92 cpu_to_be64(sysadmin_ag_val);
94 /* Change the state to be pending for update */
95 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].status
96 = MLX4_GUID_INFO_STATUS_IDLE ;
97 mlx4_set_admin_guid(mdev->dev, cpu_to_be64(sysadmin_ag_val),
98 mlx4_ib_iov_dentry->entry_num,
101 /* set the record index */
102 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].guid_indexes
103 |= mlx4_ib_get_aguid_comp_mask_from_ix(guid_index_in_rec);
105 spin_unlock_irqrestore(&mdev->sriov.alias_guid.ag_work_lock, flags);
106 mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
111 static ssize_t show_port_gid(struct device *dev,
112 struct device_attribute *attr,
115 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
116 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
117 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
118 struct mlx4_ib_dev *mdev = port->dev;
123 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
124 mlx4_ib_iov_dentry->entry_num, &gid, 1);
128 raw = (__be16 *)gid.raw;
129 return sysfs_emit(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
137 be16_to_cpu(raw[7]));
140 static ssize_t show_phys_port_pkey(struct device *dev,
141 struct device_attribute *attr,
144 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
145 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
146 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
147 struct mlx4_ib_dev *mdev = port->dev;
151 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
152 mlx4_ib_iov_dentry->entry_num, &pkey, 1);
156 return sysfs_emit(buf, "0x%04x\n", pkey);
159 #define DENTRY_REMOVE(_dentry) \
161 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \
164 static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,
165 char *_name, struct kobject *_kobj,
166 ssize_t (*show)(struct device *dev,
167 struct device_attribute *attr,
169 ssize_t (*store)(struct device *dev,
170 struct device_attribute *attr,
171 const char *buf, size_t count)
175 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
178 vdentry->dentry.show = show;
179 vdentry->dentry.store = store;
180 sysfs_attr_init(&vdentry->dentry.attr);
181 vdentry->dentry.attr.name = vdentry->name;
182 vdentry->dentry.attr.mode = 0;
183 vdentry->kobj = _kobj;
184 snprintf(vdentry->name, 15, "%s", _name);
186 if (vdentry->dentry.store)
187 vdentry->dentry.attr.mode |= S_IWUSR;
189 if (vdentry->dentry.show)
190 vdentry->dentry.attr.mode |= S_IRUGO;
192 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
194 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
202 int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
203 struct attribute *attr)
205 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
208 ret = sysfs_create_file(port->mcgs_parent, attr);
210 pr_err("failed to create %s\n", attr->name);
215 void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
216 struct attribute *attr)
218 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
220 sysfs_remove_file(port->mcgs_parent, attr);
223 static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
227 struct mlx4_ib_iov_port *port = NULL;
229 struct ib_port_attr attr;
231 memset(&attr, 0, sizeof(attr));
232 /* get the physical gid and pkey table sizes.*/
233 ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
237 port = &device->iov_ports[port_num - 1];
239 port->num = port_num;
240 /* Directory structure:
247 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
249 if (!port->dentr_ar) {
253 sprintf(buff, "%d", port_num);
254 port->cur_port = kobject_create_and_add(buff,
255 kobject_get(device->ports_parent));
256 if (!port->cur_port) {
258 goto kobj_create_err;
261 port->admin_alias_parent = kobject_create_and_add("admin_guids",
262 kobject_get(port->cur_port));
263 if (!port->admin_alias_parent) {
265 goto err_admin_guids;
267 for (i = 0 ; i < attr.gid_tbl_len; i++) {
268 sprintf(buff, "%d", i);
269 port->dentr_ar->dentries[i].entry_num = i;
270 ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i],
271 buff, port->admin_alias_parent,
272 show_admin_alias_guid, store_admin_alias_guid);
274 goto err_admin_alias_parent;
277 /* gids subdirectory (operational gids) */
278 port->gids_parent = kobject_create_and_add("gids",
279 kobject_get(port->cur_port));
280 if (!port->gids_parent) {
285 for (i = 0 ; i < attr.gid_tbl_len; i++) {
286 sprintf(buff, "%d", i);
287 port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i;
288 ret = create_sysfs_entry(port,
289 &port->dentr_ar->dentries[attr.gid_tbl_len + i],
291 port->gids_parent, show_port_gid, NULL);
293 goto err_gids_parent;
296 /* physical port pkey table */
298 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
299 if (!port->pkeys_parent) {
304 for (i = 0 ; i < attr.pkey_tbl_len; i++) {
305 sprintf(buff, "%d", i);
306 port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i;
307 ret = create_sysfs_entry(port,
308 &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i],
309 buff, port->pkeys_parent,
310 show_phys_port_pkey, NULL);
312 goto err_pkeys_parent;
317 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
318 if (!port->mcgs_parent) {
325 kobject_put(port->cur_port);
328 kobject_put(port->pkeys_parent);
331 kobject_put(port->cur_port);
334 kobject_put(port->gids_parent);
337 kobject_put(port->cur_port);
339 err_admin_alias_parent:
340 kobject_put(port->admin_alias_parent);
343 kobject_put(port->cur_port);
344 kobject_put(port->cur_port); /* once more for create_and_add buff */
347 kobject_put(device->ports_parent);
348 kfree(port->dentr_ar);
351 pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
356 static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
358 /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n
359 * with no ARI only 3 last bits are used so when the fn is higher than 8
360 * need to add it to the dev num, so count in the last number will be
362 snprintf(name, max, "%.8s%.2d.%d", pci_name(dev->dev->persist->pdev),
368 struct mlx4_ib_dev *dev;
369 struct attribute_group pkey_group;
370 struct attribute_group gid_group;
371 struct device_attribute enable_smi_admin;
372 struct device_attribute smi_enabled;
378 static void mlx4_port_release(struct kobject *kobj)
380 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
384 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
386 kfree(p->pkey_group.attrs);
387 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
389 kfree(p->gid_group.attrs);
393 struct port_attribute {
394 struct attribute attr;
395 ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf);
396 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
397 const char *buf, size_t count);
400 static ssize_t port_attr_show(struct kobject *kobj,
401 struct attribute *attr, char *buf)
403 struct port_attribute *port_attr =
404 container_of(attr, struct port_attribute, attr);
405 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
407 if (!port_attr->show)
409 return port_attr->show(p, port_attr, buf);
412 static ssize_t port_attr_store(struct kobject *kobj,
413 struct attribute *attr,
414 const char *buf, size_t size)
416 struct port_attribute *port_attr =
417 container_of(attr, struct port_attribute, attr);
418 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
420 if (!port_attr->store)
422 return port_attr->store(p, port_attr, buf, size);
425 static const struct sysfs_ops port_sysfs_ops = {
426 .show = port_attr_show,
427 .store = port_attr_store,
430 static struct kobj_type port_type = {
431 .release = mlx4_port_release,
432 .sysfs_ops = &port_sysfs_ops,
435 struct port_table_attribute {
436 struct port_attribute attr;
441 static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
444 struct port_table_attribute *tab_attr =
445 container_of(attr, struct port_table_attribute, attr);
446 ssize_t ret = -ENODEV;
448 if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >=
449 (p->dev->dev->caps.pkey_table_len[p->port_num]))
450 ret = sprintf(buf, "none\n");
452 ret = sprintf(buf, "%d\n",
453 p->dev->pkeys.virt2phys_pkey[p->slave]
454 [p->port_num - 1][tab_attr->index]);
458 static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
459 const char *buf, size_t count)
461 struct port_table_attribute *tab_attr =
462 container_of(attr, struct port_table_attribute, attr);
466 /* do not allow remapping Dom0 virtual pkey table */
467 if (p->slave == mlx4_master_func_num(p->dev->dev))
470 if (!strncasecmp(buf, "no", 2))
471 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
472 else if (sscanf(buf, "%i", &idx) != 1 ||
473 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
477 p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
478 [tab_attr->index] = idx;
479 mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
480 tab_attr->index, idx);
481 err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
483 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
484 " port %d, index %d\n", p->slave, p->port_num, idx);
490 static ssize_t show_port_gid_idx(struct mlx4_port *p,
491 struct port_attribute *attr, char *buf)
493 return sprintf(buf, "%d\n", p->slave);
496 static struct attribute **
497 alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
498 struct port_attribute *, char *buf),
499 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
500 const char *buf, size_t count),
503 struct attribute **tab_attr;
504 struct port_table_attribute *element;
507 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
511 for (i = 0; i < len; i++) {
512 element = kzalloc(sizeof (struct port_table_attribute),
516 if (snprintf(element->name, sizeof (element->name),
517 "%d", i) >= sizeof (element->name)) {
521 sysfs_attr_init(&element->attr.attr);
522 element->attr.attr.name = element->name;
524 element->attr.attr.mode = S_IWUSR | S_IRUGO;
525 element->attr.store = store;
527 element->attr.attr.mode = S_IRUGO;
529 element->attr.show = show;
531 tab_attr[i] = &element->attr.attr;
542 static ssize_t sysfs_show_smi_enabled(struct device *dev,
543 struct device_attribute *attr, char *buf)
545 struct mlx4_port *p =
546 container_of(attr, struct mlx4_port, smi_enabled);
548 return sysfs_emit(buf, "%d\n",
549 !!mlx4_vf_smi_enabled(p->dev->dev, p->slave,
553 static ssize_t sysfs_show_enable_smi_admin(struct device *dev,
554 struct device_attribute *attr,
557 struct mlx4_port *p =
558 container_of(attr, struct mlx4_port, enable_smi_admin);
560 return sysfs_emit(buf, "%d\n",
561 !!mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave,
565 static ssize_t sysfs_store_enable_smi_admin(struct device *dev,
566 struct device_attribute *attr,
567 const char *buf, size_t count)
569 struct mlx4_port *p =
570 container_of(attr, struct mlx4_port, enable_smi_admin);
573 if (sscanf(buf, "%i", &enable) != 1 ||
574 enable < 0 || enable > 1)
577 if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable))
582 static int add_vf_smi_entries(struct mlx4_port *p)
584 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
585 IB_LINK_LAYER_ETHERNET;
588 /* do not display entries if eth transport, or if master */
589 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
592 sysfs_attr_init(&p->smi_enabled.attr);
593 p->smi_enabled.show = sysfs_show_smi_enabled;
594 p->smi_enabled.store = NULL;
595 p->smi_enabled.attr.name = "smi_enabled";
596 p->smi_enabled.attr.mode = 0444;
597 ret = sysfs_create_file(&p->kobj, &p->smi_enabled.attr);
599 pr_err("failed to create smi_enabled\n");
603 sysfs_attr_init(&p->enable_smi_admin.attr);
604 p->enable_smi_admin.show = sysfs_show_enable_smi_admin;
605 p->enable_smi_admin.store = sysfs_store_enable_smi_admin;
606 p->enable_smi_admin.attr.name = "enable_smi_admin";
607 p->enable_smi_admin.attr.mode = 0644;
608 ret = sysfs_create_file(&p->kobj, &p->enable_smi_admin.attr);
610 pr_err("failed to create enable_smi_admin\n");
611 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
617 static void remove_vf_smi_entries(struct mlx4_port *p)
619 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
620 IB_LINK_LAYER_ETHERNET;
622 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
625 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
626 sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr);
629 static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
634 int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) ==
635 IB_LINK_LAYER_ETHERNET;
637 p = kzalloc(sizeof *p, GFP_KERNEL);
642 p->port_num = port_num;
645 ret = kobject_init_and_add(&p->kobj, &port_type,
646 kobject_get(dev->dev_ports_parent[slave]),
651 p->pkey_group.name = "pkey_idx";
652 p->pkey_group.attrs =
653 alloc_group_attrs(show_port_pkey,
654 is_eth ? NULL : store_port_pkey,
655 dev->dev->caps.pkey_table_len[port_num]);
656 if (!p->pkey_group.attrs) {
661 ret = sysfs_create_group(&p->kobj, &p->pkey_group);
665 p->gid_group.name = "gid_idx";
666 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
667 if (!p->gid_group.attrs) {
672 ret = sysfs_create_group(&p->kobj, &p->gid_group);
676 ret = add_vf_smi_entries(p);
680 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
684 kfree(p->gid_group.attrs[0]);
685 kfree(p->gid_group.attrs);
688 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
689 kfree(p->pkey_group.attrs[i]);
690 kfree(p->pkey_group.attrs);
693 kobject_put(dev->dev_ports_parent[slave]);
698 static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
703 struct kobject *p, *t;
704 struct mlx4_port *mport;
705 struct mlx4_active_ports actv_ports;
707 get_name(dev, name, slave, sizeof name);
709 dev->pkeys.device_parent[slave] =
710 kobject_create_and_add(name, kobject_get(dev->iov_parent));
712 if (!dev->pkeys.device_parent[slave]) {
717 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
719 dev->dev_ports_parent[slave] =
720 kobject_create_and_add("ports",
721 kobject_get(dev->pkeys.device_parent[slave]));
723 if (!dev->dev_ports_parent[slave]) {
728 actv_ports = mlx4_get_active_ports(dev->dev, slave);
730 for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
731 if (!test_bit(port - 1, actv_ports.ports))
733 err = add_port(dev, port, slave);
740 list_for_each_entry_safe(p, t,
741 &dev->pkeys.pkey_port_list[slave],
744 mport = container_of(p, struct mlx4_port, kobj);
745 sysfs_remove_group(p, &mport->pkey_group);
746 sysfs_remove_group(p, &mport->gid_group);
747 remove_vf_smi_entries(mport);
750 kobject_put(dev->dev_ports_parent[slave]);
753 kobject_put(dev->pkeys.device_parent[slave]);
754 /* extra put for the device_parent create_and_add */
755 kobject_put(dev->pkeys.device_parent[slave]);
758 kobject_put(dev->iov_parent);
762 static int register_pkey_tree(struct mlx4_ib_dev *device)
766 if (!mlx4_is_master(device->dev))
769 for (i = 0; i <= device->dev->persist->num_vfs; ++i)
770 register_one_pkey_tree(device, i);
775 static void unregister_pkey_tree(struct mlx4_ib_dev *device)
778 struct kobject *p, *t;
779 struct mlx4_port *port;
781 if (!mlx4_is_master(device->dev))
784 for (slave = device->dev->persist->num_vfs; slave >= 0; --slave) {
785 list_for_each_entry_safe(p, t,
786 &device->pkeys.pkey_port_list[slave],
789 port = container_of(p, struct mlx4_port, kobj);
790 sysfs_remove_group(p, &port->pkey_group);
791 sysfs_remove_group(p, &port->gid_group);
792 remove_vf_smi_entries(port);
794 kobject_put(device->dev_ports_parent[slave]);
796 kobject_put(device->dev_ports_parent[slave]);
797 kobject_put(device->pkeys.device_parent[slave]);
798 kobject_put(device->pkeys.device_parent[slave]);
799 kobject_put(device->iov_parent);
803 int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
808 if (!mlx4_is_master(dev->dev))
811 dev->iov_parent = kobject_create_and_add("iov", &dev->ib_dev.dev.kobj);
812 if (!dev->iov_parent) {
817 kobject_create_and_add("ports",
818 kobject_get(dev->iov_parent));
819 if (!dev->ports_parent) {
824 for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
825 ret = add_port_entries(dev, i);
827 goto err_add_entries;
830 ret = register_pkey_tree(dev);
832 goto err_add_entries;
836 kobject_put(dev->ports_parent);
839 kobject_put(dev->iov_parent);
841 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
845 static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
847 struct mlx4_ib_iov_port *p;
850 if (!mlx4_is_master(device->dev))
853 for (i = 0; i < device->dev->caps.num_ports; i++) {
854 p = &device->iov_ports[i];
855 kobject_put(p->admin_alias_parent);
856 kobject_put(p->gids_parent);
857 kobject_put(p->pkeys_parent);
858 kobject_put(p->mcgs_parent);
859 kobject_put(p->cur_port);
860 kobject_put(p->cur_port);
861 kobject_put(p->cur_port);
862 kobject_put(p->cur_port);
863 kobject_put(p->cur_port);
864 kobject_put(p->dev->ports_parent);
869 void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
871 unregister_alias_guid_tree(device);
872 unregister_pkey_tree(device);
873 kobject_put(device->ports_parent);
874 kobject_put(device->iov_parent);
875 kobject_put(device->iov_parent);