1 /*
2  * Support for dynamic reconfiguration for PCI, Memory, and CPU
3  * Hotplug and Dynamic Logical Partitioning on RPA platforms.
4  *
5  * Copyright (C) 2009 Nathan Fontenot
6  * Copyright (C) 2009 IBM Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version
10  * 2 as published by the Free Software Foundation.
11  */
12 
13 #define pr_fmt(fmt)	"dlpar: " fmt
14 
15 #include <linux/kernel.h>
16 #include <linux/notifier.h>
17 #include <linux/spinlock.h>
18 #include <linux/cpu.h>
19 #include <linux/slab.h>
20 #include <linux/of.h>
21 
22 #include "of_helpers.h"
23 #include "pseries.h"
24 
25 #include <asm/prom.h>
26 #include <asm/machdep.h>
27 #include <linux/uaccess.h>
28 #include <asm/rtas.h>
29 
30 static struct workqueue_struct *pseries_hp_wq;
31 
32 struct pseries_hp_work {
33 	struct work_struct work;
34 	struct pseries_hp_errorlog *errlog;
35 };
36 
37 struct cc_workarea {
38 	__be32	drc_index;
39 	__be32	zero;
40 	__be32	name_offset;
41 	__be32	prop_length;
42 	__be32	prop_offset;
43 };
44 
45 void dlpar_free_cc_property(struct property *prop)
46 {
47 	kfree(prop->name);
48 	kfree(prop->value);
49 	kfree(prop);
50 }
51 
52 static struct property *dlpar_parse_cc_property(struct cc_workarea *ccwa)
53 {
54 	struct property *prop;
55 	char *name;
56 	char *value;
57 
58 	prop = kzalloc(sizeof(*prop), GFP_KERNEL);
59 	if (!prop)
60 		return NULL;
61 
62 	name = (char *)ccwa + be32_to_cpu(ccwa->name_offset);
63 	prop->name = kstrdup(name, GFP_KERNEL);
64 
65 	prop->length = be32_to_cpu(ccwa->prop_length);
66 	value = (char *)ccwa + be32_to_cpu(ccwa->prop_offset);
67 	prop->value = kmemdup(value, prop->length, GFP_KERNEL);
68 	if (!prop->value) {
69 		dlpar_free_cc_property(prop);
70 		return NULL;
71 	}
72 
73 	return prop;
74 }
75 
76 static struct device_node *dlpar_parse_cc_node(struct cc_workarea *ccwa)
77 {
78 	struct device_node *dn;
79 	const char *name;
80 
81 	dn = kzalloc(sizeof(*dn), GFP_KERNEL);
82 	if (!dn)
83 		return NULL;
84 
85 	name = (const char *)ccwa + be32_to_cpu(ccwa->name_offset);
86 	dn->full_name = kstrdup(name, GFP_KERNEL);
87 	if (!dn->full_name) {
88 		kfree(dn);
89 		return NULL;
90 	}
91 
92 	of_node_set_flag(dn, OF_DYNAMIC);
93 	of_node_init(dn);
94 
95 	return dn;
96 }
97 
98 static void dlpar_free_one_cc_node(struct device_node *dn)
99 {
100 	struct property *prop;
101 
102 	while (dn->properties) {
103 		prop = dn->properties;
104 		dn->properties = prop->next;
105 		dlpar_free_cc_property(prop);
106 	}
107 
108 	kfree(dn->full_name);
109 	kfree(dn);
110 }
111 
112 void dlpar_free_cc_nodes(struct device_node *dn)
113 {
114 	if (dn->child)
115 		dlpar_free_cc_nodes(dn->child);
116 
117 	if (dn->sibling)
118 		dlpar_free_cc_nodes(dn->sibling);
119 
120 	dlpar_free_one_cc_node(dn);
121 }
122 
123 #define COMPLETE	0
124 #define NEXT_SIBLING    1
125 #define NEXT_CHILD      2
126 #define NEXT_PROPERTY   3
127 #define PREV_PARENT     4
128 #define MORE_MEMORY     5
129 #define CALL_AGAIN	-2
130 #define ERR_CFG_USE     -9003
131 
132 struct device_node *dlpar_configure_connector(__be32 drc_index,
133 					      struct device_node *parent)
134 {
135 	struct device_node *dn;
136 	struct device_node *first_dn = NULL;
137 	struct device_node *last_dn = NULL;
138 	struct property *property;
139 	struct property *last_property = NULL;
140 	struct cc_workarea *ccwa;
141 	char *data_buf;
142 	int cc_token;
143 	int rc = -1;
144 
145 	cc_token = rtas_token("ibm,configure-connector");
146 	if (cc_token == RTAS_UNKNOWN_SERVICE)
147 		return NULL;
148 
149 	data_buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
150 	if (!data_buf)
151 		return NULL;
152 
153 	ccwa = (struct cc_workarea *)&data_buf[0];
154 	ccwa->drc_index = drc_index;
155 	ccwa->zero = 0;
156 
157 	do {
158 		/* Since we release the rtas_data_buf lock between configure
159 		 * connector calls we want to re-populate the rtas_data_buffer
160 		 * with the contents of the previous call.
161 		 */
162 		spin_lock(&rtas_data_buf_lock);
163 
164 		memcpy(rtas_data_buf, data_buf, RTAS_DATA_BUF_SIZE);
165 		rc = rtas_call(cc_token, 2, 1, NULL, rtas_data_buf, NULL);
166 		memcpy(data_buf, rtas_data_buf, RTAS_DATA_BUF_SIZE);
167 
168 		spin_unlock(&rtas_data_buf_lock);
169 
170 		switch (rc) {
171 		case COMPLETE:
172 			break;
173 
174 		case NEXT_SIBLING:
175 			dn = dlpar_parse_cc_node(ccwa);
176 			if (!dn)
177 				goto cc_error;
178 
179 			dn->parent = last_dn->parent;
180 			last_dn->sibling = dn;
181 			last_dn = dn;
182 			break;
183 
184 		case NEXT_CHILD:
185 			dn = dlpar_parse_cc_node(ccwa);
186 			if (!dn)
187 				goto cc_error;
188 
189 			if (!first_dn) {
190 				dn->parent = parent;
191 				first_dn = dn;
192 			} else {
193 				dn->parent = last_dn;
194 				if (last_dn)
195 					last_dn->child = dn;
196 			}
197 
198 			last_dn = dn;
199 			break;
200 
201 		case NEXT_PROPERTY:
202 			property = dlpar_parse_cc_property(ccwa);
203 			if (!property)
204 				goto cc_error;
205 
206 			if (!last_dn->properties)
207 				last_dn->properties = property;
208 			else
209 				last_property->next = property;
210 
211 			last_property = property;
212 			break;
213 
214 		case PREV_PARENT:
215 			last_dn = last_dn->parent;
216 			break;
217 
218 		case CALL_AGAIN:
219 			break;
220 
221 		case MORE_MEMORY:
222 		case ERR_CFG_USE:
223 		default:
224 			printk(KERN_ERR "Unexpected Error (%d) "
225 			       "returned from configure-connector\n", rc);
226 			goto cc_error;
227 		}
228 	} while (rc);
229 
230 cc_error:
231 	kfree(data_buf);
232 
233 	if (rc) {
234 		if (first_dn)
235 			dlpar_free_cc_nodes(first_dn);
236 
237 		return NULL;
238 	}
239 
240 	return first_dn;
241 }
242 
243 int dlpar_attach_node(struct device_node *dn, struct device_node *parent)
244 {
245 	int rc;
246 
247 	dn->parent = parent;
248 
249 	rc = of_attach_node(dn);
250 	if (rc) {
251 		printk(KERN_ERR "Failed to add device node %pOF\n", dn);
252 		return rc;
253 	}
254 
255 	return 0;
256 }
257 
258 int dlpar_detach_node(struct device_node *dn)
259 {
260 	struct device_node *child;
261 	int rc;
262 
263 	child = of_get_next_child(dn, NULL);
264 	while (child) {
265 		dlpar_detach_node(child);
266 		child = of_get_next_child(dn, child);
267 	}
268 
269 	rc = of_detach_node(dn);
270 	if (rc)
271 		return rc;
272 
273 	of_node_put(dn);
274 
275 	return 0;
276 }
277 
278 #define DR_ENTITY_SENSE		9003
279 #define DR_ENTITY_PRESENT	1
280 #define DR_ENTITY_UNUSABLE	2
281 #define ALLOCATION_STATE	9003
282 #define ALLOC_UNUSABLE		0
283 #define ALLOC_USABLE		1
284 #define ISOLATION_STATE		9001
285 #define ISOLATE			0
286 #define UNISOLATE		1
287 
288 int dlpar_acquire_drc(u32 drc_index)
289 {
290 	int dr_status, rc;
291 
292 	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
293 		       DR_ENTITY_SENSE, drc_index);
294 	if (rc || dr_status != DR_ENTITY_UNUSABLE)
295 		return -1;
296 
297 	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_USABLE);
298 	if (rc)
299 		return rc;
300 
301 	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
302 	if (rc) {
303 		rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
304 		return rc;
305 	}
306 
307 	return 0;
308 }
309 
310 int dlpar_release_drc(u32 drc_index)
311 {
312 	int dr_status, rc;
313 
314 	rc = rtas_call(rtas_token("get-sensor-state"), 2, 2, &dr_status,
315 		       DR_ENTITY_SENSE, drc_index);
316 	if (rc || dr_status != DR_ENTITY_PRESENT)
317 		return -1;
318 
319 	rc = rtas_set_indicator(ISOLATION_STATE, drc_index, ISOLATE);
320 	if (rc)
321 		return rc;
322 
323 	rc = rtas_set_indicator(ALLOCATION_STATE, drc_index, ALLOC_UNUSABLE);
324 	if (rc) {
325 		rtas_set_indicator(ISOLATION_STATE, drc_index, UNISOLATE);
326 		return rc;
327 	}
328 
329 	return 0;
330 }
331 
332 int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
333 {
334 	int rc;
335 
336 	/* pseries error logs are in BE format, convert to cpu type */
337 	switch (hp_elog->id_type) {
338 	case PSERIES_HP_ELOG_ID_DRC_COUNT:
339 		hp_elog->_drc_u.drc_count =
340 				be32_to_cpu(hp_elog->_drc_u.drc_count);
341 		break;
342 	case PSERIES_HP_ELOG_ID_DRC_INDEX:
343 		hp_elog->_drc_u.drc_index =
344 				be32_to_cpu(hp_elog->_drc_u.drc_index);
345 		break;
346 	case PSERIES_HP_ELOG_ID_DRC_IC:
347 		hp_elog->_drc_u.ic.count =
348 				be32_to_cpu(hp_elog->_drc_u.ic.count);
349 		hp_elog->_drc_u.ic.index =
350 				be32_to_cpu(hp_elog->_drc_u.ic.index);
351 	}
352 
353 	switch (hp_elog->resource) {
354 	case PSERIES_HP_ELOG_RESOURCE_MEM:
355 		rc = dlpar_memory(hp_elog);
356 		break;
357 	case PSERIES_HP_ELOG_RESOURCE_CPU:
358 		rc = dlpar_cpu(hp_elog);
359 		break;
360 	case PSERIES_HP_ELOG_RESOURCE_PMEM:
361 		rc = dlpar_hp_pmem(hp_elog);
362 		break;
363 
364 	default:
365 		pr_warn_ratelimited("Invalid resource (%d) specified\n",
366 				    hp_elog->resource);
367 		rc = -EINVAL;
368 	}
369 
370 	return rc;
371 }
372 
373 static void pseries_hp_work_fn(struct work_struct *work)
374 {
375 	struct pseries_hp_work *hp_work =
376 			container_of(work, struct pseries_hp_work, work);
377 
378 	handle_dlpar_errorlog(hp_work->errlog);
379 
380 	kfree(hp_work->errlog);
381 	kfree((void *)work);
382 }
383 
384 void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog)
385 {
386 	struct pseries_hp_work *work;
387 	struct pseries_hp_errorlog *hp_errlog_copy;
388 
389 	hp_errlog_copy = kmalloc(sizeof(struct pseries_hp_errorlog),
390 				 GFP_KERNEL);
391 	memcpy(hp_errlog_copy, hp_errlog, sizeof(struct pseries_hp_errorlog));
392 
393 	work = kmalloc(sizeof(struct pseries_hp_work), GFP_KERNEL);
394 	if (work) {
395 		INIT_WORK((struct work_struct *)work, pseries_hp_work_fn);
396 		work->errlog = hp_errlog_copy;
397 		queue_work(pseries_hp_wq, (struct work_struct *)work);
398 	} else {
399 		kfree(hp_errlog_copy);
400 	}
401 }
402 
403 static int dlpar_parse_resource(char **cmd, struct pseries_hp_errorlog *hp_elog)
404 {
405 	char *arg;
406 
407 	arg = strsep(cmd, " ");
408 	if (!arg)
409 		return -EINVAL;
410 
411 	if (sysfs_streq(arg, "memory")) {
412 		hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM;
413 	} else if (sysfs_streq(arg, "cpu")) {
414 		hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_CPU;
415 	} else {
416 		pr_err("Invalid resource specified.\n");
417 		return -EINVAL;
418 	}
419 
420 	return 0;
421 }
422 
423 static int dlpar_parse_action(char **cmd, struct pseries_hp_errorlog *hp_elog)
424 {
425 	char *arg;
426 
427 	arg = strsep(cmd, " ");
428 	if (!arg)
429 		return -EINVAL;
430 
431 	if (sysfs_streq(arg, "add")) {
432 		hp_elog->action = PSERIES_HP_ELOG_ACTION_ADD;
433 	} else if (sysfs_streq(arg, "remove")) {
434 		hp_elog->action = PSERIES_HP_ELOG_ACTION_REMOVE;
435 	} else {
436 		pr_err("Invalid action specified.\n");
437 		return -EINVAL;
438 	}
439 
440 	return 0;
441 }
442 
443 static int dlpar_parse_id_type(char **cmd, struct pseries_hp_errorlog *hp_elog)
444 {
445 	char *arg;
446 	u32 count, index;
447 
448 	arg = strsep(cmd, " ");
449 	if (!arg)
450 		return -EINVAL;
451 
452 	if (sysfs_streq(arg, "indexed-count")) {
453 		hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_IC;
454 		arg = strsep(cmd, " ");
455 		if (!arg) {
456 			pr_err("No DRC count specified.\n");
457 			return -EINVAL;
458 		}
459 
460 		if (kstrtou32(arg, 0, &count)) {
461 			pr_err("Invalid DRC count specified.\n");
462 			return -EINVAL;
463 		}
464 
465 		arg = strsep(cmd, " ");
466 		if (!arg) {
467 			pr_err("No DRC Index specified.\n");
468 			return -EINVAL;
469 		}
470 
471 		if (kstrtou32(arg, 0, &index)) {
472 			pr_err("Invalid DRC Index specified.\n");
473 			return -EINVAL;
474 		}
475 
476 		hp_elog->_drc_u.ic.count = cpu_to_be32(count);
477 		hp_elog->_drc_u.ic.index = cpu_to_be32(index);
478 	} else if (sysfs_streq(arg, "index")) {
479 		hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
480 		arg = strsep(cmd, " ");
481 		if (!arg) {
482 			pr_err("No DRC Index specified.\n");
483 			return -EINVAL;
484 		}
485 
486 		if (kstrtou32(arg, 0, &index)) {
487 			pr_err("Invalid DRC Index specified.\n");
488 			return -EINVAL;
489 		}
490 
491 		hp_elog->_drc_u.drc_index = cpu_to_be32(index);
492 	} else if (sysfs_streq(arg, "count")) {
493 		hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_COUNT;
494 		arg = strsep(cmd, " ");
495 		if (!arg) {
496 			pr_err("No DRC count specified.\n");
497 			return -EINVAL;
498 		}
499 
500 		if (kstrtou32(arg, 0, &count)) {
501 			pr_err("Invalid DRC count specified.\n");
502 			return -EINVAL;
503 		}
504 
505 		hp_elog->_drc_u.drc_count = cpu_to_be32(count);
506 	} else {
507 		pr_err("Invalid id_type specified.\n");
508 		return -EINVAL;
509 	}
510 
511 	return 0;
512 }
513 
514 static ssize_t dlpar_store(struct class *class, struct class_attribute *attr,
515 			   const char *buf, size_t count)
516 {
517 	struct pseries_hp_errorlog hp_elog;
518 	char *argbuf;
519 	char *args;
520 	int rc;
521 
522 	args = argbuf = kstrdup(buf, GFP_KERNEL);
523 	if (!argbuf) {
524 		pr_info("Could not allocate resources for DLPAR operation\n");
525 		kfree(argbuf);
526 		return -ENOMEM;
527 	}
528 
529 	/*
530 	 * Parse out the request from the user, this will be in the form:
531 	 * <resource> <action> <id_type> <id>
532 	 */
533 	rc = dlpar_parse_resource(&args, &hp_elog);
534 	if (rc)
535 		goto dlpar_store_out;
536 
537 	rc = dlpar_parse_action(&args, &hp_elog);
538 	if (rc)
539 		goto dlpar_store_out;
540 
541 	rc = dlpar_parse_id_type(&args, &hp_elog);
542 	if (rc)
543 		goto dlpar_store_out;
544 
545 	rc = handle_dlpar_errorlog(&hp_elog);
546 
547 dlpar_store_out:
548 	kfree(argbuf);
549 
550 	if (rc)
551 		pr_err("Could not handle DLPAR request \"%s\"\n", buf);
552 
553 	return rc ? rc : count;
554 }
555 
556 static ssize_t dlpar_show(struct class *class, struct class_attribute *attr,
557 			  char *buf)
558 {
559 	return sprintf(buf, "%s\n", "memory,cpu");
560 }
561 
562 static CLASS_ATTR_RW(dlpar);
563 
564 int __init dlpar_workqueue_init(void)
565 {
566 	if (pseries_hp_wq)
567 		return 0;
568 
569 	pseries_hp_wq = alloc_workqueue("pseries hotplug workqueue",
570 			WQ_UNBOUND, 1);
571 
572 	return pseries_hp_wq ? 0 : -ENOMEM;
573 }
574 
575 static int __init dlpar_sysfs_init(void)
576 {
577 	int rc;
578 
579 	rc = dlpar_workqueue_init();
580 	if (rc)
581 		return rc;
582 
583 	return sysfs_create_file(kernel_kobj, &class_attr_dlpar.attr);
584 }
585 machine_device_initcall(pseries, dlpar_sysfs_init);
586 
587