Loading...
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 */
46static ssize_t show_admin_alias_guid(struct device *dev,
47 struct device_attribute *attr, char *buf)
48{
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;
54
55 sysadmin_ag_val = mlx4_get_admin_guid(mdev->dev,
56 mlx4_ib_iov_dentry->entry_num,
57 port->num);
58
59 return sysfs_emit(buf, "%llx\n", be64_to_cpu(sysadmin_ag_val));
60}
61
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.
67 */
68static ssize_t store_admin_alias_guid(struct device *dev,
69 struct device_attribute *attr,
70 const char *buf, size_t count)
71{
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;
78 u64 sysadmin_ag_val;
79 unsigned long flags;
80
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");
85 return count;
86 }
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);
93
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,
99 port->num);
100
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);
104
105 spin_unlock_irqrestore(&mdev->sriov.alias_guid.ag_work_lock, flags);
106 mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
107
108 return count;
109}
110
111static ssize_t show_port_gid(struct device *dev,
112 struct device_attribute *attr,
113 char *buf)
114{
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;
119 union ib_gid gid;
120 int ret;
121 __be16 *raw;
122
123 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
124 mlx4_ib_iov_dentry->entry_num, &gid, 1);
125 if (ret)
126 return ret;
127
128 raw = (__be16 *)gid.raw;
129 return sysfs_emit(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
130 be16_to_cpu(raw[0]),
131 be16_to_cpu(raw[1]),
132 be16_to_cpu(raw[2]),
133 be16_to_cpu(raw[3]),
134 be16_to_cpu(raw[4]),
135 be16_to_cpu(raw[5]),
136 be16_to_cpu(raw[6]),
137 be16_to_cpu(raw[7]));
138}
139
140static ssize_t show_phys_port_pkey(struct device *dev,
141 struct device_attribute *attr,
142 char *buf)
143{
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;
148 u16 pkey;
149 ssize_t ret;
150
151 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
152 mlx4_ib_iov_dentry->entry_num, &pkey, 1);
153 if (ret)
154 return ret;
155
156 return sysfs_emit(buf, "0x%04x\n", pkey);
157}
158
159#define DENTRY_REMOVE(_dentry) \
160do { \
161 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \
162} while (0);
163
164static 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,
168 char *buf),
169 ssize_t (*store)(struct device *dev,
170 struct device_attribute *attr,
171 const char *buf, size_t count)
172 )
173{
174 int ret = 0;
175 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
176
177 vdentry->ctx = _ctx;
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);
185
186 if (vdentry->dentry.store)
187 vdentry->dentry.attr.mode |= S_IWUSR;
188
189 if (vdentry->dentry.show)
190 vdentry->dentry.attr.mode |= S_IRUGO;
191
192 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
193 if (ret) {
194 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
195 vdentry->ctx = NULL;
196 return ret;
197 }
198
199 return ret;
200}
201
202int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
203 struct attribute *attr)
204{
205 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
206 int ret;
207
208 ret = sysfs_create_file(port->mcgs_parent, attr);
209 if (ret)
210 pr_err("failed to create %s\n", attr->name);
211
212 return ret;
213}
214
215void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
216 struct attribute *attr)
217{
218 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
219
220 sysfs_remove_file(port->mcgs_parent, attr);
221}
222
223static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
224{
225 int i;
226 char buff[12];
227 struct mlx4_ib_iov_port *port = NULL;
228 int ret = 0 ;
229 struct ib_port_attr attr;
230
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);
234 if (ret)
235 goto err;
236
237 port = &device->iov_ports[port_num - 1];
238 port->dev = device;
239 port->num = port_num;
240 /* Directory structure:
241 * iov -
242 * port num -
243 * admin_guids
244 * gids (operational)
245 * mcg_table
246 */
247 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
248 GFP_KERNEL);
249 if (!port->dentr_ar) {
250 ret = -ENOMEM;
251 goto err;
252 }
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) {
257 ret = -ENOMEM;
258 goto kobj_create_err;
259 }
260 /* admin GUIDs */
261 port->admin_alias_parent = kobject_create_and_add("admin_guids",
262 kobject_get(port->cur_port));
263 if (!port->admin_alias_parent) {
264 ret = -ENOMEM;
265 goto err_admin_guids;
266 }
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);
273 if (ret)
274 goto err_admin_alias_parent;
275 }
276
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) {
281 ret = -ENOMEM;
282 goto err_gids;
283 }
284
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],
290 buff,
291 port->gids_parent, show_port_gid, NULL);
292 if (ret)
293 goto err_gids_parent;
294 }
295
296 /* physical port pkey table */
297 port->pkeys_parent =
298 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
299 if (!port->pkeys_parent) {
300 ret = -ENOMEM;
301 goto err_pkeys;
302 }
303
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);
311 if (ret)
312 goto err_pkeys_parent;
313 }
314
315 /* MCGs table */
316 port->mcgs_parent =
317 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
318 if (!port->mcgs_parent) {
319 ret = -ENOMEM;
320 goto err_mcgs;
321 }
322 return 0;
323
324err_mcgs:
325 kobject_put(port->cur_port);
326
327err_pkeys_parent:
328 kobject_put(port->pkeys_parent);
329
330err_pkeys:
331 kobject_put(port->cur_port);
332
333err_gids_parent:
334 kobject_put(port->gids_parent);
335
336err_gids:
337 kobject_put(port->cur_port);
338
339err_admin_alias_parent:
340 kobject_put(port->admin_alias_parent);
341
342err_admin_guids:
343 kobject_put(port->cur_port);
344 kobject_put(port->cur_port); /* once more for create_and_add buff */
345
346kobj_create_err:
347 kobject_put(device->ports_parent);
348 kfree(port->dentr_ar);
349
350err:
351 pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
352 port_num, ret);
353 return ret;
354}
355
356static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
357{
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
361 * modulo 8 */
362 snprintf(name, max, "%.8s%.2d.%d", pci_name(dev->dev->persist->pdev),
363 i / 8, i % 8);
364}
365
366struct mlx4_port {
367 struct kobject kobj;
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;
373 int slave;
374 u8 port_num;
375};
376
377
378static void mlx4_port_release(struct kobject *kobj)
379{
380 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
381 struct attribute *a;
382 int i;
383
384 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
385 kfree(a);
386 kfree(p->pkey_group.attrs);
387 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
388 kfree(a);
389 kfree(p->gid_group.attrs);
390 kfree(p);
391}
392
393struct 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);
398};
399
400static ssize_t port_attr_show(struct kobject *kobj,
401 struct attribute *attr, char *buf)
402{
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);
406
407 if (!port_attr->show)
408 return -EIO;
409 return port_attr->show(p, port_attr, buf);
410}
411
412static ssize_t port_attr_store(struct kobject *kobj,
413 struct attribute *attr,
414 const char *buf, size_t size)
415{
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);
419
420 if (!port_attr->store)
421 return -EIO;
422 return port_attr->store(p, port_attr, buf, size);
423}
424
425static const struct sysfs_ops port_sysfs_ops = {
426 .show = port_attr_show,
427 .store = port_attr_store,
428};
429
430static struct kobj_type port_type = {
431 .release = mlx4_port_release,
432 .sysfs_ops = &port_sysfs_ops,
433};
434
435struct port_table_attribute {
436 struct port_attribute attr;
437 char name[8];
438 int index;
439};
440
441static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
442 char *buf)
443{
444 struct port_table_attribute *tab_attr =
445 container_of(attr, struct port_table_attribute, attr);
446 struct pkey_mgt *m = &p->dev->pkeys;
447 u8 key = m->virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index];
448
449 if (key >= p->dev->dev->caps.pkey_table_len[p->port_num])
450 return sysfs_emit(buf, "none\n");
451 return sysfs_emit(buf, "%d\n", key);
452}
453
454static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
455 const char *buf, size_t count)
456{
457 struct port_table_attribute *tab_attr =
458 container_of(attr, struct port_table_attribute, attr);
459 int idx;
460 int err;
461
462 /* do not allow remapping Dom0 virtual pkey table */
463 if (p->slave == mlx4_master_func_num(p->dev->dev))
464 return -EINVAL;
465
466 if (!strncasecmp(buf, "no", 2))
467 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
468 else if (sscanf(buf, "%i", &idx) != 1 ||
469 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
470 idx < 0)
471 return -EINVAL;
472
473 p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
474 [tab_attr->index] = idx;
475 mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
476 tab_attr->index, idx);
477 err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
478 if (err) {
479 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
480 " port %d, index %d\n", p->slave, p->port_num, idx);
481 return err;
482 }
483 return count;
484}
485
486static ssize_t show_port_gid_idx(struct mlx4_port *p,
487 struct port_attribute *attr, char *buf)
488{
489 return sysfs_emit(buf, "%d\n", p->slave);
490}
491
492static struct attribute **
493alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
494 struct port_attribute *, char *buf),
495 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
496 const char *buf, size_t count),
497 int len)
498{
499 struct attribute **tab_attr;
500 struct port_table_attribute *element;
501 int i;
502
503 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
504 if (!tab_attr)
505 return NULL;
506
507 for (i = 0; i < len; i++) {
508 element = kzalloc(sizeof (struct port_table_attribute),
509 GFP_KERNEL);
510 if (!element)
511 goto err;
512 if (snprintf(element->name, sizeof (element->name),
513 "%d", i) >= sizeof (element->name)) {
514 kfree(element);
515 goto err;
516 }
517 sysfs_attr_init(&element->attr.attr);
518 element->attr.attr.name = element->name;
519 if (store) {
520 element->attr.attr.mode = S_IWUSR | S_IRUGO;
521 element->attr.store = store;
522 } else
523 element->attr.attr.mode = S_IRUGO;
524
525 element->attr.show = show;
526 element->index = i;
527 tab_attr[i] = &element->attr.attr;
528 }
529 return tab_attr;
530
531err:
532 while (--i >= 0)
533 kfree(tab_attr[i]);
534 kfree(tab_attr);
535 return NULL;
536}
537
538static ssize_t sysfs_show_smi_enabled(struct device *dev,
539 struct device_attribute *attr, char *buf)
540{
541 struct mlx4_port *p =
542 container_of(attr, struct mlx4_port, smi_enabled);
543
544 return sysfs_emit(buf, "%d\n",
545 !!mlx4_vf_smi_enabled(p->dev->dev, p->slave,
546 p->port_num));
547}
548
549static ssize_t sysfs_show_enable_smi_admin(struct device *dev,
550 struct device_attribute *attr,
551 char *buf)
552{
553 struct mlx4_port *p =
554 container_of(attr, struct mlx4_port, enable_smi_admin);
555
556 return sysfs_emit(buf, "%d\n",
557 !!mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave,
558 p->port_num));
559}
560
561static ssize_t sysfs_store_enable_smi_admin(struct device *dev,
562 struct device_attribute *attr,
563 const char *buf, size_t count)
564{
565 struct mlx4_port *p =
566 container_of(attr, struct mlx4_port, enable_smi_admin);
567 int enable;
568
569 if (sscanf(buf, "%i", &enable) != 1 ||
570 enable < 0 || enable > 1)
571 return -EINVAL;
572
573 if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable))
574 return -EINVAL;
575 return count;
576}
577
578static int add_vf_smi_entries(struct mlx4_port *p)
579{
580 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
581 IB_LINK_LAYER_ETHERNET;
582 int ret;
583
584 /* do not display entries if eth transport, or if master */
585 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
586 return 0;
587
588 sysfs_attr_init(&p->smi_enabled.attr);
589 p->smi_enabled.show = sysfs_show_smi_enabled;
590 p->smi_enabled.store = NULL;
591 p->smi_enabled.attr.name = "smi_enabled";
592 p->smi_enabled.attr.mode = 0444;
593 ret = sysfs_create_file(&p->kobj, &p->smi_enabled.attr);
594 if (ret) {
595 pr_err("failed to create smi_enabled\n");
596 return ret;
597 }
598
599 sysfs_attr_init(&p->enable_smi_admin.attr);
600 p->enable_smi_admin.show = sysfs_show_enable_smi_admin;
601 p->enable_smi_admin.store = sysfs_store_enable_smi_admin;
602 p->enable_smi_admin.attr.name = "enable_smi_admin";
603 p->enable_smi_admin.attr.mode = 0644;
604 ret = sysfs_create_file(&p->kobj, &p->enable_smi_admin.attr);
605 if (ret) {
606 pr_err("failed to create enable_smi_admin\n");
607 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
608 return ret;
609 }
610 return 0;
611}
612
613static void remove_vf_smi_entries(struct mlx4_port *p)
614{
615 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
616 IB_LINK_LAYER_ETHERNET;
617
618 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
619 return;
620
621 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
622 sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr);
623}
624
625static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
626{
627 struct mlx4_port *p;
628 int i;
629 int ret;
630 int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) ==
631 IB_LINK_LAYER_ETHERNET;
632
633 p = kzalloc(sizeof *p, GFP_KERNEL);
634 if (!p)
635 return -ENOMEM;
636
637 p->dev = dev;
638 p->port_num = port_num;
639 p->slave = slave;
640
641 ret = kobject_init_and_add(&p->kobj, &port_type,
642 kobject_get(dev->dev_ports_parent[slave]),
643 "%d", port_num);
644 if (ret)
645 goto err_alloc;
646
647 p->pkey_group.name = "pkey_idx";
648 p->pkey_group.attrs =
649 alloc_group_attrs(show_port_pkey,
650 is_eth ? NULL : store_port_pkey,
651 dev->dev->caps.pkey_table_len[port_num]);
652 if (!p->pkey_group.attrs) {
653 ret = -ENOMEM;
654 goto err_alloc;
655 }
656
657 ret = sysfs_create_group(&p->kobj, &p->pkey_group);
658 if (ret)
659 goto err_free_pkey;
660
661 p->gid_group.name = "gid_idx";
662 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
663 if (!p->gid_group.attrs) {
664 ret = -ENOMEM;
665 goto err_free_pkey;
666 }
667
668 ret = sysfs_create_group(&p->kobj, &p->gid_group);
669 if (ret)
670 goto err_free_gid;
671
672 ret = add_vf_smi_entries(p);
673 if (ret)
674 goto err_free_gid;
675
676 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
677 return 0;
678
679err_free_gid:
680 kfree(p->gid_group.attrs[0]);
681 kfree(p->gid_group.attrs);
682
683err_free_pkey:
684 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
685 kfree(p->pkey_group.attrs[i]);
686 kfree(p->pkey_group.attrs);
687
688err_alloc:
689 kobject_put(dev->dev_ports_parent[slave]);
690 kfree(p);
691 return ret;
692}
693
694static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
695{
696 char name[32];
697 int err;
698 int port;
699 struct kobject *p, *t;
700 struct mlx4_port *mport;
701 struct mlx4_active_ports actv_ports;
702
703 get_name(dev, name, slave, sizeof name);
704
705 dev->pkeys.device_parent[slave] =
706 kobject_create_and_add(name, kobject_get(dev->iov_parent));
707
708 if (!dev->pkeys.device_parent[slave]) {
709 err = -ENOMEM;
710 goto fail_dev;
711 }
712
713 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
714
715 dev->dev_ports_parent[slave] =
716 kobject_create_and_add("ports",
717 kobject_get(dev->pkeys.device_parent[slave]));
718
719 if (!dev->dev_ports_parent[slave]) {
720 err = -ENOMEM;
721 goto err_ports;
722 }
723
724 actv_ports = mlx4_get_active_ports(dev->dev, slave);
725
726 for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
727 if (!test_bit(port - 1, actv_ports.ports))
728 continue;
729 err = add_port(dev, port, slave);
730 if (err)
731 goto err_add;
732 }
733 return 0;
734
735err_add:
736 list_for_each_entry_safe(p, t,
737 &dev->pkeys.pkey_port_list[slave],
738 entry) {
739 list_del(&p->entry);
740 mport = container_of(p, struct mlx4_port, kobj);
741 sysfs_remove_group(p, &mport->pkey_group);
742 sysfs_remove_group(p, &mport->gid_group);
743 remove_vf_smi_entries(mport);
744 kobject_put(p);
745 }
746 kobject_put(dev->dev_ports_parent[slave]);
747
748err_ports:
749 kobject_put(dev->pkeys.device_parent[slave]);
750 /* extra put for the device_parent create_and_add */
751 kobject_put(dev->pkeys.device_parent[slave]);
752
753fail_dev:
754 kobject_put(dev->iov_parent);
755 return err;
756}
757
758static int register_pkey_tree(struct mlx4_ib_dev *device)
759{
760 int i;
761
762 if (!mlx4_is_master(device->dev))
763 return 0;
764
765 for (i = 0; i <= device->dev->persist->num_vfs; ++i)
766 register_one_pkey_tree(device, i);
767
768 return 0;
769}
770
771static void unregister_pkey_tree(struct mlx4_ib_dev *device)
772{
773 int slave;
774 struct kobject *p, *t;
775 struct mlx4_port *port;
776
777 if (!mlx4_is_master(device->dev))
778 return;
779
780 for (slave = device->dev->persist->num_vfs; slave >= 0; --slave) {
781 list_for_each_entry_safe(p, t,
782 &device->pkeys.pkey_port_list[slave],
783 entry) {
784 list_del(&p->entry);
785 port = container_of(p, struct mlx4_port, kobj);
786 sysfs_remove_group(p, &port->pkey_group);
787 sysfs_remove_group(p, &port->gid_group);
788 remove_vf_smi_entries(port);
789 kobject_put(p);
790 kobject_put(device->dev_ports_parent[slave]);
791 }
792 kobject_put(device->dev_ports_parent[slave]);
793 kobject_put(device->pkeys.device_parent[slave]);
794 kobject_put(device->pkeys.device_parent[slave]);
795 kobject_put(device->iov_parent);
796 }
797}
798
799int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
800{
801 unsigned int i;
802 int ret = 0;
803
804 if (!mlx4_is_master(dev->dev))
805 return 0;
806
807 dev->iov_parent = kobject_create_and_add("iov", &dev->ib_dev.dev.kobj);
808 if (!dev->iov_parent) {
809 ret = -ENOMEM;
810 goto err;
811 }
812 dev->ports_parent =
813 kobject_create_and_add("ports",
814 kobject_get(dev->iov_parent));
815 if (!dev->ports_parent) {
816 ret = -ENOMEM;
817 goto err_ports;
818 }
819
820 rdma_for_each_port(&dev->ib_dev, i) {
821 ret = add_port_entries(dev, i);
822 if (ret)
823 goto err_add_entries;
824 }
825
826 ret = register_pkey_tree(dev);
827 if (ret)
828 goto err_add_entries;
829 return 0;
830
831err_add_entries:
832 kobject_put(dev->ports_parent);
833
834err_ports:
835 kobject_put(dev->iov_parent);
836err:
837 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
838 return ret;
839}
840
841static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
842{
843 struct mlx4_ib_iov_port *p;
844 int i;
845
846 if (!mlx4_is_master(device->dev))
847 return;
848
849 for (i = 0; i < device->dev->caps.num_ports; i++) {
850 p = &device->iov_ports[i];
851 kobject_put(p->admin_alias_parent);
852 kobject_put(p->gids_parent);
853 kobject_put(p->pkeys_parent);
854 kobject_put(p->mcgs_parent);
855 kobject_put(p->cur_port);
856 kobject_put(p->cur_port);
857 kobject_put(p->cur_port);
858 kobject_put(p->cur_port);
859 kobject_put(p->cur_port);
860 kobject_put(p->dev->ports_parent);
861 kfree(p->dentr_ar);
862 }
863}
864
865void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
866{
867 unregister_alias_guid_tree(device);
868 unregister_pkey_tree(device);
869 kobject_put(device->ports_parent);
870 kobject_put(device->iov_parent);
871 kobject_put(device->iov_parent);
872}
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 */
46static ssize_t show_admin_alias_guid(struct device *dev,
47 struct device_attribute *attr, char *buf)
48{
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;
54
55 sysadmin_ag_val = mlx4_get_admin_guid(mdev->dev,
56 mlx4_ib_iov_dentry->entry_num,
57 port->num);
58
59 return sprintf(buf, "%llx\n", be64_to_cpu(sysadmin_ag_val));
60}
61
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.
67 */
68static ssize_t store_admin_alias_guid(struct device *dev,
69 struct device_attribute *attr,
70 const char *buf, size_t count)
71{
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;
78 u64 sysadmin_ag_val;
79 unsigned long flags;
80
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");
85 return count;
86 }
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);
93
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,
99 port->num);
100
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);
104
105 spin_unlock_irqrestore(&mdev->sriov.alias_guid.ag_work_lock, flags);
106 mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
107
108 return count;
109}
110
111static ssize_t show_port_gid(struct device *dev,
112 struct device_attribute *attr,
113 char *buf)
114{
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;
119 union ib_gid gid;
120 ssize_t ret;
121
122 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
123 mlx4_ib_iov_dentry->entry_num, &gid, 1);
124 if (ret)
125 return ret;
126 ret = sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
127 be16_to_cpu(((__be16 *) gid.raw)[0]),
128 be16_to_cpu(((__be16 *) gid.raw)[1]),
129 be16_to_cpu(((__be16 *) gid.raw)[2]),
130 be16_to_cpu(((__be16 *) gid.raw)[3]),
131 be16_to_cpu(((__be16 *) gid.raw)[4]),
132 be16_to_cpu(((__be16 *) gid.raw)[5]),
133 be16_to_cpu(((__be16 *) gid.raw)[6]),
134 be16_to_cpu(((__be16 *) gid.raw)[7]));
135 return ret;
136}
137
138static ssize_t show_phys_port_pkey(struct device *dev,
139 struct device_attribute *attr,
140 char *buf)
141{
142 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
143 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
144 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
145 struct mlx4_ib_dev *mdev = port->dev;
146 u16 pkey;
147 ssize_t ret;
148
149 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
150 mlx4_ib_iov_dentry->entry_num, &pkey, 1);
151 if (ret)
152 return ret;
153
154 return sprintf(buf, "0x%04x\n", pkey);
155}
156
157#define DENTRY_REMOVE(_dentry) \
158do { \
159 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \
160} while (0);
161
162static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,
163 char *_name, struct kobject *_kobj,
164 ssize_t (*show)(struct device *dev,
165 struct device_attribute *attr,
166 char *buf),
167 ssize_t (*store)(struct device *dev,
168 struct device_attribute *attr,
169 const char *buf, size_t count)
170 )
171{
172 int ret = 0;
173 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
174
175 vdentry->ctx = _ctx;
176 vdentry->dentry.show = show;
177 vdentry->dentry.store = store;
178 sysfs_attr_init(&vdentry->dentry.attr);
179 vdentry->dentry.attr.name = vdentry->name;
180 vdentry->dentry.attr.mode = 0;
181 vdentry->kobj = _kobj;
182 snprintf(vdentry->name, 15, "%s", _name);
183
184 if (vdentry->dentry.store)
185 vdentry->dentry.attr.mode |= S_IWUSR;
186
187 if (vdentry->dentry.show)
188 vdentry->dentry.attr.mode |= S_IRUGO;
189
190 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
191 if (ret) {
192 pr_err("failed to create %s\n", vdentry->dentry.attr.name);
193 vdentry->ctx = NULL;
194 return ret;
195 }
196
197 return ret;
198}
199
200int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
201 struct attribute *attr)
202{
203 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
204 int ret;
205
206 ret = sysfs_create_file(port->mcgs_parent, attr);
207 if (ret)
208 pr_err("failed to create %s\n", attr->name);
209
210 return ret;
211}
212
213void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
214 struct attribute *attr)
215{
216 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
217
218 sysfs_remove_file(port->mcgs_parent, attr);
219}
220
221static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
222{
223 int i;
224 char buff[11];
225 struct mlx4_ib_iov_port *port = NULL;
226 int ret = 0 ;
227 struct ib_port_attr attr;
228
229 memset(&attr, 0, sizeof(attr));
230 /* get the physical gid and pkey table sizes.*/
231 ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
232 if (ret)
233 goto err;
234
235 port = &device->iov_ports[port_num - 1];
236 port->dev = device;
237 port->num = port_num;
238 /* Directory structure:
239 * iov -
240 * port num -
241 * admin_guids
242 * gids (operational)
243 * mcg_table
244 */
245 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
246 GFP_KERNEL);
247 if (!port->dentr_ar) {
248 ret = -ENOMEM;
249 goto err;
250 }
251 sprintf(buff, "%d", port_num);
252 port->cur_port = kobject_create_and_add(buff,
253 kobject_get(device->ports_parent));
254 if (!port->cur_port) {
255 ret = -ENOMEM;
256 goto kobj_create_err;
257 }
258 /* admin GUIDs */
259 port->admin_alias_parent = kobject_create_and_add("admin_guids",
260 kobject_get(port->cur_port));
261 if (!port->admin_alias_parent) {
262 ret = -ENOMEM;
263 goto err_admin_guids;
264 }
265 for (i = 0 ; i < attr.gid_tbl_len; i++) {
266 sprintf(buff, "%d", i);
267 port->dentr_ar->dentries[i].entry_num = i;
268 ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i],
269 buff, port->admin_alias_parent,
270 show_admin_alias_guid, store_admin_alias_guid);
271 if (ret)
272 goto err_admin_alias_parent;
273 }
274
275 /* gids subdirectory (operational gids) */
276 port->gids_parent = kobject_create_and_add("gids",
277 kobject_get(port->cur_port));
278 if (!port->gids_parent) {
279 ret = -ENOMEM;
280 goto err_gids;
281 }
282
283 for (i = 0 ; i < attr.gid_tbl_len; i++) {
284 sprintf(buff, "%d", i);
285 port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i;
286 ret = create_sysfs_entry(port,
287 &port->dentr_ar->dentries[attr.gid_tbl_len + i],
288 buff,
289 port->gids_parent, show_port_gid, NULL);
290 if (ret)
291 goto err_gids_parent;
292 }
293
294 /* physical port pkey table */
295 port->pkeys_parent =
296 kobject_create_and_add("pkeys", kobject_get(port->cur_port));
297 if (!port->pkeys_parent) {
298 ret = -ENOMEM;
299 goto err_pkeys;
300 }
301
302 for (i = 0 ; i < attr.pkey_tbl_len; i++) {
303 sprintf(buff, "%d", i);
304 port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i;
305 ret = create_sysfs_entry(port,
306 &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i],
307 buff, port->pkeys_parent,
308 show_phys_port_pkey, NULL);
309 if (ret)
310 goto err_pkeys_parent;
311 }
312
313 /* MCGs table */
314 port->mcgs_parent =
315 kobject_create_and_add("mcgs", kobject_get(port->cur_port));
316 if (!port->mcgs_parent) {
317 ret = -ENOMEM;
318 goto err_mcgs;
319 }
320 return 0;
321
322err_mcgs:
323 kobject_put(port->cur_port);
324
325err_pkeys_parent:
326 kobject_put(port->pkeys_parent);
327
328err_pkeys:
329 kobject_put(port->cur_port);
330
331err_gids_parent:
332 kobject_put(port->gids_parent);
333
334err_gids:
335 kobject_put(port->cur_port);
336
337err_admin_alias_parent:
338 kobject_put(port->admin_alias_parent);
339
340err_admin_guids:
341 kobject_put(port->cur_port);
342 kobject_put(port->cur_port); /* once more for create_and_add buff */
343
344kobj_create_err:
345 kobject_put(device->ports_parent);
346 kfree(port->dentr_ar);
347
348err:
349 pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
350 port_num, ret);
351 return ret;
352}
353
354static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
355{
356 char base_name[9];
357
358 /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n */
359 strlcpy(name, pci_name(dev->dev->persist->pdev), max);
360 strncpy(base_name, name, 8); /*till xxxx:yy:*/
361 base_name[8] = '\0';
362 /* with no ARI only 3 last bits are used so when the fn is higher than 8
363 * need to add it to the dev num, so count in the last number will be
364 * modulo 8 */
365 sprintf(name, "%s%.2d.%d", base_name, (i/8), (i%8));
366}
367
368struct mlx4_port {
369 struct kobject kobj;
370 struct mlx4_ib_dev *dev;
371 struct attribute_group pkey_group;
372 struct attribute_group gid_group;
373 struct device_attribute enable_smi_admin;
374 struct device_attribute smi_enabled;
375 int slave;
376 u8 port_num;
377};
378
379
380static void mlx4_port_release(struct kobject *kobj)
381{
382 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
383 struct attribute *a;
384 int i;
385
386 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
387 kfree(a);
388 kfree(p->pkey_group.attrs);
389 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
390 kfree(a);
391 kfree(p->gid_group.attrs);
392 kfree(p);
393}
394
395struct port_attribute {
396 struct attribute attr;
397 ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf);
398 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
399 const char *buf, size_t count);
400};
401
402static ssize_t port_attr_show(struct kobject *kobj,
403 struct attribute *attr, char *buf)
404{
405 struct port_attribute *port_attr =
406 container_of(attr, struct port_attribute, attr);
407 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
408
409 if (!port_attr->show)
410 return -EIO;
411 return port_attr->show(p, port_attr, buf);
412}
413
414static ssize_t port_attr_store(struct kobject *kobj,
415 struct attribute *attr,
416 const char *buf, size_t size)
417{
418 struct port_attribute *port_attr =
419 container_of(attr, struct port_attribute, attr);
420 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
421
422 if (!port_attr->store)
423 return -EIO;
424 return port_attr->store(p, port_attr, buf, size);
425}
426
427static const struct sysfs_ops port_sysfs_ops = {
428 .show = port_attr_show,
429 .store = port_attr_store,
430};
431
432static struct kobj_type port_type = {
433 .release = mlx4_port_release,
434 .sysfs_ops = &port_sysfs_ops,
435};
436
437struct port_table_attribute {
438 struct port_attribute attr;
439 char name[8];
440 int index;
441};
442
443static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
444 char *buf)
445{
446 struct port_table_attribute *tab_attr =
447 container_of(attr, struct port_table_attribute, attr);
448 ssize_t ret = -ENODEV;
449
450 if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >=
451 (p->dev->dev->caps.pkey_table_len[p->port_num]))
452 ret = sprintf(buf, "none\n");
453 else
454 ret = sprintf(buf, "%d\n",
455 p->dev->pkeys.virt2phys_pkey[p->slave]
456 [p->port_num - 1][tab_attr->index]);
457 return ret;
458}
459
460static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
461 const char *buf, size_t count)
462{
463 struct port_table_attribute *tab_attr =
464 container_of(attr, struct port_table_attribute, attr);
465 int idx;
466 int err;
467
468 /* do not allow remapping Dom0 virtual pkey table */
469 if (p->slave == mlx4_master_func_num(p->dev->dev))
470 return -EINVAL;
471
472 if (!strncasecmp(buf, "no", 2))
473 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
474 else if (sscanf(buf, "%i", &idx) != 1 ||
475 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
476 idx < 0)
477 return -EINVAL;
478
479 p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
480 [tab_attr->index] = idx;
481 mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
482 tab_attr->index, idx);
483 err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
484 if (err) {
485 pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
486 " port %d, index %d\n", p->slave, p->port_num, idx);
487 return err;
488 }
489 return count;
490}
491
492static ssize_t show_port_gid_idx(struct mlx4_port *p,
493 struct port_attribute *attr, char *buf)
494{
495 return sprintf(buf, "%d\n", p->slave);
496}
497
498static struct attribute **
499alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
500 struct port_attribute *, char *buf),
501 ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
502 const char *buf, size_t count),
503 int len)
504{
505 struct attribute **tab_attr;
506 struct port_table_attribute *element;
507 int i;
508
509 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
510 if (!tab_attr)
511 return NULL;
512
513 for (i = 0; i < len; i++) {
514 element = kzalloc(sizeof (struct port_table_attribute),
515 GFP_KERNEL);
516 if (!element)
517 goto err;
518 if (snprintf(element->name, sizeof (element->name),
519 "%d", i) >= sizeof (element->name)) {
520 kfree(element);
521 goto err;
522 }
523 sysfs_attr_init(&element->attr.attr);
524 element->attr.attr.name = element->name;
525 if (store) {
526 element->attr.attr.mode = S_IWUSR | S_IRUGO;
527 element->attr.store = store;
528 } else
529 element->attr.attr.mode = S_IRUGO;
530
531 element->attr.show = show;
532 element->index = i;
533 tab_attr[i] = &element->attr.attr;
534 }
535 return tab_attr;
536
537err:
538 while (--i >= 0)
539 kfree(tab_attr[i]);
540 kfree(tab_attr);
541 return NULL;
542}
543
544static ssize_t sysfs_show_smi_enabled(struct device *dev,
545 struct device_attribute *attr, char *buf)
546{
547 struct mlx4_port *p =
548 container_of(attr, struct mlx4_port, smi_enabled);
549 ssize_t len = 0;
550
551 if (mlx4_vf_smi_enabled(p->dev->dev, p->slave, p->port_num))
552 len = sprintf(buf, "%d\n", 1);
553 else
554 len = sprintf(buf, "%d\n", 0);
555
556 return len;
557}
558
559static ssize_t sysfs_show_enable_smi_admin(struct device *dev,
560 struct device_attribute *attr,
561 char *buf)
562{
563 struct mlx4_port *p =
564 container_of(attr, struct mlx4_port, enable_smi_admin);
565 ssize_t len = 0;
566
567 if (mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave, p->port_num))
568 len = sprintf(buf, "%d\n", 1);
569 else
570 len = sprintf(buf, "%d\n", 0);
571
572 return len;
573}
574
575static ssize_t sysfs_store_enable_smi_admin(struct device *dev,
576 struct device_attribute *attr,
577 const char *buf, size_t count)
578{
579 struct mlx4_port *p =
580 container_of(attr, struct mlx4_port, enable_smi_admin);
581 int enable;
582
583 if (sscanf(buf, "%i", &enable) != 1 ||
584 enable < 0 || enable > 1)
585 return -EINVAL;
586
587 if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable))
588 return -EINVAL;
589 return count;
590}
591
592static int add_vf_smi_entries(struct mlx4_port *p)
593{
594 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
595 IB_LINK_LAYER_ETHERNET;
596 int ret;
597
598 /* do not display entries if eth transport, or if master */
599 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
600 return 0;
601
602 sysfs_attr_init(&p->smi_enabled.attr);
603 p->smi_enabled.show = sysfs_show_smi_enabled;
604 p->smi_enabled.store = NULL;
605 p->smi_enabled.attr.name = "smi_enabled";
606 p->smi_enabled.attr.mode = 0444;
607 ret = sysfs_create_file(&p->kobj, &p->smi_enabled.attr);
608 if (ret) {
609 pr_err("failed to create smi_enabled\n");
610 return ret;
611 }
612
613 sysfs_attr_init(&p->enable_smi_admin.attr);
614 p->enable_smi_admin.show = sysfs_show_enable_smi_admin;
615 p->enable_smi_admin.store = sysfs_store_enable_smi_admin;
616 p->enable_smi_admin.attr.name = "enable_smi_admin";
617 p->enable_smi_admin.attr.mode = 0644;
618 ret = sysfs_create_file(&p->kobj, &p->enable_smi_admin.attr);
619 if (ret) {
620 pr_err("failed to create enable_smi_admin\n");
621 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
622 return ret;
623 }
624 return 0;
625}
626
627static void remove_vf_smi_entries(struct mlx4_port *p)
628{
629 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) ==
630 IB_LINK_LAYER_ETHERNET;
631
632 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev))
633 return;
634
635 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr);
636 sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr);
637}
638
639static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
640{
641 struct mlx4_port *p;
642 int i;
643 int ret;
644 int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) ==
645 IB_LINK_LAYER_ETHERNET;
646
647 p = kzalloc(sizeof *p, GFP_KERNEL);
648 if (!p)
649 return -ENOMEM;
650
651 p->dev = dev;
652 p->port_num = port_num;
653 p->slave = slave;
654
655 ret = kobject_init_and_add(&p->kobj, &port_type,
656 kobject_get(dev->dev_ports_parent[slave]),
657 "%d", port_num);
658 if (ret)
659 goto err_alloc;
660
661 p->pkey_group.name = "pkey_idx";
662 p->pkey_group.attrs =
663 alloc_group_attrs(show_port_pkey,
664 is_eth ? NULL : store_port_pkey,
665 dev->dev->caps.pkey_table_len[port_num]);
666 if (!p->pkey_group.attrs) {
667 ret = -ENOMEM;
668 goto err_alloc;
669 }
670
671 ret = sysfs_create_group(&p->kobj, &p->pkey_group);
672 if (ret)
673 goto err_free_pkey;
674
675 p->gid_group.name = "gid_idx";
676 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
677 if (!p->gid_group.attrs) {
678 ret = -ENOMEM;
679 goto err_free_pkey;
680 }
681
682 ret = sysfs_create_group(&p->kobj, &p->gid_group);
683 if (ret)
684 goto err_free_gid;
685
686 ret = add_vf_smi_entries(p);
687 if (ret)
688 goto err_free_gid;
689
690 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
691 return 0;
692
693err_free_gid:
694 kfree(p->gid_group.attrs[0]);
695 kfree(p->gid_group.attrs);
696
697err_free_pkey:
698 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
699 kfree(p->pkey_group.attrs[i]);
700 kfree(p->pkey_group.attrs);
701
702err_alloc:
703 kobject_put(dev->dev_ports_parent[slave]);
704 kfree(p);
705 return ret;
706}
707
708static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
709{
710 char name[32];
711 int err;
712 int port;
713 struct kobject *p, *t;
714 struct mlx4_port *mport;
715 struct mlx4_active_ports actv_ports;
716
717 get_name(dev, name, slave, sizeof name);
718
719 dev->pkeys.device_parent[slave] =
720 kobject_create_and_add(name, kobject_get(dev->iov_parent));
721
722 if (!dev->pkeys.device_parent[slave]) {
723 err = -ENOMEM;
724 goto fail_dev;
725 }
726
727 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
728
729 dev->dev_ports_parent[slave] =
730 kobject_create_and_add("ports",
731 kobject_get(dev->pkeys.device_parent[slave]));
732
733 if (!dev->dev_ports_parent[slave]) {
734 err = -ENOMEM;
735 goto err_ports;
736 }
737
738 actv_ports = mlx4_get_active_ports(dev->dev, slave);
739
740 for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
741 if (!test_bit(port - 1, actv_ports.ports))
742 continue;
743 err = add_port(dev, port, slave);
744 if (err)
745 goto err_add;
746 }
747 return 0;
748
749err_add:
750 list_for_each_entry_safe(p, t,
751 &dev->pkeys.pkey_port_list[slave],
752 entry) {
753 list_del(&p->entry);
754 mport = container_of(p, struct mlx4_port, kobj);
755 sysfs_remove_group(p, &mport->pkey_group);
756 sysfs_remove_group(p, &mport->gid_group);
757 remove_vf_smi_entries(mport);
758 kobject_put(p);
759 }
760 kobject_put(dev->dev_ports_parent[slave]);
761
762err_ports:
763 kobject_put(dev->pkeys.device_parent[slave]);
764 /* extra put for the device_parent create_and_add */
765 kobject_put(dev->pkeys.device_parent[slave]);
766
767fail_dev:
768 kobject_put(dev->iov_parent);
769 return err;
770}
771
772static int register_pkey_tree(struct mlx4_ib_dev *device)
773{
774 int i;
775
776 if (!mlx4_is_master(device->dev))
777 return 0;
778
779 for (i = 0; i <= device->dev->persist->num_vfs; ++i)
780 register_one_pkey_tree(device, i);
781
782 return 0;
783}
784
785static void unregister_pkey_tree(struct mlx4_ib_dev *device)
786{
787 int slave;
788 struct kobject *p, *t;
789 struct mlx4_port *port;
790
791 if (!mlx4_is_master(device->dev))
792 return;
793
794 for (slave = device->dev->persist->num_vfs; slave >= 0; --slave) {
795 list_for_each_entry_safe(p, t,
796 &device->pkeys.pkey_port_list[slave],
797 entry) {
798 list_del(&p->entry);
799 port = container_of(p, struct mlx4_port, kobj);
800 sysfs_remove_group(p, &port->pkey_group);
801 sysfs_remove_group(p, &port->gid_group);
802 remove_vf_smi_entries(port);
803 kobject_put(p);
804 kobject_put(device->dev_ports_parent[slave]);
805 }
806 kobject_put(device->dev_ports_parent[slave]);
807 kobject_put(device->pkeys.device_parent[slave]);
808 kobject_put(device->pkeys.device_parent[slave]);
809 kobject_put(device->iov_parent);
810 }
811}
812
813int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
814{
815 int i;
816 int ret = 0;
817
818 if (!mlx4_is_master(dev->dev))
819 return 0;
820
821 dev->iov_parent =
822 kobject_create_and_add("iov",
823 kobject_get(dev->ib_dev.ports_parent->parent));
824 if (!dev->iov_parent) {
825 ret = -ENOMEM;
826 goto err;
827 }
828 dev->ports_parent =
829 kobject_create_and_add("ports",
830 kobject_get(dev->iov_parent));
831 if (!dev->ports_parent) {
832 ret = -ENOMEM;
833 goto err_ports;
834 }
835
836 for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
837 ret = add_port_entries(dev, i);
838 if (ret)
839 goto err_add_entries;
840 }
841
842 ret = register_pkey_tree(dev);
843 if (ret)
844 goto err_add_entries;
845 return 0;
846
847err_add_entries:
848 kobject_put(dev->ports_parent);
849
850err_ports:
851 kobject_put(dev->iov_parent);
852err:
853 kobject_put(dev->ib_dev.ports_parent->parent);
854 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
855 return ret;
856}
857
858static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
859{
860 struct mlx4_ib_iov_port *p;
861 int i;
862
863 if (!mlx4_is_master(device->dev))
864 return;
865
866 for (i = 0; i < device->dev->caps.num_ports; i++) {
867 p = &device->iov_ports[i];
868 kobject_put(p->admin_alias_parent);
869 kobject_put(p->gids_parent);
870 kobject_put(p->pkeys_parent);
871 kobject_put(p->mcgs_parent);
872 kobject_put(p->cur_port);
873 kobject_put(p->cur_port);
874 kobject_put(p->cur_port);
875 kobject_put(p->cur_port);
876 kobject_put(p->cur_port);
877 kobject_put(p->dev->ports_parent);
878 kfree(p->dentr_ar);
879 }
880}
881
882void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
883{
884 unregister_alias_guid_tree(device);
885 unregister_pkey_tree(device);
886 kobject_put(device->ports_parent);
887 kobject_put(device->iov_parent);
888 kobject_put(device->iov_parent);
889 kobject_put(device->ib_dev.ports_parent->parent);
890}