Loading...
Note: File does not exist in v4.6.
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
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 else
51 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 else
59 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 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
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_attrs
786};
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_attrs
831};
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 MODULE
925device_initcall(uv_sysfs_init);
926#else
927module_init(uv_sysfs_init);
928#endif
929module_exit(uv_sysfs_exit);
930
931MODULE_AUTHOR("Hewlett Packard Enterprise");
932MODULE_DESCRIPTION("Sysfs structure for HPE UV systems");
933MODULE_LICENSE("GPL");