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
->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
->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
->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
);