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(nasid: ordinal_to_nasid(ordinal: cnode), sz: (u64)sizeof(union geoid_u), geo: (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(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 | |
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, fmt: "%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, fmt: "%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, fmt: "%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, fmt: "%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(obj_id: hub_info->id); |
142 | |
143 | return sprintf(buf, fmt: "%d\n" , ordinal_to_nasid(ordinal: cnode)); |
144 | } |
145 | static 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 | |
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(objp: 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 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 | |
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(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 | |
271 | err_hubs: |
272 | for (; i >= 0; i--) |
273 | kobject_put(kobj: &uv_hubs[i]->kobj); |
274 | kfree(objp: uv_hubs); |
275 | err_enum_objs: |
276 | kfree(objp: hub_buf); |
277 | err_hub_buf: |
278 | kset_unregister(kset: uv_hubs_kset); |
279 | err_hubs_kset: |
280 | kfree(objp: 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(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 | |
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, fmt: "%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, fmt: "%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(objp: 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 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 | |
365 | static 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 | |
416 | err_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; |
424 | err_ports: |
425 | for (; j >= 0; j--) |
426 | kfree(objp: uv_hubs[j]->ports); |
427 | j = uv_bios_obj_cnt - 1; |
428 | err_port_info: |
429 | for (; j >= 0; j--) |
430 | kfree(objp: port_buf[j]); |
431 | kfree(objp: 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(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 | |
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, fmt: "%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, fmt: "%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, fmt: "%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, fmt: "%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, fmt: "%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(objp: top_obj->type); |
508 | kfree(objp: top_obj->location); |
509 | kfree(objp: top_obj->ppb_addr); |
510 | kfree(objp: 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 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 | |
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(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 | |
644 | err_add_sysfs: |
645 | kobject_put(kobj: &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(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; |
704 | err_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); |
710 | err_pci_top_str: |
711 | kset_unregister(kset: 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(kobj: &uv_pci_objs[k]->kobj); |
721 | kset_unregister(kset: uv_pcibus_kset); |
722 | kfree(objp: 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, fmt: "%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, fmt: "%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, fmt: "%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, fmt: "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, fmt: "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(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 | |
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(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 | |
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(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 | |
888 | err_pci_init: |
889 | uv_ports_exit(); |
890 | err_ports_init: |
891 | uv_hubs_exit(); |
892 | err_hubs_init: |
893 | vfree(addr: uv_biosheap); |
894 | err_bios_setup: |
895 | sysfs_remove_group(kobj: sgi_uv_kobj, grp: &base_attr_group); |
896 | err_create_group: |
897 | kobject_put(kobj: sgi_uv_kobj); |
898 | return ret; |
899 | } |
900 | |
901 | static 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 | |
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(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 |
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" ); |
932 | |