1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * This file supports the /sys/firmware/sgi_uv topology tree on HPE UV. 4 * 5 * Copyright (c) 2020 Hewlett Packard Enterprise. All Rights Reserved. 6 * Copyright (c) Justin Ernst 7 */ 8 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/device.h> 12 #include <linux/slab.h> 13 #include <linux/kobject.h> 14 #include <linux/vmalloc.h> 15 #include <asm/uv/bios.h> 16 #include <asm/uv/uv.h> 17 #include <asm/uv/uv_hub.h> 18 #include <asm/uv/uv_geo.h> 19 20 #define INVALID_CNODE -1 21 22 struct kobject *sgi_uv_kobj; 23 static struct kset *uv_pcibus_kset; 24 static struct kset *uv_hubs_kset; 25 static struct uv_bios_hub_info *hub_buf; 26 static struct uv_bios_port_info **port_buf; 27 static struct uv_hub **uv_hubs; 28 static struct uv_pci_top_obj **uv_pci_objs; 29 static int num_pci_lines; 30 static int num_cnodes; 31 static int *prev_obj_to_cnode; 32 static int uv_bios_obj_cnt; 33 static signed short uv_master_nasid = -1; 34 static void *uv_biosheap; 35 36 static const char *uv_type_string(void) 37 { 38 if (is_uv5_hub()) 39 return "9.0"; 40 else if (is_uv4a_hub()) 41 return "7.1"; 42 else if (is_uv4_hub()) 43 return "7.0"; 44 else if (is_uv3_hub()) 45 return "5.0"; 46 else if (is_uv2_hub()) 47 return "3.0"; 48 else if (uv_get_hubless_system()) 49 return "0.1"; 50 else 51 return "unknown"; 52 } 53 54 static int ordinal_to_nasid(int ordinal) 55 { 56 if (ordinal < num_cnodes && ordinal >= 0) 57 return UV_PNODE_TO_NASID(uv_blade_to_pnode(ordinal)); 58 else 59 return -1; 60 } 61 62 static union geoid_u cnode_to_geoid(int cnode) 63 { 64 union geoid_u geoid; 65 66 uv_bios_get_geoinfo(ordinal_to_nasid(cnode), (u64)sizeof(union geoid_u), (u64 *)&geoid); 67 return geoid; 68 } 69 70 static int location_to_bpos(char *location, int *rack, int *slot, int *blade) 71 { 72 char type, r, b, h; 73 int idb, idh; 74 75 if (sscanf(location, "%c%03d%c%02d%c%2d%c%d", 76 &r, rack, &type, slot, &b, &idb, &h, &idh) != 8) 77 return -1; 78 *blade = idb * 2 + idh; 79 80 return 0; 81 } 82 83 static int cache_obj_to_cnode(struct uv_bios_hub_info *obj) 84 { 85 int cnode; 86 union geoid_u geoid; 87 int obj_rack, obj_slot, obj_blade; 88 int rack, slot, blade; 89 90 if (!obj->f.fields.this_part && !obj->f.fields.is_shared) 91 return 0; 92 93 if (location_to_bpos(obj->location, &obj_rack, &obj_slot, &obj_blade)) 94 return -1; 95 96 for (cnode = 0; cnode < num_cnodes; cnode++) { 97 geoid = cnode_to_geoid(cnode); 98 rack = geo_rack(geoid); 99 slot = geo_slot(geoid); 100 blade = geo_blade(geoid); 101 if (obj_rack == rack && obj_slot == slot && obj_blade == blade) 102 prev_obj_to_cnode[obj->id] = cnode; 103 } 104 105 return 0; 106 } 107 108 static int get_obj_to_cnode(int obj_id) 109 { 110 return prev_obj_to_cnode[obj_id]; 111 } 112 113 struct uv_hub { 114 struct kobject kobj; 115 struct uv_bios_hub_info *hub_info; 116 struct uv_port **ports; 117 }; 118 119 #define to_uv_hub(kobj_ptr) container_of(kobj_ptr, struct uv_hub, kobj) 120 121 static ssize_t hub_name_show(struct uv_bios_hub_info *hub_info, char *buf) 122 { 123 return sysfs_emit(buf, "%s\n", hub_info->name); 124 } 125 126 static ssize_t hub_location_show(struct uv_bios_hub_info *hub_info, char *buf) 127 { 128 return sysfs_emit(buf, "%s\n", hub_info->location); 129 } 130 131 static ssize_t hub_partition_show(struct uv_bios_hub_info *hub_info, char *buf) 132 { 133 return sysfs_emit(buf, "%d\n", hub_info->f.fields.this_part); 134 } 135 136 static ssize_t hub_shared_show(struct uv_bios_hub_info *hub_info, char *buf) 137 { 138 return sysfs_emit(buf, "%d\n", hub_info->f.fields.is_shared); 139 } 140 static ssize_t hub_nasid_show(struct uv_bios_hub_info *hub_info, char *buf) 141 { 142 int cnode = get_obj_to_cnode(hub_info->id); 143 144 return sysfs_emit(buf, "%d\n", ordinal_to_nasid(cnode)); 145 } 146 static ssize_t hub_cnode_show(struct uv_bios_hub_info *hub_info, char *buf) 147 { 148 return sysfs_emit(buf, "%d\n", get_obj_to_cnode(hub_info->id)); 149 } 150 151 struct hub_sysfs_entry { 152 struct attribute attr; 153 ssize_t (*show)(struct uv_bios_hub_info *hub_info, char *buf); 154 ssize_t (*store)(struct uv_bios_hub_info *hub_info, const char *buf, size_t sz); 155 }; 156 157 static struct hub_sysfs_entry name_attribute = 158 __ATTR(name, 0444, hub_name_show, NULL); 159 static struct hub_sysfs_entry location_attribute = 160 __ATTR(location, 0444, hub_location_show, NULL); 161 static struct hub_sysfs_entry partition_attribute = 162 __ATTR(this_partition, 0444, hub_partition_show, NULL); 163 static struct hub_sysfs_entry shared_attribute = 164 __ATTR(shared, 0444, hub_shared_show, NULL); 165 static struct hub_sysfs_entry nasid_attribute = 166 __ATTR(nasid, 0444, hub_nasid_show, NULL); 167 static struct hub_sysfs_entry cnode_attribute = 168 __ATTR(cnode, 0444, hub_cnode_show, NULL); 169 170 static struct attribute *uv_hub_attrs[] = { 171 &name_attribute.attr, 172 &location_attribute.attr, 173 &partition_attribute.attr, 174 &shared_attribute.attr, 175 &nasid_attribute.attr, 176 &cnode_attribute.attr, 177 NULL, 178 }; 179 ATTRIBUTE_GROUPS(uv_hub); 180 181 static void hub_release(struct kobject *kobj) 182 { 183 struct uv_hub *hub = to_uv_hub(kobj); 184 185 kfree(hub); 186 } 187 188 static ssize_t hub_type_show(struct kobject *kobj, struct attribute *attr, 189 char *buf) 190 { 191 struct uv_hub *hub = to_uv_hub(kobj); 192 struct uv_bios_hub_info *bios_hub_info = hub->hub_info; 193 struct hub_sysfs_entry *entry; 194 195 entry = container_of(attr, struct hub_sysfs_entry, attr); 196 197 if (!entry->show) 198 return -EIO; 199 200 return entry->show(bios_hub_info, buf); 201 } 202 203 static const struct sysfs_ops hub_sysfs_ops = { 204 .show = hub_type_show, 205 }; 206 207 static const struct kobj_type hub_attr_type = { 208 .release = hub_release, 209 .sysfs_ops = &hub_sysfs_ops, 210 .default_groups = uv_hub_groups, 211 }; 212 213 static int uv_hubs_init(void) 214 { 215 s64 biosr; 216 u64 sz; 217 int i, ret; 218 219 prev_obj_to_cnode = kmalloc_objs(*prev_obj_to_cnode, uv_bios_obj_cnt); 220 if (!prev_obj_to_cnode) 221 return -ENOMEM; 222 223 for (i = 0; i < uv_bios_obj_cnt; i++) 224 prev_obj_to_cnode[i] = INVALID_CNODE; 225 226 uv_hubs_kset = kset_create_and_add("hubs", NULL, sgi_uv_kobj); 227 if (!uv_hubs_kset) { 228 ret = -ENOMEM; 229 goto err_hubs_kset; 230 } 231 sz = uv_bios_obj_cnt * sizeof(*hub_buf); 232 hub_buf = kzalloc(sz, GFP_KERNEL); 233 if (!hub_buf) { 234 ret = -ENOMEM; 235 goto err_hub_buf; 236 } 237 238 biosr = uv_bios_enum_objs((u64)uv_master_nasid, sz, (u64 *)hub_buf); 239 if (biosr) { 240 ret = -EINVAL; 241 goto err_enum_objs; 242 } 243 244 uv_hubs = kzalloc_objs(*uv_hubs, uv_bios_obj_cnt); 245 if (!uv_hubs) { 246 ret = -ENOMEM; 247 goto err_enum_objs; 248 } 249 250 for (i = 0; i < uv_bios_obj_cnt; i++) { 251 uv_hubs[i] = kzalloc_obj(*uv_hubs[i]); 252 if (!uv_hubs[i]) { 253 i--; 254 ret = -ENOMEM; 255 goto err_hubs; 256 } 257 258 uv_hubs[i]->hub_info = &hub_buf[i]; 259 cache_obj_to_cnode(uv_hubs[i]->hub_info); 260 261 uv_hubs[i]->kobj.kset = uv_hubs_kset; 262 263 ret = kobject_init_and_add(&uv_hubs[i]->kobj, &hub_attr_type, 264 NULL, "hub_%u", hub_buf[i].id); 265 if (ret) 266 goto err_hubs; 267 kobject_uevent(&uv_hubs[i]->kobj, KOBJ_ADD); 268 } 269 return 0; 270 271 err_hubs: 272 for (; i >= 0; i--) 273 kobject_put(&uv_hubs[i]->kobj); 274 kfree(uv_hubs); 275 err_enum_objs: 276 kfree(hub_buf); 277 err_hub_buf: 278 kset_unregister(uv_hubs_kset); 279 err_hubs_kset: 280 kfree(prev_obj_to_cnode); 281 return ret; 282 283 } 284 285 static void uv_hubs_exit(void) 286 { 287 int i; 288 289 for (i = 0; i < uv_bios_obj_cnt; i++) 290 kobject_put(&uv_hubs[i]->kobj); 291 292 kfree(uv_hubs); 293 kfree(hub_buf); 294 kset_unregister(uv_hubs_kset); 295 kfree(prev_obj_to_cnode); 296 } 297 298 struct uv_port { 299 struct kobject kobj; 300 struct uv_bios_port_info *port_info; 301 }; 302 303 #define to_uv_port(kobj_ptr) container_of(kobj_ptr, struct uv_port, kobj) 304 305 static ssize_t uv_port_conn_hub_show(struct uv_bios_port_info *port, char *buf) 306 { 307 return sysfs_emit(buf, "%d\n", port->conn_id); 308 } 309 310 static ssize_t uv_port_conn_port_show(struct uv_bios_port_info *port, char *buf) 311 { 312 return sysfs_emit(buf, "%d\n", port->conn_port); 313 } 314 315 struct uv_port_sysfs_entry { 316 struct attribute attr; 317 ssize_t (*show)(struct uv_bios_port_info *port_info, char *buf); 318 ssize_t (*store)(struct uv_bios_port_info *port_info, const char *buf, size_t size); 319 }; 320 321 static struct uv_port_sysfs_entry uv_port_conn_hub_attribute = 322 __ATTR(conn_hub, 0444, uv_port_conn_hub_show, NULL); 323 static struct uv_port_sysfs_entry uv_port_conn_port_attribute = 324 __ATTR(conn_port, 0444, uv_port_conn_port_show, NULL); 325 326 static struct attribute *uv_port_attrs[] = { 327 &uv_port_conn_hub_attribute.attr, 328 &uv_port_conn_port_attribute.attr, 329 NULL, 330 }; 331 ATTRIBUTE_GROUPS(uv_port); 332 333 static void uv_port_release(struct kobject *kobj) 334 { 335 struct uv_port *port = to_uv_port(kobj); 336 337 kfree(port); 338 } 339 340 static ssize_t uv_port_type_show(struct kobject *kobj, struct attribute *attr, 341 char *buf) 342 { 343 struct uv_port *port = to_uv_port(kobj); 344 struct uv_bios_port_info *port_info = port->port_info; 345 struct uv_port_sysfs_entry *entry; 346 347 entry = container_of(attr, struct uv_port_sysfs_entry, attr); 348 349 if (!entry->show) 350 return -EIO; 351 352 return entry->show(port_info, buf); 353 } 354 355 static const struct sysfs_ops uv_port_sysfs_ops = { 356 .show = uv_port_type_show, 357 }; 358 359 static const struct kobj_type uv_port_attr_type = { 360 .release = uv_port_release, 361 .sysfs_ops = &uv_port_sysfs_ops, 362 .default_groups = uv_port_groups, 363 }; 364 365 static int uv_ports_init(void) 366 { 367 s64 biosr; 368 int j = 0, k = 0, ret, sz; 369 370 port_buf = kzalloc_objs(*port_buf, uv_bios_obj_cnt); 371 if (!port_buf) 372 return -ENOMEM; 373 374 for (j = 0; j < uv_bios_obj_cnt; j++) { 375 sz = hub_buf[j].ports * sizeof(*port_buf[j]); 376 port_buf[j] = kzalloc(sz, GFP_KERNEL); 377 if (!port_buf[j]) { 378 ret = -ENOMEM; 379 j--; 380 goto err_port_info; 381 } 382 biosr = uv_bios_enum_ports((u64)uv_master_nasid, (u64)hub_buf[j].id, sz, 383 (u64 *)port_buf[j]); 384 if (biosr) { 385 ret = -EINVAL; 386 goto err_port_info; 387 } 388 } 389 for (j = 0; j < uv_bios_obj_cnt; j++) { 390 uv_hubs[j]->ports = kzalloc_objs(*uv_hubs[j]->ports, 391 hub_buf[j].ports); 392 if (!uv_hubs[j]->ports) { 393 ret = -ENOMEM; 394 j--; 395 goto err_ports; 396 } 397 } 398 for (j = 0; j < uv_bios_obj_cnt; j++) { 399 for (k = 0; k < hub_buf[j].ports; k++) { 400 uv_hubs[j]->ports[k] = kzalloc_obj(*uv_hubs[j]->ports[k]); 401 if (!uv_hubs[j]->ports[k]) { 402 ret = -ENOMEM; 403 k--; 404 goto err_kobj_ports; 405 } 406 uv_hubs[j]->ports[k]->port_info = &port_buf[j][k]; 407 ret = kobject_init_and_add(&uv_hubs[j]->ports[k]->kobj, &uv_port_attr_type, 408 &uv_hubs[j]->kobj, "port_%d", port_buf[j][k].port); 409 if (ret) 410 goto err_kobj_ports; 411 kobject_uevent(&uv_hubs[j]->ports[k]->kobj, KOBJ_ADD); 412 } 413 } 414 return 0; 415 416 err_kobj_ports: 417 for (; j >= 0; j--) { 418 for (; k >= 0; k--) 419 kobject_put(&uv_hubs[j]->ports[k]->kobj); 420 if (j > 0) 421 k = hub_buf[j-1].ports - 1; 422 } 423 j = uv_bios_obj_cnt - 1; 424 err_ports: 425 for (; j >= 0; j--) 426 kfree(uv_hubs[j]->ports); 427 j = uv_bios_obj_cnt - 1; 428 err_port_info: 429 for (; j >= 0; j--) 430 kfree(port_buf[j]); 431 kfree(port_buf); 432 return ret; 433 } 434 435 static void uv_ports_exit(void) 436 { 437 int j, k; 438 439 for (j = 0; j < uv_bios_obj_cnt; j++) { 440 for (k = hub_buf[j].ports - 1; k >= 0; k--) 441 kobject_put(&uv_hubs[j]->ports[k]->kobj); 442 } 443 for (j = 0; j < uv_bios_obj_cnt; j++) { 444 kfree(uv_hubs[j]->ports); 445 kfree(port_buf[j]); 446 } 447 kfree(port_buf); 448 } 449 450 struct uv_pci_top_obj { 451 struct kobject kobj; 452 char *type; 453 char *location; 454 int iio_stack; 455 char *ppb_addr; 456 int slot; 457 }; 458 459 #define to_uv_pci_top_obj(kobj_ptr) container_of(kobj_ptr, struct uv_pci_top_obj, kobj) 460 461 static ssize_t uv_pci_type_show(struct uv_pci_top_obj *top_obj, char *buf) 462 { 463 return sysfs_emit(buf, "%s\n", top_obj->type); 464 } 465 466 static ssize_t uv_pci_location_show(struct uv_pci_top_obj *top_obj, char *buf) 467 { 468 return sysfs_emit(buf, "%s\n", top_obj->location); 469 } 470 471 static ssize_t uv_pci_iio_stack_show(struct uv_pci_top_obj *top_obj, char *buf) 472 { 473 return sysfs_emit(buf, "%d\n", top_obj->iio_stack); 474 } 475 476 static ssize_t uv_pci_ppb_addr_show(struct uv_pci_top_obj *top_obj, char *buf) 477 { 478 return sysfs_emit(buf, "%s\n", top_obj->ppb_addr); 479 } 480 481 static ssize_t uv_pci_slot_show(struct uv_pci_top_obj *top_obj, char *buf) 482 { 483 return sysfs_emit(buf, "%d\n", top_obj->slot); 484 } 485 486 struct uv_pci_top_sysfs_entry { 487 struct attribute attr; 488 ssize_t (*show)(struct uv_pci_top_obj *top_obj, char *buf); 489 ssize_t (*store)(struct uv_pci_top_obj *top_obj, const char *buf, size_t size); 490 }; 491 492 static struct uv_pci_top_sysfs_entry uv_pci_type_attribute = 493 __ATTR(type, 0444, uv_pci_type_show, NULL); 494 static struct uv_pci_top_sysfs_entry uv_pci_location_attribute = 495 __ATTR(location, 0444, uv_pci_location_show, NULL); 496 static struct uv_pci_top_sysfs_entry uv_pci_iio_stack_attribute = 497 __ATTR(iio_stack, 0444, uv_pci_iio_stack_show, NULL); 498 static struct uv_pci_top_sysfs_entry uv_pci_ppb_addr_attribute = 499 __ATTR(ppb_addr, 0444, uv_pci_ppb_addr_show, NULL); 500 static struct uv_pci_top_sysfs_entry uv_pci_slot_attribute = 501 __ATTR(slot, 0444, uv_pci_slot_show, NULL); 502 503 static void uv_pci_top_release(struct kobject *kobj) 504 { 505 struct uv_pci_top_obj *top_obj = to_uv_pci_top_obj(kobj); 506 507 kfree(top_obj->type); 508 kfree(top_obj->location); 509 kfree(top_obj->ppb_addr); 510 kfree(top_obj); 511 } 512 513 static ssize_t pci_top_type_show(struct kobject *kobj, 514 struct attribute *attr, char *buf) 515 { 516 struct uv_pci_top_obj *top_obj = to_uv_pci_top_obj(kobj); 517 struct uv_pci_top_sysfs_entry *entry; 518 519 entry = container_of(attr, struct uv_pci_top_sysfs_entry, attr); 520 521 if (!entry->show) 522 return -EIO; 523 524 return entry->show(top_obj, buf); 525 } 526 527 static const struct sysfs_ops uv_pci_top_sysfs_ops = { 528 .show = pci_top_type_show, 529 }; 530 531 static const struct kobj_type uv_pci_top_attr_type = { 532 .release = uv_pci_top_release, 533 .sysfs_ops = &uv_pci_top_sysfs_ops, 534 }; 535 536 static int init_pci_top_obj(struct uv_pci_top_obj *top_obj, char *line) 537 { 538 char *start; 539 char type[11], location[14], ppb_addr[15]; 540 int str_cnt, ret; 541 unsigned int tmp_match[2]; 542 543 // Minimum line length 544 if (strlen(line) < 36) 545 return -EINVAL; 546 547 //Line must match format "pcibus %4x:%2x" to be valid 548 str_cnt = sscanf(line, "pcibus %4x:%2x", &tmp_match[0], &tmp_match[1]); 549 if (str_cnt < 2) 550 return -EINVAL; 551 552 /* Connect pcibus to segment:bus number with '_' 553 * to concatenate name tokens. 554 * pcibus 0000:00 ... -> pcibus_0000:00 ... 555 */ 556 line[6] = '_'; 557 558 /* Null terminate after the concatencated name tokens 559 * to produce kobj name string. 560 */ 561 line[14] = '\0'; 562 563 // Use start to index after name tokens string for remainder of line info. 564 start = &line[15]; 565 566 top_obj->iio_stack = -1; 567 top_obj->slot = -1; 568 569 /* r001i01b00h0 BASE IO (IIO Stack 0) 570 * r001i01b00h1 PCIe IO (IIO Stack 1) 571 * r001i01b03h1 PCIe SLOT 572 * r001i01b00h0 NODE IO 573 * r001i01b00h0 Riser 574 * (IIO Stack #) may not be present. 575 */ 576 if (start[0] == 'r') { 577 str_cnt = sscanf(start, "%13s %10[^(] %*s %*s %d)", 578 location, type, &top_obj->iio_stack); 579 if (str_cnt < 2) 580 return -EINVAL; 581 top_obj->type = kstrdup(type, GFP_KERNEL); 582 if (!top_obj->type) 583 return -ENOMEM; 584 top_obj->location = kstrdup(location, GFP_KERNEL); 585 if (!top_obj->location) { 586 kfree(top_obj->type); 587 return -ENOMEM; 588 } 589 } 590 /* PPB at 0000:80:00.00 (slot 3) 591 * (slot #) may not be present. 592 */ 593 else if (start[0] == 'P') { 594 str_cnt = sscanf(start, "%10s %*s %14s %*s %d)", 595 type, ppb_addr, &top_obj->slot); 596 if (str_cnt < 2) 597 return -EINVAL; 598 top_obj->type = kstrdup(type, GFP_KERNEL); 599 if (!top_obj->type) 600 return -ENOMEM; 601 top_obj->ppb_addr = kstrdup(ppb_addr, GFP_KERNEL); 602 if (!top_obj->ppb_addr) { 603 kfree(top_obj->type); 604 return -ENOMEM; 605 } 606 } else 607 return -EINVAL; 608 609 top_obj->kobj.kset = uv_pcibus_kset; 610 611 ret = kobject_init_and_add(&top_obj->kobj, &uv_pci_top_attr_type, NULL, "%s", line); 612 if (ret) 613 goto err_add_sysfs; 614 615 if (top_obj->type) { 616 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_type_attribute.attr); 617 if (ret) 618 goto err_add_sysfs; 619 } 620 if (top_obj->location) { 621 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_location_attribute.attr); 622 if (ret) 623 goto err_add_sysfs; 624 } 625 if (top_obj->iio_stack >= 0) { 626 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_iio_stack_attribute.attr); 627 if (ret) 628 goto err_add_sysfs; 629 } 630 if (top_obj->ppb_addr) { 631 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_ppb_addr_attribute.attr); 632 if (ret) 633 goto err_add_sysfs; 634 } 635 if (top_obj->slot >= 0) { 636 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_slot_attribute.attr); 637 if (ret) 638 goto err_add_sysfs; 639 } 640 641 kobject_uevent(&top_obj->kobj, KOBJ_ADD); 642 return 0; 643 644 err_add_sysfs: 645 kobject_put(&top_obj->kobj); 646 return ret; 647 } 648 649 static int pci_topology_init(void) 650 { 651 char *pci_top_str, *start, *found, *count; 652 size_t sz; 653 s64 biosr; 654 int l = 0, k = 0; 655 int len, ret; 656 657 uv_pcibus_kset = kset_create_and_add("pcibuses", NULL, sgi_uv_kobj); 658 if (!uv_pcibus_kset) 659 return -ENOMEM; 660 661 for (sz = PAGE_SIZE; sz < 16 * PAGE_SIZE; sz += PAGE_SIZE) { 662 pci_top_str = kmalloc(sz, GFP_KERNEL); 663 if (!pci_top_str) { 664 ret = -ENOMEM; 665 goto err_pci_top_str; 666 } 667 biosr = uv_bios_get_pci_topology((u64)sz, (u64 *)pci_top_str); 668 if (biosr == BIOS_STATUS_SUCCESS) { 669 len = strnlen(pci_top_str, sz); 670 for (count = pci_top_str; count < pci_top_str + len; count++) { 671 if (*count == '\n') 672 l++; 673 } 674 num_pci_lines = l; 675 676 uv_pci_objs = kzalloc_objs(*uv_pci_objs, num_pci_lines); 677 if (!uv_pci_objs) { 678 kfree(pci_top_str); 679 ret = -ENOMEM; 680 goto err_pci_top_str; 681 } 682 start = pci_top_str; 683 while ((found = strsep(&start, "\n")) != NULL) { 684 uv_pci_objs[k] = kzalloc_obj(*uv_pci_objs[k]); 685 if (!uv_pci_objs[k]) { 686 ret = -ENOMEM; 687 goto err_pci_obj; 688 } 689 ret = init_pci_top_obj(uv_pci_objs[k], found); 690 if (ret) 691 goto err_pci_obj; 692 k++; 693 if (k == num_pci_lines) 694 break; 695 } 696 } 697 kfree(pci_top_str); 698 if (biosr == BIOS_STATUS_SUCCESS || biosr == BIOS_STATUS_UNIMPLEMENTED) 699 break; 700 } 701 702 return 0; 703 err_pci_obj: 704 k--; 705 for (; k >= 0; k--) 706 kobject_put(&uv_pci_objs[k]->kobj); 707 kfree(uv_pci_objs); 708 kfree(pci_top_str); 709 err_pci_top_str: 710 kset_unregister(uv_pcibus_kset); 711 return ret; 712 } 713 714 static void pci_topology_exit(void) 715 { 716 int k; 717 718 for (k = 0; k < num_pci_lines; k++) 719 kobject_put(&uv_pci_objs[k]->kobj); 720 kset_unregister(uv_pcibus_kset); 721 kfree(uv_pci_objs); 722 } 723 724 static ssize_t partition_id_show(struct kobject *kobj, 725 struct kobj_attribute *attr, char *buf) 726 { 727 return sysfs_emit(buf, "%ld\n", sn_partition_id); 728 } 729 730 static ssize_t coherence_id_show(struct kobject *kobj, 731 struct kobj_attribute *attr, char *buf) 732 { 733 return sysfs_emit(buf, "%ld\n", sn_coherency_id); 734 } 735 736 static ssize_t uv_type_show(struct kobject *kobj, 737 struct kobj_attribute *attr, char *buf) 738 { 739 return sysfs_emit(buf, "%s\n", uv_type_string()); 740 } 741 742 static ssize_t uv_archtype_show(struct kobject *kobj, 743 struct kobj_attribute *attr, char *buf) 744 { 745 return uv_get_archtype(buf, PAGE_SIZE); 746 } 747 748 static ssize_t uv_hub_type_show(struct kobject *kobj, 749 struct kobj_attribute *attr, char *buf) 750 { 751 return sysfs_emit(buf, "0x%x\n", uv_hub_type()); 752 } 753 754 static ssize_t uv_hubless_show(struct kobject *kobj, 755 struct kobj_attribute *attr, char *buf) 756 { 757 return sysfs_emit(buf, "0x%x\n", uv_get_hubless_system()); 758 } 759 760 static struct kobj_attribute partition_id_attr = 761 __ATTR(partition_id, 0444, partition_id_show, NULL); 762 static struct kobj_attribute coherence_id_attr = 763 __ATTR(coherence_id, 0444, coherence_id_show, NULL); 764 static struct kobj_attribute uv_type_attr = 765 __ATTR(uv_type, 0444, uv_type_show, NULL); 766 static struct kobj_attribute uv_archtype_attr = 767 __ATTR(archtype, 0444, uv_archtype_show, NULL); 768 static struct kobj_attribute uv_hub_type_attr = 769 __ATTR(hub_type, 0444, uv_hub_type_show, NULL); 770 static struct kobj_attribute uv_hubless_attr = 771 __ATTR(hubless, 0444, uv_hubless_show, NULL); 772 773 static struct attribute *base_attrs[] = { 774 &partition_id_attr.attr, 775 &coherence_id_attr.attr, 776 &uv_type_attr.attr, 777 &uv_archtype_attr.attr, 778 &uv_hub_type_attr.attr, 779 NULL, 780 }; 781 782 static const struct attribute_group base_attr_group = { 783 .attrs = base_attrs 784 }; 785 786 static int initial_bios_setup(void) 787 { 788 u64 v; 789 s64 biosr; 790 791 biosr = uv_bios_get_master_nasid((u64)sizeof(uv_master_nasid), (u64 *)&uv_master_nasid); 792 if (biosr) 793 return -EINVAL; 794 795 biosr = uv_bios_get_heapsize((u64)uv_master_nasid, (u64)sizeof(u64), &v); 796 if (biosr) 797 return -EINVAL; 798 799 uv_biosheap = vmalloc(v); 800 if (!uv_biosheap) 801 return -ENOMEM; 802 803 biosr = uv_bios_install_heap((u64)uv_master_nasid, v, (u64 *)uv_biosheap); 804 if (biosr) { 805 vfree(uv_biosheap); 806 return -EINVAL; 807 } 808 809 biosr = uv_bios_obj_count((u64)uv_master_nasid, sizeof(u64), &v); 810 if (biosr) { 811 vfree(uv_biosheap); 812 return -EINVAL; 813 } 814 uv_bios_obj_cnt = (int)v; 815 816 return 0; 817 } 818 819 static struct attribute *hubless_base_attrs[] = { 820 &partition_id_attr.attr, 821 &uv_type_attr.attr, 822 &uv_archtype_attr.attr, 823 &uv_hubless_attr.attr, 824 NULL, 825 }; 826 827 static const struct attribute_group hubless_base_attr_group = { 828 .attrs = hubless_base_attrs 829 }; 830 831 832 static int __init uv_sysfs_hubless_init(void) 833 { 834 int ret; 835 836 ret = sysfs_create_group(sgi_uv_kobj, &hubless_base_attr_group); 837 if (ret) { 838 pr_warn("sysfs_create_group hubless_base_attr_group failed\n"); 839 kobject_put(sgi_uv_kobj); 840 } 841 return ret; 842 } 843 844 static int __init uv_sysfs_init(void) 845 { 846 int ret = 0; 847 848 if (!is_uv_system() && !uv_get_hubless_system()) 849 return -ENODEV; 850 851 num_cnodes = uv_num_possible_blades(); 852 853 if (!sgi_uv_kobj) 854 sgi_uv_kobj = kobject_create_and_add("sgi_uv", firmware_kobj); 855 if (!sgi_uv_kobj) { 856 pr_warn("kobject_create_and_add sgi_uv failed\n"); 857 return -EINVAL; 858 } 859 860 if (uv_get_hubless_system()) 861 return uv_sysfs_hubless_init(); 862 863 ret = sysfs_create_group(sgi_uv_kobj, &base_attr_group); 864 if (ret) { 865 pr_warn("sysfs_create_group base_attr_group failed\n"); 866 goto err_create_group; 867 } 868 869 ret = initial_bios_setup(); 870 if (ret) 871 goto err_bios_setup; 872 873 ret = uv_hubs_init(); 874 if (ret) 875 goto err_hubs_init; 876 877 ret = uv_ports_init(); 878 if (ret) 879 goto err_ports_init; 880 881 ret = pci_topology_init(); 882 if (ret) 883 goto err_pci_init; 884 885 return 0; 886 887 err_pci_init: 888 uv_ports_exit(); 889 err_ports_init: 890 uv_hubs_exit(); 891 err_hubs_init: 892 vfree(uv_biosheap); 893 err_bios_setup: 894 sysfs_remove_group(sgi_uv_kobj, &base_attr_group); 895 err_create_group: 896 kobject_put(sgi_uv_kobj); 897 return ret; 898 } 899 900 static void __exit uv_sysfs_hubless_exit(void) 901 { 902 sysfs_remove_group(sgi_uv_kobj, &hubless_base_attr_group); 903 kobject_put(sgi_uv_kobj); 904 } 905 906 static void __exit uv_sysfs_exit(void) 907 { 908 if (!is_uv_system()) { 909 if (uv_get_hubless_system()) 910 uv_sysfs_hubless_exit(); 911 return; 912 } 913 914 pci_topology_exit(); 915 uv_ports_exit(); 916 uv_hubs_exit(); 917 vfree(uv_biosheap); 918 sysfs_remove_group(sgi_uv_kobj, &base_attr_group); 919 kobject_put(sgi_uv_kobj); 920 } 921 922 #ifndef MODULE 923 device_initcall(uv_sysfs_init); 924 #else 925 module_init(uv_sysfs_init); 926 #endif 927 module_exit(uv_sysfs_exit); 928 929 MODULE_AUTHOR("Hewlett Packard Enterprise"); 930 MODULE_DESCRIPTION("Sysfs structure for HPE UV systems"); 931 MODULE_LICENSE("GPL"); 932