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_array(uv_bios_obj_cnt, sizeof(*prev_obj_to_cnode), 220 GFP_KERNEL); 221 if (!prev_obj_to_cnode) 222 return -ENOMEM; 223 224 for (i = 0; i < uv_bios_obj_cnt; i++) 225 prev_obj_to_cnode[i] = INVALID_CNODE; 226 227 uv_hubs_kset = kset_create_and_add("hubs", NULL, sgi_uv_kobj); 228 if (!uv_hubs_kset) { 229 ret = -ENOMEM; 230 goto err_hubs_kset; 231 } 232 sz = uv_bios_obj_cnt * sizeof(*hub_buf); 233 hub_buf = kzalloc(sz, GFP_KERNEL); 234 if (!hub_buf) { 235 ret = -ENOMEM; 236 goto err_hub_buf; 237 } 238 239 biosr = uv_bios_enum_objs((u64)uv_master_nasid, sz, (u64 *)hub_buf); 240 if (biosr) { 241 ret = -EINVAL; 242 goto err_enum_objs; 243 } 244 245 uv_hubs = kcalloc(uv_bios_obj_cnt, sizeof(*uv_hubs), GFP_KERNEL); 246 if (!uv_hubs) { 247 ret = -ENOMEM; 248 goto err_enum_objs; 249 } 250 251 for (i = 0; i < uv_bios_obj_cnt; i++) { 252 uv_hubs[i] = kzalloc(sizeof(*uv_hubs[i]), GFP_KERNEL); 253 if (!uv_hubs[i]) { 254 i--; 255 ret = -ENOMEM; 256 goto err_hubs; 257 } 258 259 uv_hubs[i]->hub_info = &hub_buf[i]; 260 cache_obj_to_cnode(uv_hubs[i]->hub_info); 261 262 uv_hubs[i]->kobj.kset = uv_hubs_kset; 263 264 ret = kobject_init_and_add(&uv_hubs[i]->kobj, &hub_attr_type, 265 NULL, "hub_%u", hub_buf[i].id); 266 if (ret) 267 goto err_hubs; 268 kobject_uevent(&uv_hubs[i]->kobj, KOBJ_ADD); 269 } 270 return 0; 271 272 err_hubs: 273 for (; i >= 0; i--) 274 kobject_put(&uv_hubs[i]->kobj); 275 kfree(uv_hubs); 276 err_enum_objs: 277 kfree(hub_buf); 278 err_hub_buf: 279 kset_unregister(uv_hubs_kset); 280 err_hubs_kset: 281 kfree(prev_obj_to_cnode); 282 return ret; 283 284 } 285 286 static void uv_hubs_exit(void) 287 { 288 int i; 289 290 for (i = 0; i < uv_bios_obj_cnt; i++) 291 kobject_put(&uv_hubs[i]->kobj); 292 293 kfree(uv_hubs); 294 kfree(hub_buf); 295 kset_unregister(uv_hubs_kset); 296 kfree(prev_obj_to_cnode); 297 } 298 299 struct uv_port { 300 struct kobject kobj; 301 struct uv_bios_port_info *port_info; 302 }; 303 304 #define to_uv_port(kobj_ptr) container_of(kobj_ptr, struct uv_port, kobj) 305 306 static ssize_t uv_port_conn_hub_show(struct uv_bios_port_info *port, char *buf) 307 { 308 return sysfs_emit(buf, "%d\n", port->conn_id); 309 } 310 311 static ssize_t uv_port_conn_port_show(struct uv_bios_port_info *port, char *buf) 312 { 313 return sysfs_emit(buf, "%d\n", port->conn_port); 314 } 315 316 struct uv_port_sysfs_entry { 317 struct attribute attr; 318 ssize_t (*show)(struct uv_bios_port_info *port_info, char *buf); 319 ssize_t (*store)(struct uv_bios_port_info *port_info, const char *buf, size_t size); 320 }; 321 322 static struct uv_port_sysfs_entry uv_port_conn_hub_attribute = 323 __ATTR(conn_hub, 0444, uv_port_conn_hub_show, NULL); 324 static struct uv_port_sysfs_entry uv_port_conn_port_attribute = 325 __ATTR(conn_port, 0444, uv_port_conn_port_show, NULL); 326 327 static struct attribute *uv_port_attrs[] = { 328 &uv_port_conn_hub_attribute.attr, 329 &uv_port_conn_port_attribute.attr, 330 NULL, 331 }; 332 ATTRIBUTE_GROUPS(uv_port); 333 334 static void uv_port_release(struct kobject *kobj) 335 { 336 struct uv_port *port = to_uv_port(kobj); 337 338 kfree(port); 339 } 340 341 static ssize_t uv_port_type_show(struct kobject *kobj, struct attribute *attr, 342 char *buf) 343 { 344 struct uv_port *port = to_uv_port(kobj); 345 struct uv_bios_port_info *port_info = port->port_info; 346 struct uv_port_sysfs_entry *entry; 347 348 entry = container_of(attr, struct uv_port_sysfs_entry, attr); 349 350 if (!entry->show) 351 return -EIO; 352 353 return entry->show(port_info, buf); 354 } 355 356 static const struct sysfs_ops uv_port_sysfs_ops = { 357 .show = uv_port_type_show, 358 }; 359 360 static const struct kobj_type uv_port_attr_type = { 361 .release = uv_port_release, 362 .sysfs_ops = &uv_port_sysfs_ops, 363 .default_groups = uv_port_groups, 364 }; 365 366 static int uv_ports_init(void) 367 { 368 s64 biosr; 369 int j = 0, k = 0, ret, sz; 370 371 port_buf = kcalloc(uv_bios_obj_cnt, sizeof(*port_buf), GFP_KERNEL); 372 if (!port_buf) 373 return -ENOMEM; 374 375 for (j = 0; j < uv_bios_obj_cnt; j++) { 376 sz = hub_buf[j].ports * sizeof(*port_buf[j]); 377 port_buf[j] = kzalloc(sz, GFP_KERNEL); 378 if (!port_buf[j]) { 379 ret = -ENOMEM; 380 j--; 381 goto err_port_info; 382 } 383 biosr = uv_bios_enum_ports((u64)uv_master_nasid, (u64)hub_buf[j].id, sz, 384 (u64 *)port_buf[j]); 385 if (biosr) { 386 ret = -EINVAL; 387 goto err_port_info; 388 } 389 } 390 for (j = 0; j < uv_bios_obj_cnt; j++) { 391 uv_hubs[j]->ports = kcalloc(hub_buf[j].ports, 392 sizeof(*uv_hubs[j]->ports), GFP_KERNEL); 393 if (!uv_hubs[j]->ports) { 394 ret = -ENOMEM; 395 j--; 396 goto err_ports; 397 } 398 } 399 for (j = 0; j < uv_bios_obj_cnt; j++) { 400 for (k = 0; k < hub_buf[j].ports; k++) { 401 uv_hubs[j]->ports[k] = kzalloc(sizeof(*uv_hubs[j]->ports[k]), GFP_KERNEL); 402 if (!uv_hubs[j]->ports[k]) { 403 ret = -ENOMEM; 404 k--; 405 goto err_kobj_ports; 406 } 407 uv_hubs[j]->ports[k]->port_info = &port_buf[j][k]; 408 ret = kobject_init_and_add(&uv_hubs[j]->ports[k]->kobj, &uv_port_attr_type, 409 &uv_hubs[j]->kobj, "port_%d", port_buf[j][k].port); 410 if (ret) 411 goto err_kobj_ports; 412 kobject_uevent(&uv_hubs[j]->ports[k]->kobj, KOBJ_ADD); 413 } 414 } 415 return 0; 416 417 err_kobj_ports: 418 for (; j >= 0; j--) { 419 for (; k >= 0; k--) 420 kobject_put(&uv_hubs[j]->ports[k]->kobj); 421 if (j > 0) 422 k = hub_buf[j-1].ports - 1; 423 } 424 j = uv_bios_obj_cnt - 1; 425 err_ports: 426 for (; j >= 0; j--) 427 kfree(uv_hubs[j]->ports); 428 j = uv_bios_obj_cnt - 1; 429 err_port_info: 430 for (; j >= 0; j--) 431 kfree(port_buf[j]); 432 kfree(port_buf); 433 return ret; 434 } 435 436 static void uv_ports_exit(void) 437 { 438 int j, k; 439 440 for (j = 0; j < uv_bios_obj_cnt; j++) { 441 for (k = hub_buf[j].ports - 1; k >= 0; k--) 442 kobject_put(&uv_hubs[j]->ports[k]->kobj); 443 } 444 for (j = 0; j < uv_bios_obj_cnt; j++) { 445 kfree(uv_hubs[j]->ports); 446 kfree(port_buf[j]); 447 } 448 kfree(port_buf); 449 } 450 451 struct uv_pci_top_obj { 452 struct kobject kobj; 453 char *type; 454 char *location; 455 int iio_stack; 456 char *ppb_addr; 457 int slot; 458 }; 459 460 #define to_uv_pci_top_obj(kobj_ptr) container_of(kobj_ptr, struct uv_pci_top_obj, kobj) 461 462 static ssize_t uv_pci_type_show(struct uv_pci_top_obj *top_obj, char *buf) 463 { 464 return sysfs_emit(buf, "%s\n", top_obj->type); 465 } 466 467 static ssize_t uv_pci_location_show(struct uv_pci_top_obj *top_obj, char *buf) 468 { 469 return sysfs_emit(buf, "%s\n", top_obj->location); 470 } 471 472 static ssize_t uv_pci_iio_stack_show(struct uv_pci_top_obj *top_obj, char *buf) 473 { 474 return sysfs_emit(buf, "%d\n", top_obj->iio_stack); 475 } 476 477 static ssize_t uv_pci_ppb_addr_show(struct uv_pci_top_obj *top_obj, char *buf) 478 { 479 return sysfs_emit(buf, "%s\n", top_obj->ppb_addr); 480 } 481 482 static ssize_t uv_pci_slot_show(struct uv_pci_top_obj *top_obj, char *buf) 483 { 484 return sysfs_emit(buf, "%d\n", top_obj->slot); 485 } 486 487 struct uv_pci_top_sysfs_entry { 488 struct attribute attr; 489 ssize_t (*show)(struct uv_pci_top_obj *top_obj, char *buf); 490 ssize_t (*store)(struct uv_pci_top_obj *top_obj, const char *buf, size_t size); 491 }; 492 493 static struct uv_pci_top_sysfs_entry uv_pci_type_attribute = 494 __ATTR(type, 0444, uv_pci_type_show, NULL); 495 static struct uv_pci_top_sysfs_entry uv_pci_location_attribute = 496 __ATTR(location, 0444, uv_pci_location_show, NULL); 497 static struct uv_pci_top_sysfs_entry uv_pci_iio_stack_attribute = 498 __ATTR(iio_stack, 0444, uv_pci_iio_stack_show, NULL); 499 static struct uv_pci_top_sysfs_entry uv_pci_ppb_addr_attribute = 500 __ATTR(ppb_addr, 0444, uv_pci_ppb_addr_show, NULL); 501 static struct uv_pci_top_sysfs_entry uv_pci_slot_attribute = 502 __ATTR(slot, 0444, uv_pci_slot_show, NULL); 503 504 static void uv_pci_top_release(struct kobject *kobj) 505 { 506 struct uv_pci_top_obj *top_obj = to_uv_pci_top_obj(kobj); 507 508 kfree(top_obj->type); 509 kfree(top_obj->location); 510 kfree(top_obj->ppb_addr); 511 kfree(top_obj); 512 } 513 514 static ssize_t pci_top_type_show(struct kobject *kobj, 515 struct attribute *attr, char *buf) 516 { 517 struct uv_pci_top_obj *top_obj = to_uv_pci_top_obj(kobj); 518 struct uv_pci_top_sysfs_entry *entry; 519 520 entry = container_of(attr, struct uv_pci_top_sysfs_entry, attr); 521 522 if (!entry->show) 523 return -EIO; 524 525 return entry->show(top_obj, buf); 526 } 527 528 static const struct sysfs_ops uv_pci_top_sysfs_ops = { 529 .show = pci_top_type_show, 530 }; 531 532 static const struct kobj_type uv_pci_top_attr_type = { 533 .release = uv_pci_top_release, 534 .sysfs_ops = &uv_pci_top_sysfs_ops, 535 }; 536 537 static int init_pci_top_obj(struct uv_pci_top_obj *top_obj, char *line) 538 { 539 char *start; 540 char type[11], location[14], ppb_addr[15]; 541 int str_cnt, ret; 542 unsigned int tmp_match[2]; 543 544 // Minimum line length 545 if (strlen(line) < 36) 546 return -EINVAL; 547 548 //Line must match format "pcibus %4x:%2x" to be valid 549 str_cnt = sscanf(line, "pcibus %4x:%2x", &tmp_match[0], &tmp_match[1]); 550 if (str_cnt < 2) 551 return -EINVAL; 552 553 /* Connect pcibus to segment:bus number with '_' 554 * to concatenate name tokens. 555 * pcibus 0000:00 ... -> pcibus_0000:00 ... 556 */ 557 line[6] = '_'; 558 559 /* Null terminate after the concatencated name tokens 560 * to produce kobj name string. 561 */ 562 line[14] = '\0'; 563 564 // Use start to index after name tokens string for remainder of line info. 565 start = &line[15]; 566 567 top_obj->iio_stack = -1; 568 top_obj->slot = -1; 569 570 /* r001i01b00h0 BASE IO (IIO Stack 0) 571 * r001i01b00h1 PCIe IO (IIO Stack 1) 572 * r001i01b03h1 PCIe SLOT 573 * r001i01b00h0 NODE IO 574 * r001i01b00h0 Riser 575 * (IIO Stack #) may not be present. 576 */ 577 if (start[0] == 'r') { 578 str_cnt = sscanf(start, "%13s %10[^(] %*s %*s %d)", 579 location, type, &top_obj->iio_stack); 580 if (str_cnt < 2) 581 return -EINVAL; 582 top_obj->type = kstrdup(type, GFP_KERNEL); 583 if (!top_obj->type) 584 return -ENOMEM; 585 top_obj->location = kstrdup(location, GFP_KERNEL); 586 if (!top_obj->location) { 587 kfree(top_obj->type); 588 return -ENOMEM; 589 } 590 } 591 /* PPB at 0000:80:00.00 (slot 3) 592 * (slot #) may not be present. 593 */ 594 else if (start[0] == 'P') { 595 str_cnt = sscanf(start, "%10s %*s %14s %*s %d)", 596 type, ppb_addr, &top_obj->slot); 597 if (str_cnt < 2) 598 return -EINVAL; 599 top_obj->type = kstrdup(type, GFP_KERNEL); 600 if (!top_obj->type) 601 return -ENOMEM; 602 top_obj->ppb_addr = kstrdup(ppb_addr, GFP_KERNEL); 603 if (!top_obj->ppb_addr) { 604 kfree(top_obj->type); 605 return -ENOMEM; 606 } 607 } else 608 return -EINVAL; 609 610 top_obj->kobj.kset = uv_pcibus_kset; 611 612 ret = kobject_init_and_add(&top_obj->kobj, &uv_pci_top_attr_type, NULL, "%s", line); 613 if (ret) 614 goto err_add_sysfs; 615 616 if (top_obj->type) { 617 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_type_attribute.attr); 618 if (ret) 619 goto err_add_sysfs; 620 } 621 if (top_obj->location) { 622 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_location_attribute.attr); 623 if (ret) 624 goto err_add_sysfs; 625 } 626 if (top_obj->iio_stack >= 0) { 627 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_iio_stack_attribute.attr); 628 if (ret) 629 goto err_add_sysfs; 630 } 631 if (top_obj->ppb_addr) { 632 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_ppb_addr_attribute.attr); 633 if (ret) 634 goto err_add_sysfs; 635 } 636 if (top_obj->slot >= 0) { 637 ret = sysfs_create_file(&top_obj->kobj, &uv_pci_slot_attribute.attr); 638 if (ret) 639 goto err_add_sysfs; 640 } 641 642 kobject_uevent(&top_obj->kobj, KOBJ_ADD); 643 return 0; 644 645 err_add_sysfs: 646 kobject_put(&top_obj->kobj); 647 return ret; 648 } 649 650 static int pci_topology_init(void) 651 { 652 char *pci_top_str, *start, *found, *count; 653 size_t sz; 654 s64 biosr; 655 int l = 0, k = 0; 656 int len, ret; 657 658 uv_pcibus_kset = kset_create_and_add("pcibuses", NULL, sgi_uv_kobj); 659 if (!uv_pcibus_kset) 660 return -ENOMEM; 661 662 for (sz = PAGE_SIZE; sz < 16 * PAGE_SIZE; sz += PAGE_SIZE) { 663 pci_top_str = kmalloc(sz, GFP_KERNEL); 664 if (!pci_top_str) { 665 ret = -ENOMEM; 666 goto err_pci_top_str; 667 } 668 biosr = uv_bios_get_pci_topology((u64)sz, (u64 *)pci_top_str); 669 if (biosr == BIOS_STATUS_SUCCESS) { 670 len = strnlen(pci_top_str, sz); 671 for (count = pci_top_str; count < pci_top_str + len; count++) { 672 if (*count == '\n') 673 l++; 674 } 675 num_pci_lines = l; 676 677 uv_pci_objs = kcalloc(num_pci_lines, 678 sizeof(*uv_pci_objs), GFP_KERNEL); 679 if (!uv_pci_objs) { 680 kfree(pci_top_str); 681 ret = -ENOMEM; 682 goto err_pci_top_str; 683 } 684 start = pci_top_str; 685 while ((found = strsep(&start, "\n")) != NULL) { 686 uv_pci_objs[k] = kzalloc(sizeof(*uv_pci_objs[k]), GFP_KERNEL); 687 if (!uv_pci_objs[k]) { 688 ret = -ENOMEM; 689 goto err_pci_obj; 690 } 691 ret = init_pci_top_obj(uv_pci_objs[k], found); 692 if (ret) 693 goto err_pci_obj; 694 k++; 695 if (k == num_pci_lines) 696 break; 697 } 698 } 699 kfree(pci_top_str); 700 if (biosr == BIOS_STATUS_SUCCESS || biosr == BIOS_STATUS_UNIMPLEMENTED) 701 break; 702 } 703 704 return 0; 705 err_pci_obj: 706 k--; 707 for (; k >= 0; k--) 708 kobject_put(&uv_pci_objs[k]->kobj); 709 kfree(uv_pci_objs); 710 kfree(pci_top_str); 711 err_pci_top_str: 712 kset_unregister(uv_pcibus_kset); 713 return ret; 714 } 715 716 static void pci_topology_exit(void) 717 { 718 int k; 719 720 for (k = 0; k < num_pci_lines; k++) 721 kobject_put(&uv_pci_objs[k]->kobj); 722 kset_unregister(uv_pcibus_kset); 723 kfree(uv_pci_objs); 724 } 725 726 static ssize_t partition_id_show(struct kobject *kobj, 727 struct kobj_attribute *attr, char *buf) 728 { 729 return sysfs_emit(buf, "%ld\n", sn_partition_id); 730 } 731 732 static ssize_t coherence_id_show(struct kobject *kobj, 733 struct kobj_attribute *attr, char *buf) 734 { 735 return sysfs_emit(buf, "%ld\n", sn_coherency_id); 736 } 737 738 static ssize_t uv_type_show(struct kobject *kobj, 739 struct kobj_attribute *attr, char *buf) 740 { 741 return sysfs_emit(buf, "%s\n", uv_type_string()); 742 } 743 744 static ssize_t uv_archtype_show(struct kobject *kobj, 745 struct kobj_attribute *attr, char *buf) 746 { 747 return uv_get_archtype(buf, PAGE_SIZE); 748 } 749 750 static ssize_t uv_hub_type_show(struct kobject *kobj, 751 struct kobj_attribute *attr, char *buf) 752 { 753 return sysfs_emit(buf, "0x%x\n", uv_hub_type()); 754 } 755 756 static ssize_t uv_hubless_show(struct kobject *kobj, 757 struct kobj_attribute *attr, char *buf) 758 { 759 return sysfs_emit(buf, "0x%x\n", uv_get_hubless_system()); 760 } 761 762 static struct kobj_attribute partition_id_attr = 763 __ATTR(partition_id, 0444, partition_id_show, NULL); 764 static struct kobj_attribute coherence_id_attr = 765 __ATTR(coherence_id, 0444, coherence_id_show, NULL); 766 static struct kobj_attribute uv_type_attr = 767 __ATTR(uv_type, 0444, uv_type_show, NULL); 768 static struct kobj_attribute uv_archtype_attr = 769 __ATTR(archtype, 0444, uv_archtype_show, NULL); 770 static struct kobj_attribute uv_hub_type_attr = 771 __ATTR(hub_type, 0444, uv_hub_type_show, NULL); 772 static struct kobj_attribute uv_hubless_attr = 773 __ATTR(hubless, 0444, uv_hubless_show, NULL); 774 775 static struct attribute *base_attrs[] = { 776 &partition_id_attr.attr, 777 &coherence_id_attr.attr, 778 &uv_type_attr.attr, 779 &uv_archtype_attr.attr, 780 &uv_hub_type_attr.attr, 781 NULL, 782 }; 783 784 static const struct attribute_group base_attr_group = { 785 .attrs = base_attrs 786 }; 787 788 static int initial_bios_setup(void) 789 { 790 u64 v; 791 s64 biosr; 792 793 biosr = uv_bios_get_master_nasid((u64)sizeof(uv_master_nasid), (u64 *)&uv_master_nasid); 794 if (biosr) 795 return -EINVAL; 796 797 biosr = uv_bios_get_heapsize((u64)uv_master_nasid, (u64)sizeof(u64), &v); 798 if (biosr) 799 return -EINVAL; 800 801 uv_biosheap = vmalloc(v); 802 if (!uv_biosheap) 803 return -ENOMEM; 804 805 biosr = uv_bios_install_heap((u64)uv_master_nasid, v, (u64 *)uv_biosheap); 806 if (biosr) { 807 vfree(uv_biosheap); 808 return -EINVAL; 809 } 810 811 biosr = uv_bios_obj_count((u64)uv_master_nasid, sizeof(u64), &v); 812 if (biosr) { 813 vfree(uv_biosheap); 814 return -EINVAL; 815 } 816 uv_bios_obj_cnt = (int)v; 817 818 return 0; 819 } 820 821 static struct attribute *hubless_base_attrs[] = { 822 &partition_id_attr.attr, 823 &uv_type_attr.attr, 824 &uv_archtype_attr.attr, 825 &uv_hubless_attr.attr, 826 NULL, 827 }; 828 829 static const struct attribute_group hubless_base_attr_group = { 830 .attrs = hubless_base_attrs 831 }; 832 833 834 static int __init uv_sysfs_hubless_init(void) 835 { 836 int ret; 837 838 ret = sysfs_create_group(sgi_uv_kobj, &hubless_base_attr_group); 839 if (ret) { 840 pr_warn("sysfs_create_group hubless_base_attr_group failed\n"); 841 kobject_put(sgi_uv_kobj); 842 } 843 return ret; 844 } 845 846 static int __init uv_sysfs_init(void) 847 { 848 int ret = 0; 849 850 if (!is_uv_system() && !uv_get_hubless_system()) 851 return -ENODEV; 852 853 num_cnodes = uv_num_possible_blades(); 854 855 if (!sgi_uv_kobj) 856 sgi_uv_kobj = kobject_create_and_add("sgi_uv", firmware_kobj); 857 if (!sgi_uv_kobj) { 858 pr_warn("kobject_create_and_add sgi_uv failed\n"); 859 return -EINVAL; 860 } 861 862 if (uv_get_hubless_system()) 863 return uv_sysfs_hubless_init(); 864 865 ret = sysfs_create_group(sgi_uv_kobj, &base_attr_group); 866 if (ret) { 867 pr_warn("sysfs_create_group base_attr_group failed\n"); 868 goto err_create_group; 869 } 870 871 ret = initial_bios_setup(); 872 if (ret) 873 goto err_bios_setup; 874 875 ret = uv_hubs_init(); 876 if (ret) 877 goto err_hubs_init; 878 879 ret = uv_ports_init(); 880 if (ret) 881 goto err_ports_init; 882 883 ret = pci_topology_init(); 884 if (ret) 885 goto err_pci_init; 886 887 return 0; 888 889 err_pci_init: 890 uv_ports_exit(); 891 err_ports_init: 892 uv_hubs_exit(); 893 err_hubs_init: 894 vfree(uv_biosheap); 895 err_bios_setup: 896 sysfs_remove_group(sgi_uv_kobj, &base_attr_group); 897 err_create_group: 898 kobject_put(sgi_uv_kobj); 899 return ret; 900 } 901 902 static void __exit uv_sysfs_hubless_exit(void) 903 { 904 sysfs_remove_group(sgi_uv_kobj, &hubless_base_attr_group); 905 kobject_put(sgi_uv_kobj); 906 } 907 908 static void __exit uv_sysfs_exit(void) 909 { 910 if (!is_uv_system()) { 911 if (uv_get_hubless_system()) 912 uv_sysfs_hubless_exit(); 913 return; 914 } 915 916 pci_topology_exit(); 917 uv_ports_exit(); 918 uv_hubs_exit(); 919 vfree(uv_biosheap); 920 sysfs_remove_group(sgi_uv_kobj, &base_attr_group); 921 kobject_put(sgi_uv_kobj); 922 } 923 924 #ifndef MODULE 925 device_initcall(uv_sysfs_init); 926 #else 927 module_init(uv_sysfs_init); 928 #endif 929 module_exit(uv_sysfs_exit); 930 931 MODULE_AUTHOR("Hewlett Packard Enterprise"); 932 MODULE_LICENSE("GPL"); 933