934 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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 Ernst7 */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 -121 22struct kobject *sgi_uv_kobj;23static struct kset *uv_pcibus_kset;24static struct kset *uv_hubs_kset;25static struct uv_bios_hub_info *hub_buf;26static struct uv_bios_port_info **port_buf;27static struct uv_hub **uv_hubs;28static struct uv_pci_top_obj **uv_pci_objs;29static int num_pci_lines;30static int num_cnodes;31static int *prev_obj_to_cnode;32static int uv_bios_obj_cnt;33static signed short uv_master_nasid = -1;34static void *uv_biosheap;35 36static 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 else51 return "unknown";52}53 54static 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 else59 return -1;60}61 62static 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 70static 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 83static 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 108static int get_obj_to_cnode(int obj_id)109{110 return prev_obj_to_cnode[obj_id];111}112 113struct 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 121static 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 126static 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 131static 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 136static 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}140static 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}146static 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 151struct 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 157static struct hub_sysfs_entry name_attribute =158 __ATTR(name, 0444, hub_name_show, NULL);159static struct hub_sysfs_entry location_attribute =160 __ATTR(location, 0444, hub_location_show, NULL);161static struct hub_sysfs_entry partition_attribute =162 __ATTR(this_partition, 0444, hub_partition_show, NULL);163static struct hub_sysfs_entry shared_attribute =164 __ATTR(shared, 0444, hub_shared_show, NULL);165static struct hub_sysfs_entry nasid_attribute =166 __ATTR(nasid, 0444, hub_nasid_show, NULL);167static struct hub_sysfs_entry cnode_attribute =168 __ATTR(cnode, 0444, hub_cnode_show, NULL);169 170static 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};179ATTRIBUTE_GROUPS(uv_hub);180 181static void hub_release(struct kobject *kobj)182{183 struct uv_hub *hub = to_uv_hub(kobj);184 185 kfree(hub);186}187 188static 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 203static const struct sysfs_ops hub_sysfs_ops = {204 .show = hub_type_show,205};206 207static 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 213static 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 272err_hubs:273 for (; i >= 0; i--)274 kobject_put(&uv_hubs[i]->kobj);275 kfree(uv_hubs);276err_enum_objs:277 kfree(hub_buf);278err_hub_buf:279 kset_unregister(uv_hubs_kset);280err_hubs_kset:281 kfree(prev_obj_to_cnode);282 return ret;283 284}285 286static 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 299struct 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 306static 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 311static 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 316struct 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 322static struct uv_port_sysfs_entry uv_port_conn_hub_attribute =323 __ATTR(conn_hub, 0444, uv_port_conn_hub_show, NULL);324static struct uv_port_sysfs_entry uv_port_conn_port_attribute =325 __ATTR(conn_port, 0444, uv_port_conn_port_show, NULL);326 327static struct attribute *uv_port_attrs[] = {328 &uv_port_conn_hub_attribute.attr,329 &uv_port_conn_port_attribute.attr,330 NULL,331};332ATTRIBUTE_GROUPS(uv_port);333 334static void uv_port_release(struct kobject *kobj)335{336 struct uv_port *port = to_uv_port(kobj);337 338 kfree(port);339}340 341static 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 356static const struct sysfs_ops uv_port_sysfs_ops = {357 .show = uv_port_type_show,358};359 360static 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 366static 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 417err_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;425err_ports:426 for (; j >= 0; j--)427 kfree(uv_hubs[j]->ports);428 j = uv_bios_obj_cnt - 1;429err_port_info:430 for (; j >= 0; j--)431 kfree(port_buf[j]);432 kfree(port_buf);433 return ret;434}435 436static 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 451struct 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 462static 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 467static 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 472static 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 477static 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 482static 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 487struct 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 493static struct uv_pci_top_sysfs_entry uv_pci_type_attribute =494 __ATTR(type, 0444, uv_pci_type_show, NULL);495static struct uv_pci_top_sysfs_entry uv_pci_location_attribute =496 __ATTR(location, 0444, uv_pci_location_show, NULL);497static struct uv_pci_top_sysfs_entry uv_pci_iio_stack_attribute =498 __ATTR(iio_stack, 0444, uv_pci_iio_stack_show, NULL);499static struct uv_pci_top_sysfs_entry uv_pci_ppb_addr_attribute =500 __ATTR(ppb_addr, 0444, uv_pci_ppb_addr_show, NULL);501static struct uv_pci_top_sysfs_entry uv_pci_slot_attribute =502 __ATTR(slot, 0444, uv_pci_slot_show, NULL);503 504static 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 514static 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 528static const struct sysfs_ops uv_pci_top_sysfs_ops = {529 .show = pci_top_type_show,530};531 532static 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 537static 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 length545 if (strlen(line) < 36)546 return -EINVAL;547 548 //Line must match format "pcibus %4x:%2x" to be valid549 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 tokens560 * 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 SLOT573 * r001i01b00h0 NODE IO574 * r001i01b00h0 Riser575 * (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 } else608 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 645err_add_sysfs:646 kobject_put(&top_obj->kobj);647 return ret;648}649 650static 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;705err_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);711err_pci_top_str:712 kset_unregister(uv_pcibus_kset);713 return ret;714}715 716static 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 726static 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 732static 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 738static 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 744static 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 750static 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 756static 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 762static struct kobj_attribute partition_id_attr =763 __ATTR(partition_id, 0444, partition_id_show, NULL);764static struct kobj_attribute coherence_id_attr =765 __ATTR(coherence_id, 0444, coherence_id_show, NULL);766static struct kobj_attribute uv_type_attr =767 __ATTR(uv_type, 0444, uv_type_show, NULL);768static struct kobj_attribute uv_archtype_attr =769 __ATTR(archtype, 0444, uv_archtype_show, NULL);770static struct kobj_attribute uv_hub_type_attr =771 __ATTR(hub_type, 0444, uv_hub_type_show, NULL);772static struct kobj_attribute uv_hubless_attr =773 __ATTR(hubless, 0444, uv_hubless_show, NULL);774 775static 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 784static const struct attribute_group base_attr_group = {785 .attrs = base_attrs786};787 788static 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 821static 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 829static const struct attribute_group hubless_base_attr_group = {830 .attrs = hubless_base_attrs831};832 833 834static 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 846static 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 889err_pci_init:890 uv_ports_exit();891err_ports_init:892 uv_hubs_exit();893err_hubs_init:894 vfree(uv_biosheap);895err_bios_setup:896 sysfs_remove_group(sgi_uv_kobj, &base_attr_group);897err_create_group:898 kobject_put(sgi_uv_kobj);899 return ret;900}901 902static 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 908static 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 MODULE925device_initcall(uv_sysfs_init);926#else927module_init(uv_sysfs_init);928#endif929module_exit(uv_sysfs_exit);930 931MODULE_AUTHOR("Hewlett Packard Enterprise");932MODULE_DESCRIPTION("Sysfs structure for HPE UV systems");933MODULE_LICENSE("GPL");934