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>
38 #include <rdma/ib_mad.h>
39 /*show_admin_alias_guid returns the administratively assigned value of that GUID.
40 * Values returned in buf parameter string:
41 * 0 - requests opensm to assign a value.
42 * ffffffffffffffff - delete this entry.
43 * other - value assigned by administrator.
45 static ssize_t show_admin_alias_guid(struct device *dev,
46 struct device_attribute *attr, char *buf)
48 int record_num;/*0-15*/
49 int guid_index_in_rec; /*0 - 7*/
50 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
51 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
52 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
53 struct mlx4_ib_dev *mdev = port->dev;
55 record_num = mlx4_ib_iov_dentry->entry_num / 8 ;
56 guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8 ;
58 return sprintf(buf, "%llx\n", (long long)
59 be64_to_cpu(*(__be64 *)&mdev->sriov.alias_guid.
60 ports_guid[port->num - 1].
61 all_rec_per_port[record_num].
62 all_recs[8 * guid_index_in_rec]));
65 /* store_admin_alias_guid stores the (new) administratively assigned value of that GUID.
66 * Values in buf parameter string:
67 * 0 - requests opensm to assign a value.
68 * 0xffffffffffffffff - delete this entry.
69 * other - guid value assigned by the administrator.
71 static ssize_t store_admin_alias_guid(struct device *dev,
72 struct device_attribute *attr,
73 const char *buf, size_t count)
75 int record_num;/*0-15*/
76 int guid_index_in_rec; /*0 - 7*/
77 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
78 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
79 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
80 struct mlx4_ib_dev *mdev = port->dev;
83 record_num = mlx4_ib_iov_dentry->entry_num / 8;
84 guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8;
85 if (0 == record_num && 0 == guid_index_in_rec) {
86 pr_err("GUID 0 block 0 is RO\n");
89 sscanf(buf, "%llx", &sysadmin_ag_val);
90 *(__be64 *)&mdev->sriov.alias_guid.ports_guid[port->num - 1].
91 all_rec_per_port[record_num].
92 all_recs[GUID_REC_SIZE * guid_index_in_rec] =
93 cpu_to_be64(sysadmin_ag_val);
95 /* Change the state to be pending for update */
96 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].status
97 = MLX4_GUID_INFO_STATUS_IDLE ;
99 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
100 = MLX4_GUID_INFO_RECORD_SET;
102 switch (sysadmin_ag_val) {
103 case MLX4_GUID_FOR_DELETE_VAL:
104 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
105 = MLX4_GUID_INFO_RECORD_DELETE;
106 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
107 = MLX4_GUID_SYSADMIN_ASSIGN;
109 /* The sysadmin requests the SM to re-assign */
110 case MLX4_NOT_SET_GUID:
111 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
112 = MLX4_GUID_DRIVER_ASSIGN;
114 /* The sysadmin requests a specific value.*/
116 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
117 = MLX4_GUID_SYSADMIN_ASSIGN;
121 /* set the record index */
122 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].guid_indexes
123 = mlx4_ib_get_aguid_comp_mask_from_ix(guid_index_in_rec);
125 mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
130 static ssize_t show_port_gid(struct device *dev,
131 struct device_attribute *attr,
134 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
135 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
136 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
137 struct mlx4_ib_dev *mdev = port->dev;
141 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
142 mlx4_ib_iov_dentry->entry_num, &gid, 1);
145 ret = sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
146 be16_to_cpu(((__be16 *) gid.raw)[0]),
147 be16_to_cpu(((__be16 *) gid.raw)[1]),
148 be16_to_cpu(((__be16 *) gid.raw)[2]),
149 be16_to_cpu(((__be16 *) gid.raw)[3]),
150 be16_to_cpu(((__be16 *) gid.raw)[4]),
151 be16_to_cpu(((__be16 *) gid.raw)[5]),
152 be16_to_cpu(((__be16 *) gid.raw)[6]),
153 be16_to_cpu(((__be16 *) gid.raw)[7]));
157 static ssize_t show_phys_port_pkey(struct device *dev,
158 struct device_attribute *attr,
161 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
162 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
163 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
164 struct mlx4_ib_dev *mdev = port->dev;
168 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
169 mlx4_ib_iov_dentry->entry_num, &pkey, 1);
173 return sprintf(buf, "0x%04x\n", pkey);
176 #define DENTRY_REMOVE(_dentry) \
178 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \
181 static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,
182 char *_name, struct kobject *_kobj,
183 ssize_t (*show)(struct device *dev,
184 struct device_attribute *attr,
186 ssize_t (*store)(struct device *dev,
187 struct device_attribute *attr,
188 const char *buf, size_t count)
192 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
195 vdentry->dentry.show = show;
196 vdentry->dentry.store = store;
197 sysfs_attr_init(&vdentry->dentry.attr);
198 vdentry->dentry.attr.name = vdentry->name;
199 vdentry->dentry.attr.mode = 0;
200 vdentry->kobj = _kobj;
201 snprintf(vdentry->name, 15, "%s", _name);
203 if (vdentry->dentry.store)
204 vdentry->dentry.attr.mode |= S_IWUSR;
206 if (vdentry->dentry.show)
207 vdentry->dentry.attr.mode |= S_IRUGO;
209 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
211 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
219 int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
220 struct attribute *attr)
222 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
225 ret = sysfs_create_file(port->mcgs_parent, attr);
227 pr_err("failed to create %s\n", attr->name);
232 void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
233 struct attribute *attr)
235 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
237 sysfs_remove_file(port->mcgs_parent, attr);
240 static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
244 struct mlx4_ib_iov_port *port = NULL;
246 struct ib_port_attr attr;
248 /* get the physical gid and pkey table sizes.*/
249 ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
253 port = &device->iov_ports[port_num - 1];
255 port->num = port_num;
256 /* Directory structure:
263 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
265 if (!port->dentr_ar) {
269 sprintf(buff, "%d", port_num);
270 port->cur_port = kobject_create_and_add(buff,
271 kobject_get(device->ports_parent));
272 if (!port->cur_port) {
274 goto kobj_create_err;
277 port->admin_alias_parent = kobject_create_and_add("admin_guids",
278 kobject_get(port->cur_port));
279 if (!port->admin_alias_parent) {
281 goto err_admin_guids;
283 for (i = 0 ; i < attr.gid_tbl_len; i++) {
284 sprintf(buff, "%d", i);
285 port->dentr_ar->dentries[i].entry_num = i;
286 ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i],
287 buff, port->admin_alias_parent,
288 show_admin_alias_guid, store_admin_alias_guid);
290 goto err_admin_alias_parent;
293 /* gids subdirectory (operational gids) */
294 port->gids_parent = kobject_create_and_add("gids",
295 kobject_get(port->cur_port));
296 if (!port->gids_parent) {
301 for (i = 0 ; i < attr.gid_tbl_len; i++) {
302 sprintf(buff, "%d", i);
303 port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i;
304 ret = create_sysfs_entry(port,
305 &port->dentr_ar->dentries[attr.gid_tbl_len + i],
307 port->gids_parent, show_port_gid, NULL);
309 goto err_gids_parent;
312 /* physical port pkey table */
314 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
315 if (!port->pkeys_parent) {
320 for (i = 0 ; i < attr.pkey_tbl_len; i++) {
321 sprintf(buff, "%d", i);
322 port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i;
323 ret = create_sysfs_entry(port,
324 &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i],
325 buff, port->pkeys_parent,
326 show_phys_port_pkey, NULL);
328 goto err_pkeys_parent;
333 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
334 if (!port->mcgs_parent) {
341 kobject_put(port->cur_port);
344 kobject_put(port->pkeys_parent);
347 kobject_put(port->cur_port);
350 kobject_put(port->gids_parent);
353 kobject_put(port->cur_port);
355 err_admin_alias_parent:
356 kobject_put(port->admin_alias_parent);
359 kobject_put(port->cur_port);
360 kobject_put(port->cur_port); /* once more for create_and_add buff */
363 kobject_put(device->ports_parent);
364 kfree(port->dentr_ar);
367 pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
372 static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
376 /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n */
377 strlcpy(name, pci_name(dev->dev->pdev), max);
378 strncpy(base_name, name, 8); /*till xxxx:yy:*/
380 /* with no ARI only 3 last bits are used so when the fn is higher than 8
381 * need to add it to the dev num, so count in the last number will be
383 sprintf(name, "%s%.2d.%d", base_name, (i/8), (i%8));
388 struct mlx4_ib_dev *dev;
389 struct attribute_group pkey_group;
390 struct attribute_group gid_group;
396 static void mlx4_port_release(struct kobject *kobj)
398 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
402 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
404 kfree(p->pkey_group.attrs);
405 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
407 kfree(p->gid_group.attrs);
411 struct port_attribute {
412 struct attribute attr;
413 ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf);
414 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
415 const char *buf, size_t count);
418 static ssize_t port_attr_show(struct kobject *kobj,
419 struct attribute *attr, char *buf)
421 struct port_attribute *port_attr =
422 container_of(attr, struct port_attribute, attr);
423 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
425 if (!port_attr->show)
427 return port_attr->show(p, port_attr, buf);
430 static ssize_t port_attr_store(struct kobject *kobj,
431 struct attribute *attr,
432 const char *buf, size_t size)
434 struct port_attribute *port_attr =
435 container_of(attr, struct port_attribute, attr);
436 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
438 if (!port_attr->store)
440 return port_attr->store(p, port_attr, buf, size);
443 static const struct sysfs_ops port_sysfs_ops = {
444 .show = port_attr_show,
445 .store = port_attr_store,
448 static struct kobj_type port_type = {
449 .release = mlx4_port_release,
450 .sysfs_ops = &port_sysfs_ops,
453 struct port_table_attribute {
454 struct port_attribute attr;
459 static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
462 struct port_table_attribute *tab_attr =
463 container_of(attr, struct port_table_attribute, attr);
464 ssize_t ret = -ENODEV;
466 if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >=
467 (p->dev->dev->caps.pkey_table_len[p->port_num]))
468 ret = sprintf(buf, "none\n");
470 ret = sprintf(buf, "%d\n",
471 p->dev->pkeys.virt2phys_pkey[p->slave]
472 [p->port_num - 1][tab_attr->index]);
476 static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
477 const char *buf, size_t count)
479 struct port_table_attribute *tab_attr =
480 container_of(attr, struct port_table_attribute, attr);
484 /* do not allow remapping Dom0 virtual pkey table */
485 if (p->slave == mlx4_master_func_num(p->dev->dev))
488 if (!strncasecmp(buf, "no", 2))
489 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
490 else if (sscanf(buf, "%i", &idx) != 1 ||
491 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
495 p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
496 [tab_attr->index] = idx;
497 mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
498 tab_attr->index, idx);
499 err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
501 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
502 " port %d, index %d\n", p->slave, p->port_num, idx);
508 static ssize_t show_port_gid_idx(struct mlx4_port *p,
509 struct port_attribute *attr, char *buf)
511 return sprintf(buf, "%d\n", p->slave);
514 static struct attribute **
515 alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
516 struct port_attribute *, char *buf),
517 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
518 const char *buf, size_t count),
521 struct attribute **tab_attr;
522 struct port_table_attribute *element;
525 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
529 for (i = 0; i < len; i++) {
530 element = kzalloc(sizeof (struct port_table_attribute),
534 if (snprintf(element->name, sizeof (element->name),
535 "%d", i) >= sizeof (element->name)) {
539 sysfs_attr_init(&element->attr.attr);
540 element->attr.attr.name = element->name;
542 element->attr.attr.mode = S_IWUSR | S_IRUGO;
543 element->attr.store = store;
545 element->attr.attr.mode = S_IRUGO;
547 element->attr.show = show;
549 tab_attr[i] = &element->attr.attr;
560 static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
565 int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) ==
566 IB_LINK_LAYER_ETHERNET;
568 p = kzalloc(sizeof *p, GFP_KERNEL);
573 p->port_num = port_num;
576 ret = kobject_init_and_add(&p->kobj, &port_type,
577 kobject_get(dev->dev_ports_parent[slave]),
582 p->pkey_group.name = "pkey_idx";
584 p->pkey_group.attrs =
585 alloc_group_attrs(show_port_pkey, NULL,
586 dev->dev->caps.pkey_table_len[port_num]);
588 p->pkey_group.attrs =
589 alloc_group_attrs(show_port_pkey, store_port_pkey,
590 dev->dev->caps.pkey_table_len[port_num]);
591 if (!p->pkey_group.attrs)
594 ret = sysfs_create_group(&p->kobj, &p->pkey_group);
598 p->gid_group.name = "gid_idx";
599 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
600 if (!p->gid_group.attrs)
603 ret = sysfs_create_group(&p->kobj, &p->gid_group);
607 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
611 kfree(p->gid_group.attrs[0]);
612 kfree(p->gid_group.attrs);
615 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
616 kfree(p->pkey_group.attrs[i]);
617 kfree(p->pkey_group.attrs);
620 kobject_put(dev->dev_ports_parent[slave]);
625 static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
630 struct kobject *p, *t;
631 struct mlx4_port *mport;
633 get_name(dev, name, slave, sizeof name);
635 dev->pkeys.device_parent[slave] =
636 kobject_create_and_add(name, kobject_get(dev->iov_parent));
638 if (!dev->pkeys.device_parent[slave]) {
643 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
645 dev->dev_ports_parent[slave] =
646 kobject_create_and_add("ports",
647 kobject_get(dev->pkeys.device_parent[slave]));
649 if (!dev->dev_ports_parent[slave]) {
654 for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
655 err = add_port(dev, port, slave);
662 list_for_each_entry_safe(p, t,
663 &dev->pkeys.pkey_port_list[slave],
666 mport = container_of(p, struct mlx4_port, kobj);
667 sysfs_remove_group(p, &mport->pkey_group);
668 sysfs_remove_group(p, &mport->gid_group);
671 kobject_put(dev->dev_ports_parent[slave]);
674 kobject_put(dev->pkeys.device_parent[slave]);
675 /* extra put for the device_parent create_and_add */
676 kobject_put(dev->pkeys.device_parent[slave]);
679 kobject_put(dev->iov_parent);
683 static int register_pkey_tree(struct mlx4_ib_dev *device)
687 if (!mlx4_is_master(device->dev))
690 for (i = 0; i <= device->dev->num_vfs; ++i)
691 register_one_pkey_tree(device, i);
696 static void unregister_pkey_tree(struct mlx4_ib_dev *device)
699 struct kobject *p, *t;
700 struct mlx4_port *port;
702 if (!mlx4_is_master(device->dev))
705 for (slave = device->dev->num_vfs; slave >= 0; --slave) {
706 list_for_each_entry_safe(p, t,
707 &device->pkeys.pkey_port_list[slave],
710 port = container_of(p, struct mlx4_port, kobj);
711 sysfs_remove_group(p, &port->pkey_group);
712 sysfs_remove_group(p, &port->gid_group);
714 kobject_put(device->dev_ports_parent[slave]);
716 kobject_put(device->dev_ports_parent[slave]);
717 kobject_put(device->pkeys.device_parent[slave]);
718 kobject_put(device->pkeys.device_parent[slave]);
719 kobject_put(device->iov_parent);
723 int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
728 if (!mlx4_is_master(dev->dev))
732 kobject_create_and_add("iov",
733 kobject_get(dev->ib_dev.ports_parent->parent));
734 if (!dev->iov_parent) {
739 kobject_create_and_add("ports",
740 kobject_get(dev->iov_parent));
741 if (!dev->iov_parent) {
746 for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
747 ret = add_port_entries(dev, i);
749 goto err_add_entries;
752 ret = register_pkey_tree(dev);
754 goto err_add_entries;
758 kobject_put(dev->ports_parent);
761 kobject_put(dev->iov_parent);
763 kobject_put(dev->ib_dev.ports_parent->parent);
764 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
768 static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
770 struct mlx4_ib_iov_port *p;
773 if (!mlx4_is_master(device->dev))
776 for (i = 0; i < device->dev->caps.num_ports; i++) {
777 p = &device->iov_ports[i];
778 kobject_put(p->admin_alias_parent);
779 kobject_put(p->gids_parent);
780 kobject_put(p->pkeys_parent);
781 kobject_put(p->mcgs_parent);
782 kobject_put(p->cur_port);
783 kobject_put(p->cur_port);
784 kobject_put(p->cur_port);
785 kobject_put(p->cur_port);
786 kobject_put(p->cur_port);
787 kobject_put(p->dev->ports_parent);
792 void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
794 unregister_alias_guid_tree(device);
795 unregister_pkey_tree(device);
796 kobject_put(device->ports_parent);
797 kobject_put(device->iov_parent);
798 kobject_put(device->iov_parent);
799 kobject_put(device->ib_dev.ports_parent->parent);