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
21struct kobject *sgi_uv_kobj;
22static struct kset *uv_pcibus_kset;
23static struct kset *uv_hubs_kset;
24static struct uv_bios_hub_info *hub_buf;
25static struct uv_bios_port_info **port_buf;
26static struct uv_hub **uv_hubs;
27static struct uv_pci_top_obj **uv_pci_objs;
28static int num_pci_lines;
29static int num_cnodes;
30static int *prev_obj_to_cnode;
31static int uv_bios_obj_cnt;
32static signed short uv_master_nasid = -1;
33static void *uv_biosheap;
34
35static 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
53static 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
61static union geoid_u cnode_to_geoid(int cnode)
62{
63 union geoid_u geoid;
64
65 uv_bios_get_geoinfo(nasid: ordinal_to_nasid(ordinal: cnode), sz: (u64)sizeof(union geoid_u), geo: (u64 *)&geoid);
66 return geoid;
67}
68
69static 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
82static 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(location: obj->location, rack: &obj_rack, slot: &obj_slot, blade: &obj_blade))
93 return -1;
94
95 for (cnode = 0; cnode < num_cnodes; cnode++) {
96 geoid = cnode_to_geoid(cnode);
97 rack = geo_rack(g: geoid);
98 slot = geo_slot(g: geoid);
99 blade = geo_blade(g: 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
107static int get_obj_to_cnode(int obj_id)
108{
109 return prev_obj_to_cnode[obj_id];
110}
111
112struct 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
120static ssize_t hub_name_show(struct uv_bios_hub_info *hub_info, char *buf)
121{
122 return sysfs_emit(buf, fmt: "%s\n", hub_info->name);
123}
124
125static ssize_t hub_location_show(struct uv_bios_hub_info *hub_info, char *buf)
126{
127 return sysfs_emit(buf, fmt: "%s\n", hub_info->location);
128}
129
130static ssize_t hub_partition_show(struct uv_bios_hub_info *hub_info, char *buf)
131{
132 return sprintf(buf, fmt: "%d\n", hub_info->f.fields.this_part);
133}
134
135static ssize_t hub_shared_show(struct uv_bios_hub_info *hub_info, char *buf)
136{
137 return sprintf(buf, fmt: "%d\n", hub_info->f.fields.is_shared);
138}
139static ssize_t hub_nasid_show(struct uv_bios_hub_info *hub_info, char *buf)
140{
141 int cnode = get_obj_to_cnode(obj_id: hub_info->id);
142
143 return sprintf(buf, fmt: "%d\n", ordinal_to_nasid(ordinal: cnode));
144}
145static ssize_t hub_cnode_show(struct uv_bios_hub_info *hub_info, char *buf)
146{
147 return sprintf(buf, fmt: "%d\n", get_obj_to_cnode(obj_id: hub_info->id));
148}
149
150struct 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
156static struct hub_sysfs_entry name_attribute =
157 __ATTR(name, 0444, hub_name_show, NULL);
158static struct hub_sysfs_entry location_attribute =
159 __ATTR(location, 0444, hub_location_show, NULL);
160static struct hub_sysfs_entry partition_attribute =
161 __ATTR(this_partition, 0444, hub_partition_show, NULL);
162static struct hub_sysfs_entry shared_attribute =
163 __ATTR(shared, 0444, hub_shared_show, NULL);
164static struct hub_sysfs_entry nasid_attribute =
165 __ATTR(nasid, 0444, hub_nasid_show, NULL);
166static struct hub_sysfs_entry cnode_attribute =
167 __ATTR(cnode, 0444, hub_cnode_show, NULL);
168
169static 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};
178ATTRIBUTE_GROUPS(uv_hub);
179
180static void hub_release(struct kobject *kobj)
181{
182 struct uv_hub *hub = to_uv_hub(kobj);
183
184 kfree(objp: hub);
185}
186
187static 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
202static const struct sysfs_ops hub_sysfs_ops = {
203 .show = hub_type_show,
204};
205
206static const struct kobj_type hub_attr_type = {
207 .release = hub_release,
208 .sysfs_ops = &hub_sysfs_ops,
209 .default_groups = uv_hub_groups,
210};
211
212static int uv_hubs_init(void)
213{
214 s64 biosr;
215 u64 sz;
216 int i, ret;
217
218 prev_obj_to_cnode = kmalloc_array(n: uv_bios_obj_cnt, size: 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(name: "hubs", NULL, parent_kobj: 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(size: sz, GFP_KERNEL);
233 if (!hub_buf) {
234 ret = -ENOMEM;
235 goto err_hub_buf;
236 }
237
238 biosr = uv_bios_enum_objs(nasid: (u64)uv_master_nasid, sz, objbuf: (u64 *)hub_buf);
239 if (biosr) {
240 ret = -EINVAL;
241 goto err_enum_objs;
242 }
243
244 uv_hubs = kcalloc(n: uv_bios_obj_cnt, size: 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(size: 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(obj: uv_hubs[i]->hub_info);
260
261 uv_hubs[i]->kobj.kset = uv_hubs_kset;
262
263 ret = kobject_init_and_add(kobj: &uv_hubs[i]->kobj, ktype: &hub_attr_type,
264 NULL, fmt: "hub_%u", hub_buf[i].id);
265 if (ret)
266 goto err_hubs;
267 kobject_uevent(kobj: &uv_hubs[i]->kobj, action: KOBJ_ADD);
268 }
269 return 0;
270
271err_hubs:
272 for (; i >= 0; i--)
273 kobject_put(kobj: &uv_hubs[i]->kobj);
274 kfree(objp: uv_hubs);
275err_enum_objs:
276 kfree(objp: hub_buf);
277err_hub_buf:
278 kset_unregister(kset: uv_hubs_kset);
279err_hubs_kset:
280 kfree(objp: prev_obj_to_cnode);
281 return ret;
282
283}
284
285static void uv_hubs_exit(void)
286{
287 int i;
288
289 for (i = 0; i < uv_bios_obj_cnt; i++)
290 kobject_put(kobj: &uv_hubs[i]->kobj);
291
292 kfree(objp: uv_hubs);
293 kfree(objp: hub_buf);
294 kset_unregister(kset: uv_hubs_kset);
295 kfree(objp: prev_obj_to_cnode);
296}
297
298struct 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
305static ssize_t uv_port_conn_hub_show(struct uv_bios_port_info *port, char *buf)
306{
307 return sprintf(buf, fmt: "%d\n", port->conn_id);
308}
309
310static ssize_t uv_port_conn_port_show(struct uv_bios_port_info *port, char *buf)
311{
312 return sprintf(buf, fmt: "%d\n", port->conn_port);
313}
314
315struct 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
321static struct uv_port_sysfs_entry uv_port_conn_hub_attribute =
322 __ATTR(conn_hub, 0444, uv_port_conn_hub_show, NULL);
323static struct uv_port_sysfs_entry uv_port_conn_port_attribute =
324 __ATTR(conn_port, 0444, uv_port_conn_port_show, NULL);
325
326static struct attribute *uv_port_attrs[] = {
327 &uv_port_conn_hub_attribute.attr,
328 &uv_port_conn_port_attribute.attr,
329 NULL,
330};
331ATTRIBUTE_GROUPS(uv_port);
332
333static void uv_port_release(struct kobject *kobj)
334{
335 struct uv_port *port = to_uv_port(kobj);
336
337 kfree(objp: port);
338}
339
340static 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
355static const struct sysfs_ops uv_port_sysfs_ops = {
356 .show = uv_port_type_show,
357};
358
359static const 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
365static int uv_ports_init(void)
366{
367 s64 biosr;
368 int j = 0, k = 0, ret, sz;
369
370 port_buf = kcalloc(n: uv_bios_obj_cnt, size: 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(size: 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(nasid: (u64)uv_master_nasid, obj_id: (u64)hub_buf[j].id, sz,
383 portbuf: (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(n: hub_buf[j].ports,
391 size: 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(size: 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(kobj: &uv_hubs[j]->ports[k]->kobj, ktype: &uv_port_attr_type,
408 parent: &uv_hubs[j]->kobj, fmt: "port_%d", port_buf[j][k].port);
409 if (ret)
410 goto err_kobj_ports;
411 kobject_uevent(kobj: &uv_hubs[j]->ports[k]->kobj, action: KOBJ_ADD);
412 }
413 }
414 return 0;
415
416err_kobj_ports:
417 for (; j >= 0; j--) {
418 for (; k >= 0; k--)
419 kobject_put(kobj: &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;
424err_ports:
425 for (; j >= 0; j--)
426 kfree(objp: uv_hubs[j]->ports);
427 j = uv_bios_obj_cnt - 1;
428err_port_info:
429 for (; j >= 0; j--)
430 kfree(objp: port_buf[j]);
431 kfree(objp: port_buf);
432 return ret;
433}
434
435static 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(kobj: &uv_hubs[j]->ports[k]->kobj);
442 }
443 for (j = 0; j < uv_bios_obj_cnt; j++) {
444 kfree(objp: uv_hubs[j]->ports);
445 kfree(objp: port_buf[j]);
446 }
447 kfree(objp: port_buf);
448}
449
450struct 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
461static ssize_t uv_pci_type_show(struct uv_pci_top_obj *top_obj, char *buf)
462{
463 return sysfs_emit(buf, fmt: "%s\n", top_obj->type);
464}
465
466static ssize_t uv_pci_location_show(struct uv_pci_top_obj *top_obj, char *buf)
467{
468 return sysfs_emit(buf, fmt: "%s\n", top_obj->location);
469}
470
471static ssize_t uv_pci_iio_stack_show(struct uv_pci_top_obj *top_obj, char *buf)
472{
473 return sprintf(buf, fmt: "%d\n", top_obj->iio_stack);
474}
475
476static ssize_t uv_pci_ppb_addr_show(struct uv_pci_top_obj *top_obj, char *buf)
477{
478 return sysfs_emit(buf, fmt: "%s\n", top_obj->ppb_addr);
479}
480
481static ssize_t uv_pci_slot_show(struct uv_pci_top_obj *top_obj, char *buf)
482{
483 return sprintf(buf, fmt: "%d\n", top_obj->slot);
484}
485
486struct 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
492static struct uv_pci_top_sysfs_entry uv_pci_type_attribute =
493 __ATTR(type, 0444, uv_pci_type_show, NULL);
494static struct uv_pci_top_sysfs_entry uv_pci_location_attribute =
495 __ATTR(location, 0444, uv_pci_location_show, NULL);
496static struct uv_pci_top_sysfs_entry uv_pci_iio_stack_attribute =
497 __ATTR(iio_stack, 0444, uv_pci_iio_stack_show, NULL);
498static struct uv_pci_top_sysfs_entry uv_pci_ppb_addr_attribute =
499 __ATTR(ppb_addr, 0444, uv_pci_ppb_addr_show, NULL);
500static struct uv_pci_top_sysfs_entry uv_pci_slot_attribute =
501 __ATTR(slot, 0444, uv_pci_slot_show, NULL);
502
503static 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(objp: top_obj->type);
508 kfree(objp: top_obj->location);
509 kfree(objp: top_obj->ppb_addr);
510 kfree(objp: top_obj);
511}
512
513static 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
527static const struct sysfs_ops uv_pci_top_sysfs_ops = {
528 .show = pci_top_type_show,
529};
530
531static const struct kobj_type uv_pci_top_attr_type = {
532 .release = uv_pci_top_release,
533 .sysfs_ops = &uv_pci_top_sysfs_ops,
534};
535
536static 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(s: type, GFP_KERNEL);
582 if (!top_obj->type)
583 return -ENOMEM;
584 top_obj->location = kstrdup(s: location, GFP_KERNEL);
585 if (!top_obj->location) {
586 kfree(objp: 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(s: type, GFP_KERNEL);
599 if (!top_obj->type)
600 return -ENOMEM;
601 top_obj->ppb_addr = kstrdup(s: ppb_addr, GFP_KERNEL);
602 if (!top_obj->ppb_addr) {
603 kfree(objp: 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(kobj: &top_obj->kobj, ktype: &uv_pci_top_attr_type, NULL, fmt: "%s", line);
612 if (ret)
613 goto err_add_sysfs;
614
615 if (top_obj->type) {
616 ret = sysfs_create_file(kobj: &top_obj->kobj, attr: &uv_pci_type_attribute.attr);
617 if (ret)
618 goto err_add_sysfs;
619 }
620 if (top_obj->location) {
621 ret = sysfs_create_file(kobj: &top_obj->kobj, attr: &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(kobj: &top_obj->kobj, attr: &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(kobj: &top_obj->kobj, attr: &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(kobj: &top_obj->kobj, attr: &uv_pci_slot_attribute.attr);
637 if (ret)
638 goto err_add_sysfs;
639 }
640
641 kobject_uevent(kobj: &top_obj->kobj, action: KOBJ_ADD);
642 return 0;
643
644err_add_sysfs:
645 kobject_put(kobj: &top_obj->kobj);
646 return ret;
647}
648
649static 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(name: "pcibuses", NULL, parent_kobj: 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(size: 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(sz: (u64)sz, buf: (u64 *)pci_top_str);
668 if (biosr == BIOS_STATUS_SUCCESS) {
669 len = strnlen(p: pci_top_str, maxlen: 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(n: num_pci_lines,
677 size: sizeof(*uv_pci_objs), GFP_KERNEL);
678 if (!uv_pci_objs) {
679 kfree(objp: 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(size: 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(top_obj: uv_pci_objs[k], line: found);
691 if (ret)
692 goto err_pci_obj;
693 k++;
694 if (k == num_pci_lines)
695 break;
696 }
697 }
698 kfree(objp: pci_top_str);
699 if (biosr == BIOS_STATUS_SUCCESS || biosr == BIOS_STATUS_UNIMPLEMENTED)
700 break;
701 }
702
703 return 0;
704err_pci_obj:
705 k--;
706 for (; k >= 0; k--)
707 kobject_put(kobj: &uv_pci_objs[k]->kobj);
708 kfree(objp: uv_pci_objs);
709 kfree(objp: pci_top_str);
710err_pci_top_str:
711 kset_unregister(kset: uv_pcibus_kset);
712 return ret;
713}
714
715static void pci_topology_exit(void)
716{
717 int k;
718
719 for (k = 0; k < num_pci_lines; k++)
720 kobject_put(kobj: &uv_pci_objs[k]->kobj);
721 kset_unregister(kset: uv_pcibus_kset);
722 kfree(objp: uv_pci_objs);
723}
724
725static ssize_t partition_id_show(struct kobject *kobj,
726 struct kobj_attribute *attr, char *buf)
727{
728 return sprintf(buf, fmt: "%ld\n", sn_partition_id);
729}
730
731static ssize_t coherence_id_show(struct kobject *kobj,
732 struct kobj_attribute *attr, char *buf)
733{
734 return sprintf(buf, fmt: "%ld\n", sn_coherency_id);
735}
736
737static ssize_t uv_type_show(struct kobject *kobj,
738 struct kobj_attribute *attr, char *buf)
739{
740 return sysfs_emit(buf, fmt: "%s\n", uv_type_string());
741}
742
743static 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
749static ssize_t uv_hub_type_show(struct kobject *kobj,
750 struct kobj_attribute *attr, char *buf)
751{
752 return sysfs_emit(buf, fmt: "0x%x\n", uv_hub_type());
753}
754
755static ssize_t uv_hubless_show(struct kobject *kobj,
756 struct kobj_attribute *attr, char *buf)
757{
758 return sysfs_emit(buf, fmt: "0x%x\n", uv_get_hubless_system());
759}
760
761static struct kobj_attribute partition_id_attr =
762 __ATTR(partition_id, 0444, partition_id_show, NULL);
763static struct kobj_attribute coherence_id_attr =
764 __ATTR(coherence_id, 0444, coherence_id_show, NULL);
765static struct kobj_attribute uv_type_attr =
766 __ATTR(uv_type, 0444, uv_type_show, NULL);
767static struct kobj_attribute uv_archtype_attr =
768 __ATTR(archtype, 0444, uv_archtype_show, NULL);
769static struct kobj_attribute uv_hub_type_attr =
770 __ATTR(hub_type, 0444, uv_hub_type_show, NULL);
771static struct kobj_attribute uv_hubless_attr =
772 __ATTR(hubless, 0444, uv_hubless_show, NULL);
773
774static 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
783static const struct attribute_group base_attr_group = {
784 .attrs = base_attrs
785};
786
787static int initial_bios_setup(void)
788{
789 u64 v;
790 s64 biosr;
791
792 biosr = uv_bios_get_master_nasid(sz: (u64)sizeof(uv_master_nasid), nasid: (u64 *)&uv_master_nasid);
793 if (biosr)
794 return -EINVAL;
795
796 biosr = uv_bios_get_heapsize(nasid: (u64)uv_master_nasid, sz: (u64)sizeof(u64), heap_sz: &v);
797 if (biosr)
798 return -EINVAL;
799
800 uv_biosheap = vmalloc(size: v);
801 if (!uv_biosheap)
802 return -ENOMEM;
803
804 biosr = uv_bios_install_heap(nasid: (u64)uv_master_nasid, sz: v, heap: (u64 *)uv_biosheap);
805 if (biosr) {
806 vfree(addr: uv_biosheap);
807 return -EINVAL;
808 }
809
810 biosr = uv_bios_obj_count(nasid: (u64)uv_master_nasid, sz: sizeof(u64), objcnt: &v);
811 if (biosr) {
812 vfree(addr: uv_biosheap);
813 return -EINVAL;
814 }
815 uv_bios_obj_cnt = (int)v;
816
817 return 0;
818}
819
820static 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
828static const struct attribute_group hubless_base_attr_group = {
829 .attrs = hubless_base_attrs
830};
831
832
833static int __init uv_sysfs_hubless_init(void)
834{
835 int ret;
836
837 ret = sysfs_create_group(kobj: sgi_uv_kobj, grp: &hubless_base_attr_group);
838 if (ret) {
839 pr_warn("sysfs_create_group hubless_base_attr_group failed\n");
840 kobject_put(kobj: sgi_uv_kobj);
841 }
842 return ret;
843}
844
845static 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(name: "sgi_uv", parent: 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(kobj: sgi_uv_kobj, grp: &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
888err_pci_init:
889 uv_ports_exit();
890err_ports_init:
891 uv_hubs_exit();
892err_hubs_init:
893 vfree(addr: uv_biosheap);
894err_bios_setup:
895 sysfs_remove_group(kobj: sgi_uv_kobj, grp: &base_attr_group);
896err_create_group:
897 kobject_put(kobj: sgi_uv_kobj);
898 return ret;
899}
900
901static void __exit uv_sysfs_hubless_exit(void)
902{
903 sysfs_remove_group(kobj: sgi_uv_kobj, grp: &hubless_base_attr_group);
904 kobject_put(kobj: sgi_uv_kobj);
905}
906
907static 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(addr: uv_biosheap);
919 sysfs_remove_group(kobj: sgi_uv_kobj, grp: &base_attr_group);
920 kobject_put(kobj: sgi_uv_kobj);
921}
922
923#ifndef MODULE
924device_initcall(uv_sysfs_init);
925#else
926module_init(uv_sysfs_init);
927#endif
928module_exit(uv_sysfs_exit);
929
930MODULE_AUTHOR("Hewlett Packard Enterprise");
931MODULE_LICENSE("GPL");
932

source code of linux/drivers/platform/x86/uv_sysfs.c