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