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 <asm/uv/bios.h>
  15 #include <asm/uv/uv.h>
  16 #include <asm/uv/uv_hub.h>
  17 #include <asm/uv/uv_geo.h>
  18
  19 #define INVALID_CNODE -1
  20
  21 struct kobject *sgi_uv_kobj;
  22 static struct kset *uv_pcibus_kset;
  23 static struct kset *uv_hubs_kset;
  24 static struct uv_bios_hub_info *hub_buf;
  25 static struct uv_bios_port_info **port_buf;
  26 static struct uv_hub **uv_hubs;
  27 static struct uv_pci_top_obj **uv_pci_objs;
  28 static int num_pci_lines;
  29 static int num_cnodes;
  30 static int *prev_obj_to_cnode;
  31 static int uv_bios_obj_cnt;
  32 static signed short uv_master_nasid = -1;
  33 static void *uv_biosheap;
  34
  35 static const char *uv_type_string(void)
  36 {
  37         if (is_uv5_hub())
  38                 return "9.0";
  39         else if (is_uv4a_hub())
  40                 return "7.1";
  41         else if (is_uv4_hub())
  42                 return "7.0";
  43         else if (is_uv3_hub())
  44                 return "5.0";
  45         else if (is_uv2_hub())
  46                 return "3.0";
  47         else if (uv_get_hubless_system())
  48                 return "0.1";
  49         else
  50                 return "unknown";
  51 }
  52
  53 static int ordinal_to_nasid(int ordinal)
  54 {
  55         if (ordinal < num_cnodes && ordinal >= 0)
  56                 return UV_PNODE_TO_NASID(uv_blade_to_pnode(ordinal));
  57         else
  58                 return -1;
  59 }
  60
  61 static union geoid_u cnode_to_geoid(int cnode)
  62 {
  63         union geoid_u geoid;
  64
  65         uv_bios_get_geoinfo(ordinal_to_nasid(cnode), (u64)sizeof(union geoid_u), (u64 *)&geoid);
  66         return geoid;
  67 }
  68
  69 static int location_to_bpos(char *location, int *rack, int *slot, int *blade)
  70 {
  71         char type, r, b, h;
  72         int idb, idh;
  73
  74         if (sscanf(location, "%c%03d%c%02d%c%2d%c%d",
  75                          &r, rack, &type, slot, &b, &idb, &h, &idh) != 8)
  76                 return -1;
  77         *blade = idb * 2 + idh;
  78
  79         return 0;
  80 }
  81
  82 static int cache_obj_to_cnode(struct uv_bios_hub_info *obj)
  83 {
  84         int cnode;
  85         union geoid_u geoid;
  86         int obj_rack, obj_slot, obj_blade;
  87         int rack, slot, blade;
  88
  89         if (!obj->f.fields.this_part && !obj->f.fields.is_shared)
  90                 return 0;
  91
  92         if (location_to_bpos(obj->location, &obj_rack, &obj_slot, &obj_blade))
  93                 return -1;
  94
  95         for (cnode = 0; cnode < num_cnodes; cnode++) {
  96                 geoid = cnode_to_geoid(cnode);
  97                 rack = geo_rack(geoid);
  98                 slot = geo_slot(geoid);
  99                 blade = geo_blade(geoid);
 100                 if (obj_rack == rack && obj_slot == slot && obj_blade == blade)
 101                         prev_obj_to_cnode[obj->id] = cnode;
 102         }
 103
 104         return 0;
 105 }
 106
 107 static int get_obj_to_cnode(int obj_id)
 108 {
 109         return prev_obj_to_cnode[obj_id];
 110 }
 111
 112 struct uv_hub {
 113         struct kobject kobj;
 114         struct uv_bios_hub_info *hub_info;
 115         struct uv_port **ports;
 116 };
 117
 118 #define to_uv_hub(kobj_ptr) container_of(kobj_ptr, struct uv_hub, kobj)
 119
 120 static ssize_t hub_name_show(struct uv_bios_hub_info *hub_info, char *buf)
 121 {
 122         return sysfs_emit(buf, "%s\n", hub_info->name);
 123 }
 124
 125 static ssize_t hub_location_show(struct uv_bios_hub_info *hub_info, char *buf)
 126 {
 127         return sysfs_emit(buf, "%s\n", hub_info->location);
 128 }
 129
 130 static ssize_t hub_partition_show(struct uv_bios_hub_info *hub_info, char *buf)
 131 {
 132         return sprintf(buf, "%d\n", hub_info->f.fields.this_part);
 133 }
 134
 135 static ssize_t hub_shared_show(struct uv_bios_hub_info *hub_info, char *buf)
 136 {
 137         return sprintf(buf, "%d\n", hub_info->f.fields.is_shared);
 138 }
 139 static ssize_t hub_nasid_show(struct uv_bios_hub_info *hub_info, char *buf)
 140 {
 141         int cnode = get_obj_to_cnode(hub_info->id);
 142
 143         return sprintf(buf, "%d\n", ordinal_to_nasid(cnode));
 144 }
 145 static ssize_t hub_cnode_show(struct uv_bios_hub_info *hub_info, char *buf)
 146 {
 147         return sprintf(buf, "%d\n", get_obj_to_cnode(hub_info->id));
 148 }
 149
 150 struct hub_sysfs_entry {
 151         struct attribute attr;
 152         ssize_t (*show)(struct uv_bios_hub_info *hub_info, char *buf);
 153         ssize_t (*store)(struct uv_bios_hub_info *hub_info, const char *buf, size_t sz);
 154 };
 155
 156 static struct hub_sysfs_entry name_attribute =
 157         __ATTR(name, 0444, hub_name_show, NULL);
 158 static struct hub_sysfs_entry location_attribute =
 159         __ATTR(location, 0444, hub_location_show, NULL);
 160 static struct hub_sysfs_entry partition_attribute =
 161         __ATTR(this_partition, 0444, hub_partition_show, NULL);
 162 static struct hub_sysfs_entry shared_attribute =
 163         __ATTR(shared, 0444, hub_shared_show, NULL);
 164 static struct hub_sysfs_entry nasid_attribute =
 165         __ATTR(nasid, 0444, hub_nasid_show, NULL);
 166 static struct hub_sysfs_entry cnode_attribute =
 167         __ATTR(cnode, 0444, hub_cnode_show, NULL);
 168
 169 static struct attribute *uv_hub_attrs[] = {
 170         &name_attribute.attr,
 171         &location_attribute.attr,
 172         &partition_attribute.attr,
 173         &shared_attribute.attr,
 174         &nasid_attribute.attr,
 175         &cnode_attribute.attr,
 176         NULL,
 177 };
 178 ATTRIBUTE_GROUPS(uv_hub);
 179
 180 static void hub_release(struct kobject *kobj)
 181 {
 182         struct uv_hub *hub = to_uv_hub(kobj);
 183
 184         kfree(hub);
 185 }
 186
 187 static ssize_t hub_type_show(struct kobject *kobj, struct attribute *attr,
 188                                 char *buf)
 189 {
 190         struct uv_hub *hub = to_uv_hub(kobj);
 191         struct uv_bios_hub_info *bios_hub_info = hub->hub_info;
 192         struct hub_sysfs_entry *entry;
 193
 194         entry = container_of(attr, struct hub_sysfs_entry, attr);
 195
 196         if (!entry->show)
 197                 return -EIO;
 198
 199         return entry->show(bios_hub_info, buf);
 200 }
 201
 202 static const struct sysfs_ops hub_sysfs_ops = {
 203         .show = hub_type_show,
 204 };
 205
 206 static struct kobj_type hub_attr_type = {
 207         .release        = hub_release,
 208         .sysfs_ops      = &hub_sysfs_ops,
 209         .default_groups = uv_hub_groups,
 210 };
 211
 212 static int uv_hubs_init(void)
 213 {
 214         s64 biosr;
 215         u64 sz;
 216         int i, ret;
 217
 218         prev_obj_to_cnode = kmalloc_array(uv_bios_obj_cnt, sizeof(*prev_obj_to_cnode),
 219                                          GFP_KERNEL);
 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 = kcalloc(uv_bios_obj_cnt, sizeof(*uv_hubs), GFP_KERNEL);
 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(sizeof(*uv_hubs[i]), GFP_KERNEL);
 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 sprintf(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 sprintf(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 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 = kcalloc(uv_bios_obj_cnt, sizeof(*port_buf), GFP_KERNEL);
 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 = kcalloc(hub_buf[j].ports,
 391                                            sizeof(*uv_hubs[j]->ports), GFP_KERNEL);
 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(sizeof(*uv_hubs[j]->ports[k]), GFP_KERNEL);
 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 sprintf(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 sprintf(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 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 = kcalloc(num_pci_lines,
 677                                              sizeof(*uv_pci_objs), GFP_KERNEL);
 678                         if (!uv_pci_objs) {
 679                                 kfree(pci_top_str);
 680                                 ret = -ENOMEM;
 681                                 goto err_pci_top_str;
 682                         }
 683                         start = pci_top_str;
 684                         while ((found = strsep(&start, "\n")) != NULL) {
 685                                 uv_pci_objs[k] = kzalloc(sizeof(*uv_pci_objs[k]), GFP_KERNEL);
 686                                 if (!uv_pci_objs[k]) {
 687                                         ret = -ENOMEM;
 688                                         goto err_pci_obj;
 689                                 }
 690                                 ret = init_pci_top_obj(uv_pci_objs[k], found);
 691                                 if (ret)
 692                                         goto err_pci_obj;
 693                                 k++;
 694                                 if (k == num_pci_lines)
 695                                         break;
 696                         }
 697                 }
 698                 kfree(pci_top_str);
 699                 if (biosr == BIOS_STATUS_SUCCESS || biosr == BIOS_STATUS_UNIMPLEMENTED)
 700                         break;
 701         }
 702
 703         return 0;
 704 err_pci_obj:
 705         k--;
 706         for (; k >= 0; k--)
 707                 kobject_put(&uv_pci_objs[k]->kobj);
 708         kfree(uv_pci_objs);
 709         kfree(pci_top_str);
 710 err_pci_top_str:
 711         kset_unregister(uv_pcibus_kset);
 712         return ret;
 713 }
 714
 715 static void pci_topology_exit(void)
 716 {
 717         int k;
 718
 719         for (k = 0; k < num_pci_lines; k++)
 720                 kobject_put(&uv_pci_objs[k]->kobj);
 721         kset_unregister(uv_pcibus_kset);
 722         kfree(uv_pci_objs);
 723 }
 724
 725 static ssize_t partition_id_show(struct kobject *kobj,
 726                         struct kobj_attribute *attr, char *buf)
 727 {
 728         return sprintf(buf, "%ld\n", sn_partition_id);
 729 }
 730
 731 static ssize_t coherence_id_show(struct kobject *kobj,
 732                         struct kobj_attribute *attr, char *buf)
 733 {
 734         return sprintf(buf, "%ld\n", sn_coherency_id);
 735 }
 736
 737 static ssize_t uv_type_show(struct kobject *kobj,
 738                         struct kobj_attribute *attr, char *buf)
 739 {
 740         return sysfs_emit(buf, "%s\n", uv_type_string());
 741 }
 742
 743 static ssize_t uv_archtype_show(struct kobject *kobj,
 744                         struct kobj_attribute *attr, char *buf)
 745 {
 746         return uv_get_archtype(buf, PAGE_SIZE);
 747 }
 748
 749 static ssize_t uv_hub_type_show(struct kobject *kobj,
 750                         struct kobj_attribute *attr, char *buf)
 751 {
 752         return sysfs_emit(buf, "0x%x\n", uv_hub_type());
 753 }
 754
 755 static ssize_t uv_hubless_show(struct kobject *kobj,
 756                         struct kobj_attribute *attr, char *buf)
 757 {
 758         return sysfs_emit(buf, "0x%x\n", uv_get_hubless_system());
 759 }
 760
 761 static struct kobj_attribute partition_id_attr =
 762         __ATTR(partition_id, 0444, partition_id_show, NULL);
 763 static struct kobj_attribute coherence_id_attr =
 764         __ATTR(coherence_id, 0444, coherence_id_show, NULL);
 765 static struct kobj_attribute uv_type_attr =
 766         __ATTR(uv_type, 0444, uv_type_show, NULL);
 767 static struct kobj_attribute uv_archtype_attr =
 768         __ATTR(archtype, 0444, uv_archtype_show, NULL);
 769 static struct kobj_attribute uv_hub_type_attr =
 770         __ATTR(hub_type, 0444, uv_hub_type_show, NULL);
 771 static struct kobj_attribute uv_hubless_attr =
 772         __ATTR(hubless, 0444, uv_hubless_show, NULL);
 773
 774 static struct attribute *base_attrs[] = {
 775         &partition_id_attr.attr,
 776         &coherence_id_attr.attr,
 777         &uv_type_attr.attr,
 778         &uv_archtype_attr.attr,
 779         &uv_hub_type_attr.attr,
 780         NULL,
 781 };
 782
 783 static const struct attribute_group base_attr_group = {
 784         .attrs = base_attrs
 785 };
 786
 787 static int initial_bios_setup(void)
 788 {
 789         u64 v;
 790         s64 biosr;
 791
 792         biosr = uv_bios_get_master_nasid((u64)sizeof(uv_master_nasid), (u64 *)&uv_master_nasid);
 793         if (biosr)
 794                 return -EINVAL;
 795
 796         biosr = uv_bios_get_heapsize((u64)uv_master_nasid, (u64)sizeof(u64), &v);
 797         if (biosr)
 798                 return -EINVAL;
 799
 800         uv_biosheap = vmalloc(v);
 801         if (!uv_biosheap)
 802                 return -ENOMEM;
 803
 804         biosr = uv_bios_install_heap((u64)uv_master_nasid, v, (u64 *)uv_biosheap);
 805         if (biosr) {
 806                 vfree(uv_biosheap);
 807                 return -EINVAL;
 808         }
 809
 810         biosr = uv_bios_obj_count((u64)uv_master_nasid, sizeof(u64), &v);
 811         if (biosr) {
 812                 vfree(uv_biosheap);
 813                 return -EINVAL;
 814         }
 815         uv_bios_obj_cnt = (int)v;
 816
 817         return 0;
 818 }
 819
 820 static struct attribute *hubless_base_attrs[] = {
 821         &partition_id_attr.attr,
 822         &uv_type_attr.attr,
 823         &uv_archtype_attr.attr,
 824         &uv_hubless_attr.attr,
 825         NULL,
 826 };
 827
 828 static const struct attribute_group hubless_base_attr_group = {
 829         .attrs = hubless_base_attrs
 830 };
 831
 832
 833 static int __init uv_sysfs_hubless_init(void)
 834 {
 835         int ret;
 836
 837         ret = sysfs_create_group(sgi_uv_kobj, &hubless_base_attr_group);
 838         if (ret) {
 839                 pr_warn("sysfs_create_group hubless_base_attr_group failed\n");
 840                 kobject_put(sgi_uv_kobj);
 841         }
 842         return ret;
 843 }
 844
 845 static int __init uv_sysfs_init(void)
 846 {
 847         int ret = 0;
 848
 849         if (!is_uv_system() && !uv_get_hubless_system())
 850                 return -ENODEV;
 851
 852         num_cnodes = uv_num_possible_blades();
 853
 854         if (!sgi_uv_kobj)
 855                 sgi_uv_kobj = kobject_create_and_add("sgi_uv", firmware_kobj);
 856         if (!sgi_uv_kobj) {
 857                 pr_warn("kobject_create_and_add sgi_uv failed\n");
 858                 return -EINVAL;
 859         }
 860
 861         if (uv_get_hubless_system())
 862                 return uv_sysfs_hubless_init();
 863
 864         ret = sysfs_create_group(sgi_uv_kobj, &base_attr_group);
 865         if (ret) {
 866                 pr_warn("sysfs_create_group base_attr_group failed\n");
 867                 goto err_create_group;
 868         }
 869
 870         ret = initial_bios_setup();
 871         if (ret)
 872                 goto err_bios_setup;
 873
 874         ret = uv_hubs_init();
 875         if (ret)
 876                 goto err_hubs_init;
 877
 878         ret = uv_ports_init();
 879         if (ret)
 880                 goto err_ports_init;
 881
 882         ret = pci_topology_init();
 883         if (ret)
 884                 goto err_pci_init;
 885
 886         return 0;
 887
 888 err_pci_init:
 889         uv_ports_exit();
 890 err_ports_init:
 891         uv_hubs_exit();
 892 err_hubs_init:
 893         vfree(uv_biosheap);
 894 err_bios_setup:
 895         sysfs_remove_group(sgi_uv_kobj, &base_attr_group);
 896 err_create_group:
 897         kobject_put(sgi_uv_kobj);
 898         return ret;
 899 }
 900
 901 static void __exit uv_sysfs_hubless_exit(void)
 902 {
 903         sysfs_remove_group(sgi_uv_kobj, &hubless_base_attr_group);
 904         kobject_put(sgi_uv_kobj);
 905 }
 906
 907 static void __exit uv_sysfs_exit(void)
 908 {
 909         if (!is_uv_system()) {
 910                 if (uv_get_hubless_system())
 911                         uv_sysfs_hubless_exit();
 912                 return;
 913         }
 914
 915         pci_topology_exit();
 916         uv_ports_exit();
 917         uv_hubs_exit();
 918         vfree(uv_biosheap);
 919         sysfs_remove_group(sgi_uv_kobj, &base_attr_group);
 920         kobject_put(sgi_uv_kobj);
 921 }
 922
 923 #ifndef MODULE
 924 device_initcall(uv_sysfs_init);
 925 #else
 926 module_init(uv_sysfs_init);
 927 #endif
 928 module_exit(uv_sysfs_exit);
 929
 930 MODULE_AUTHOR("Hewlett Packard Enterprise");
 931 MODULE_LICENSE("GPL");