drivers/platform/x86/uv_sysfs.c

   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_DESCRIPTION("Sysfs structure for HPE UV systems");
 933 MODULE_LICENSE("GPL");