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
uv_type_string(void)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
ordinal_to_nasid(int ordinal)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
cnode_to_geoid(int cnode)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
location_to_bpos(char * location,int * rack,int * slot,int * blade)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
cache_obj_to_cnode(struct uv_bios_hub_info * obj)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
get_obj_to_cnode(int obj_id)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
hub_name_show(struct uv_bios_hub_info * hub_info,char * buf)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
hub_location_show(struct uv_bios_hub_info * hub_info,char * buf)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
hub_partition_show(struct uv_bios_hub_info * hub_info,char * buf)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
hub_shared_show(struct uv_bios_hub_info * hub_info,char * buf)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 }
hub_nasid_show(struct uv_bios_hub_info * hub_info,char * buf)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 }
hub_cnode_show(struct uv_bios_hub_info * hub_info,char * buf)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
hub_release(struct kobject * kobj)181 static void hub_release(struct kobject *kobj)
182 {
183 struct uv_hub *hub = to_uv_hub(kobj);
184
185 kfree(hub);
186 }
187
hub_type_show(struct kobject * kobj,struct attribute * attr,char * buf)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
uv_hubs_init(void)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_objs(*prev_obj_to_cnode, uv_bios_obj_cnt);
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 = kzalloc_objs(*uv_hubs, uv_bios_obj_cnt);
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_obj(*uv_hubs[i]);
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
uv_hubs_exit(void)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
uv_port_conn_hub_show(struct uv_bios_port_info * port,char * buf)305 static ssize_t uv_port_conn_hub_show(struct uv_bios_port_info *port, char *buf)
306 {
307 return sysfs_emit(buf, "%d\n", port->conn_id);
308 }
309
uv_port_conn_port_show(struct uv_bios_port_info * port,char * buf)310 static ssize_t uv_port_conn_port_show(struct uv_bios_port_info *port, char *buf)
311 {
312 return sysfs_emit(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
uv_port_release(struct kobject * kobj)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
uv_port_type_show(struct kobject * kobj,struct attribute * attr,char * buf)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 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
uv_ports_init(void)365 static int uv_ports_init(void)
366 {
367 s64 biosr;
368 int j = 0, k = 0, ret, sz;
369
370 port_buf = kzalloc_objs(*port_buf, uv_bios_obj_cnt);
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 = kzalloc_objs(*uv_hubs[j]->ports,
391 hub_buf[j].ports);
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_obj(*uv_hubs[j]->ports[k]);
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
uv_ports_exit(void)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
uv_pci_type_show(struct uv_pci_top_obj * top_obj,char * buf)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
uv_pci_location_show(struct uv_pci_top_obj * top_obj,char * buf)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
uv_pci_iio_stack_show(struct uv_pci_top_obj * top_obj,char * buf)471 static ssize_t uv_pci_iio_stack_show(struct uv_pci_top_obj *top_obj, char *buf)
472 {
473 return sysfs_emit(buf, "%d\n", top_obj->iio_stack);
474 }
475
uv_pci_ppb_addr_show(struct uv_pci_top_obj * top_obj,char * buf)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
uv_pci_slot_show(struct uv_pci_top_obj * top_obj,char * buf)481 static ssize_t uv_pci_slot_show(struct uv_pci_top_obj *top_obj, char *buf)
482 {
483 return sysfs_emit(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
uv_pci_top_release(struct kobject * kobj)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
pci_top_type_show(struct kobject * kobj,struct attribute * attr,char * buf)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 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
init_pci_top_obj(struct uv_pci_top_obj * top_obj,char * line)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
pci_topology_init(void)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 = kzalloc_objs(*uv_pci_objs, num_pci_lines);
677 if (!uv_pci_objs) {
678 kfree(pci_top_str);
679 ret = -ENOMEM;
680 goto err_pci_top_str;
681 }
682 start = pci_top_str;
683 while ((found = strsep(&start, "\n")) != NULL) {
684 uv_pci_objs[k] = kzalloc_obj(*uv_pci_objs[k]);
685 if (!uv_pci_objs[k]) {
686 ret = -ENOMEM;
687 goto err_pci_obj;
688 }
689 ret = init_pci_top_obj(uv_pci_objs[k], found);
690 if (ret)
691 goto err_pci_obj;
692 k++;
693 if (k == num_pci_lines)
694 break;
695 }
696 }
697 kfree(pci_top_str);
698 if (biosr == BIOS_STATUS_SUCCESS || biosr == BIOS_STATUS_UNIMPLEMENTED)
699 break;
700 }
701
702 return 0;
703 err_pci_obj:
704 k--;
705 for (; k >= 0; k--)
706 kobject_put(&uv_pci_objs[k]->kobj);
707 kfree(uv_pci_objs);
708 kfree(pci_top_str);
709 err_pci_top_str:
710 kset_unregister(uv_pcibus_kset);
711 return ret;
712 }
713
pci_topology_exit(void)714 static void pci_topology_exit(void)
715 {
716 int k;
717
718 for (k = 0; k < num_pci_lines; k++)
719 kobject_put(&uv_pci_objs[k]->kobj);
720 kset_unregister(uv_pcibus_kset);
721 kfree(uv_pci_objs);
722 }
723
partition_id_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)724 static ssize_t partition_id_show(struct kobject *kobj,
725 struct kobj_attribute *attr, char *buf)
726 {
727 return sysfs_emit(buf, "%ld\n", sn_partition_id);
728 }
729
coherence_id_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)730 static ssize_t coherence_id_show(struct kobject *kobj,
731 struct kobj_attribute *attr, char *buf)
732 {
733 return sysfs_emit(buf, "%ld\n", sn_coherency_id);
734 }
735
uv_type_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)736 static ssize_t uv_type_show(struct kobject *kobj,
737 struct kobj_attribute *attr, char *buf)
738 {
739 return sysfs_emit(buf, "%s\n", uv_type_string());
740 }
741
uv_archtype_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)742 static ssize_t uv_archtype_show(struct kobject *kobj,
743 struct kobj_attribute *attr, char *buf)
744 {
745 return uv_get_archtype(buf, PAGE_SIZE);
746 }
747
uv_hub_type_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)748 static ssize_t uv_hub_type_show(struct kobject *kobj,
749 struct kobj_attribute *attr, char *buf)
750 {
751 return sysfs_emit(buf, "0x%x\n", uv_hub_type());
752 }
753
uv_hubless_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)754 static ssize_t uv_hubless_show(struct kobject *kobj,
755 struct kobj_attribute *attr, char *buf)
756 {
757 return sysfs_emit(buf, "0x%x\n", uv_get_hubless_system());
758 }
759
760 static struct kobj_attribute partition_id_attr =
761 __ATTR(partition_id, 0444, partition_id_show, NULL);
762 static struct kobj_attribute coherence_id_attr =
763 __ATTR(coherence_id, 0444, coherence_id_show, NULL);
764 static struct kobj_attribute uv_type_attr =
765 __ATTR(uv_type, 0444, uv_type_show, NULL);
766 static struct kobj_attribute uv_archtype_attr =
767 __ATTR(archtype, 0444, uv_archtype_show, NULL);
768 static struct kobj_attribute uv_hub_type_attr =
769 __ATTR(hub_type, 0444, uv_hub_type_show, NULL);
770 static struct kobj_attribute uv_hubless_attr =
771 __ATTR(hubless, 0444, uv_hubless_show, NULL);
772
773 static struct attribute *base_attrs[] = {
774 &partition_id_attr.attr,
775 &coherence_id_attr.attr,
776 &uv_type_attr.attr,
777 &uv_archtype_attr.attr,
778 &uv_hub_type_attr.attr,
779 NULL,
780 };
781
782 static const struct attribute_group base_attr_group = {
783 .attrs = base_attrs
784 };
785
initial_bios_setup(void)786 static int initial_bios_setup(void)
787 {
788 u64 v;
789 s64 biosr;
790
791 biosr = uv_bios_get_master_nasid((u64)sizeof(uv_master_nasid), (u64 *)&uv_master_nasid);
792 if (biosr)
793 return -EINVAL;
794
795 biosr = uv_bios_get_heapsize((u64)uv_master_nasid, (u64)sizeof(u64), &v);
796 if (biosr)
797 return -EINVAL;
798
799 uv_biosheap = vmalloc(v);
800 if (!uv_biosheap)
801 return -ENOMEM;
802
803 biosr = uv_bios_install_heap((u64)uv_master_nasid, v, (u64 *)uv_biosheap);
804 if (biosr) {
805 vfree(uv_biosheap);
806 return -EINVAL;
807 }
808
809 biosr = uv_bios_obj_count((u64)uv_master_nasid, sizeof(u64), &v);
810 if (biosr) {
811 vfree(uv_biosheap);
812 return -EINVAL;
813 }
814 uv_bios_obj_cnt = (int)v;
815
816 return 0;
817 }
818
819 static struct attribute *hubless_base_attrs[] = {
820 &partition_id_attr.attr,
821 &uv_type_attr.attr,
822 &uv_archtype_attr.attr,
823 &uv_hubless_attr.attr,
824 NULL,
825 };
826
827 static const struct attribute_group hubless_base_attr_group = {
828 .attrs = hubless_base_attrs
829 };
830
831
uv_sysfs_hubless_init(void)832 static int __init uv_sysfs_hubless_init(void)
833 {
834 int ret;
835
836 ret = sysfs_create_group(sgi_uv_kobj, &hubless_base_attr_group);
837 if (ret) {
838 pr_warn("sysfs_create_group hubless_base_attr_group failed\n");
839 kobject_put(sgi_uv_kobj);
840 }
841 return ret;
842 }
843
uv_sysfs_init(void)844 static int __init uv_sysfs_init(void)
845 {
846 int ret = 0;
847
848 if (!is_uv_system() && !uv_get_hubless_system())
849 return -ENODEV;
850
851 num_cnodes = uv_num_possible_blades();
852
853 if (!sgi_uv_kobj)
854 sgi_uv_kobj = kobject_create_and_add("sgi_uv", firmware_kobj);
855 if (!sgi_uv_kobj) {
856 pr_warn("kobject_create_and_add sgi_uv failed\n");
857 return -EINVAL;
858 }
859
860 if (uv_get_hubless_system())
861 return uv_sysfs_hubless_init();
862
863 ret = sysfs_create_group(sgi_uv_kobj, &base_attr_group);
864 if (ret) {
865 pr_warn("sysfs_create_group base_attr_group failed\n");
866 goto err_create_group;
867 }
868
869 ret = initial_bios_setup();
870 if (ret)
871 goto err_bios_setup;
872
873 ret = uv_hubs_init();
874 if (ret)
875 goto err_hubs_init;
876
877 ret = uv_ports_init();
878 if (ret)
879 goto err_ports_init;
880
881 ret = pci_topology_init();
882 if (ret)
883 goto err_pci_init;
884
885 return 0;
886
887 err_pci_init:
888 uv_ports_exit();
889 err_ports_init:
890 uv_hubs_exit();
891 err_hubs_init:
892 vfree(uv_biosheap);
893 err_bios_setup:
894 sysfs_remove_group(sgi_uv_kobj, &base_attr_group);
895 err_create_group:
896 kobject_put(sgi_uv_kobj);
897 return ret;
898 }
899
uv_sysfs_hubless_exit(void)900 static void __exit uv_sysfs_hubless_exit(void)
901 {
902 sysfs_remove_group(sgi_uv_kobj, &hubless_base_attr_group);
903 kobject_put(sgi_uv_kobj);
904 }
905
uv_sysfs_exit(void)906 static void __exit uv_sysfs_exit(void)
907 {
908 if (!is_uv_system()) {
909 if (uv_get_hubless_system())
910 uv_sysfs_hubless_exit();
911 return;
912 }
913
914 pci_topology_exit();
915 uv_ports_exit();
916 uv_hubs_exit();
917 vfree(uv_biosheap);
918 sysfs_remove_group(sgi_uv_kobj, &base_attr_group);
919 kobject_put(sgi_uv_kobj);
920 }
921
922 #ifndef MODULE
923 device_initcall(uv_sysfs_init);
924 #else
925 module_init(uv_sysfs_init);
926 #endif
927 module_exit(uv_sysfs_exit);
928
929 MODULE_AUTHOR("Hewlett Packard Enterprise");
930 MODULE_DESCRIPTION("Sysfs structure for HPE UV systems");
931 MODULE_LICENSE("GPL");
932