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