?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.31.6
[linux/fpc-iii.git] / arch / powerpc / kernel / lparcfg.c
blobed0ac4e4b8d8c82639625d67c8619d495bd9c9d2
1 /*
2 * PowerPC64 LPAR Configuration Information Driver
3 *
4 * Dave Engebretsen engebret@us.ibm.com
5 * Copyright (c) 2003 Dave Engebretsen
6 * Will Schmidt willschm@us.ibm.com
7 * SPLPAR updates, Copyright (c) 2003 Will Schmidt IBM Corporation.
8 * seq_file updates, Copyright (c) 2004 Will Schmidt IBM Corporation.
9 * Nathan Lynch nathanl@austin.ibm.com
10 * Added lparcfg_write, Copyright (C) 2004 Nathan Lynch IBM Corporation.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 * This driver creates a proc file at /proc/ppc64/lparcfg which contains
18 * keyword - value pairs that specify the configuration of the partition.
19 */
20
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/errno.h>
24 #include <linux/proc_fs.h>
25 #include <linux/init.h>
26 #include <linux/seq_file.h>
27 #include <asm/uaccess.h>
28 #include <asm/iseries/hv_lp_config.h>
29 #include <asm/lppaca.h>
30 #include <asm/hvcall.h>
31 #include <asm/firmware.h>
32 #include <asm/rtas.h>
33 #include <asm/system.h>
34 #include <asm/time.h>
35 #include <asm/prom.h>
36 #include <asm/vdso_datapage.h>
37 #include <asm/vio.h>
38 #include <asm/mmu.h>
39
40 #define MODULE_VERS "1.8"
41 #define MODULE_NAME "lparcfg"
42
43 /* #define LPARCFG_DEBUG */
44
45 static struct proc_dir_entry *proc_ppc64_lparcfg;
46
47 /*
48 * Track sum of all purrs across all processors. This is used to further
49 * calculate usage values by different applications
50 */
51 static unsigned long get_purr(void)
52 {
53 unsigned long sum_purr = 0;
54 int cpu;
55
56 for_each_possible_cpu(cpu) {
57 if (firmware_has_feature(FW_FEATURE_ISERIES))
58 sum_purr += lppaca[cpu].emulated_time_base;
59 else {
60 struct cpu_usage *cu;
61
62 cu = &per_cpu(cpu_usage_array, cpu);
63 sum_purr += cu->current_tb;
64 }
65 }
66 return sum_purr;
67 }
68
69 #ifdef CONFIG_PPC_ISERIES
70
71 /*
72 * Methods used to fetch LPAR data when running on an iSeries platform.
73 */
74 static int iseries_lparcfg_data(struct seq_file *m, void *v)
75 {
76 unsigned long pool_id;
77 int shared, entitled_capacity, max_entitled_capacity;
78 int processors, max_processors;
79 unsigned long purr = get_purr();
80
81 shared = (int)(local_paca->lppaca_ptr->shared_proc);
82
83 seq_printf(m, "system_active_processors=%d\n",
84 (int)HvLpConfig_getSystemPhysicalProcessors());
85
86 seq_printf(m, "system_potential_processors=%d\n",
87 (int)HvLpConfig_getSystemPhysicalProcessors());
88
89 processors = (int)HvLpConfig_getPhysicalProcessors();
90 seq_printf(m, "partition_active_processors=%d\n", processors);
91
92 max_processors = (int)HvLpConfig_getMaxPhysicalProcessors();
93 seq_printf(m, "partition_potential_processors=%d\n", max_processors);
94
95 if (shared) {
96 entitled_capacity = HvLpConfig_getSharedProcUnits();
97 max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits();
98 } else {
99 entitled_capacity = processors * 100;
100 max_entitled_capacity = max_processors * 100;
101 }
102 seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity);
103
104 seq_printf(m, "partition_max_entitled_capacity=%d\n",
105 max_entitled_capacity);
106
107 if (shared) {
108 pool_id = HvLpConfig_getSharedPoolIndex();
109 seq_printf(m, "pool=%d\n", (int)pool_id);
110 seq_printf(m, "pool_capacity=%d\n",
111 (int)(HvLpConfig_getNumProcsInSharedPool(pool_id) *
112 100));
113 seq_printf(m, "purr=%ld\n", purr);
114 }
115
116 seq_printf(m, "shared_processor_mode=%d\n", shared);
117
118 return 0;
119 }
120
121 #else /* CONFIG_PPC_ISERIES */
122
123 static int iseries_lparcfg_data(struct seq_file *m, void *v)
124 {
125 return 0;
126 }
127
128 #endif /* CONFIG_PPC_ISERIES */
129
130 #ifdef CONFIG_PPC_PSERIES
131 /*
132 * Methods used to fetch LPAR data when running on a pSeries platform.
133 */
134 /**
135 * h_get_mpp
136 * H_GET_MPP hcall returns info in 7 parms
137 */
138 int h_get_mpp(struct hvcall_mpp_data *mpp_data)
139 {
140 int rc;
141 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
142
143 rc = plpar_hcall9(H_GET_MPP, retbuf);
144
145 mpp_data->entitled_mem = retbuf[0];
146 mpp_data->mapped_mem = retbuf[1];
147
148 mpp_data->group_num = (retbuf[2] >> 2 * 8) & 0xffff;
149 mpp_data->pool_num = retbuf[2] & 0xffff;
150
151 mpp_data->mem_weight = (retbuf[3] >> 7 * 8) & 0xff;
152 mpp_data->unallocated_mem_weight = (retbuf[3] >> 6 * 8) & 0xff;
153 mpp_data->unallocated_entitlement = retbuf[3] & 0xffffffffffff;
154
155 mpp_data->pool_size = retbuf[4];
156 mpp_data->loan_request = retbuf[5];
157 mpp_data->backing_mem = retbuf[6];
158
159 return rc;
160 }
161 EXPORT_SYMBOL(h_get_mpp);
162
163 struct hvcall_ppp_data {
164 u64 entitlement;
165 u64 unallocated_entitlement;
166 u16 group_num;
167 u16 pool_num;
168 u8 capped;
169 u8 weight;
170 u8 unallocated_weight;
171 u16 active_procs_in_pool;
172 u16 active_system_procs;
173 u16 phys_platform_procs;
174 u32 max_proc_cap_avail;
175 u32 entitled_proc_cap_avail;
176 };
177
178 /*
179 * H_GET_PPP hcall returns info in 4 parms.
180 * entitled_capacity,unallocated_capacity,
181 * aggregation, resource_capability).
182 *
183 * R4 = Entitled Processor Capacity Percentage.
184 * R5 = Unallocated Processor Capacity Percentage.
185 * R6 (AABBCCDDEEFFGGHH).
186 * XXXX - reserved (0)
187 * XXXX - reserved (0)
188 * XXXX - Group Number
189 * XXXX - Pool Number.
190 * R7 (IIJJKKLLMMNNOOPP).
191 * XX - reserved. (0)
192 * XX - bit 0-6 reserved (0). bit 7 is Capped indicator.
193 * XX - variable processor Capacity Weight
194 * XX - Unallocated Variable Processor Capacity Weight.
195 * XXXX - Active processors in Physical Processor Pool.
196 * XXXX - Processors active on platform.
197 * R8 (QQQQRRRRRRSSSSSS). if ibm,partition-performance-parameters-level >= 1
198 * XXXX - Physical platform procs allocated to virtualization.
199 * XXXXXX - Max procs capacity % available to the partitions pool.
200 * XXXXXX - Entitled procs capacity % available to the
201 * partitions pool.
202 */
203 static unsigned int h_get_ppp(struct hvcall_ppp_data *ppp_data)
204 {
205 unsigned long rc;
206 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
207
208 rc = plpar_hcall9(H_GET_PPP, retbuf);
209
210 ppp_data->entitlement = retbuf[0];
211 ppp_data->unallocated_entitlement = retbuf[1];
212
213 ppp_data->group_num = (retbuf[2] >> 2 * 8) & 0xffff;
214 ppp_data->pool_num = retbuf[2] & 0xffff;
215
216 ppp_data->capped = (retbuf[3] >> 6 * 8) & 0x01;
217 ppp_data->weight = (retbuf[3] >> 5 * 8) & 0xff;
218 ppp_data->unallocated_weight = (retbuf[3] >> 4 * 8) & 0xff;
219 ppp_data->active_procs_in_pool = (retbuf[3] >> 2 * 8) & 0xffff;
220 ppp_data->active_system_procs = retbuf[3] & 0xffff;
221
222 ppp_data->phys_platform_procs = retbuf[4] >> 6 * 8;
223 ppp_data->max_proc_cap_avail = (retbuf[4] >> 3 * 8) & 0xffffff;
224 ppp_data->entitled_proc_cap_avail = retbuf[4] & 0xffffff;
225
226 return rc;
227 }
228
229 static unsigned h_pic(unsigned long *pool_idle_time,
230 unsigned long *num_procs)
231 {
232 unsigned long rc;
233 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
234
235 rc = plpar_hcall(H_PIC, retbuf);
236
237 *pool_idle_time = retbuf[0];
238 *num_procs = retbuf[1];
239
240 return rc;
241 }
242
243 /*
244 * parse_ppp_data
245 * Parse out the data returned from h_get_ppp and h_pic
246 */
247 static void parse_ppp_data(struct seq_file *m)
248 {
249 struct hvcall_ppp_data ppp_data;
250 struct device_node *root;
251 const int *perf_level;
252 int rc;
253
254 rc = h_get_ppp(&ppp_data);
255 if (rc)
256 return;
257
258 seq_printf(m, "partition_entitled_capacity=%lld\n",
259 ppp_data.entitlement);
260 seq_printf(m, "group=%d\n", ppp_data.group_num);
261 seq_printf(m, "system_active_processors=%d\n",
262 ppp_data.active_system_procs);
263
264 /* pool related entries are apropriate for shared configs */
265 if (lppaca[0].shared_proc) {
266 unsigned long pool_idle_time, pool_procs;
267
268 seq_printf(m, "pool=%d\n", ppp_data.pool_num);
269
270 /* report pool_capacity in percentage */
271 seq_printf(m, "pool_capacity=%d\n",
272 ppp_data.active_procs_in_pool * 100);
273
274 h_pic(&pool_idle_time, &pool_procs);
275 seq_printf(m, "pool_idle_time=%ld\n", pool_idle_time);
276 seq_printf(m, "pool_num_procs=%ld\n", pool_procs);
277 }
278
279 seq_printf(m, "unallocated_capacity_weight=%d\n",
280 ppp_data.unallocated_weight);
281 seq_printf(m, "capacity_weight=%d\n", ppp_data.weight);
282 seq_printf(m, "capped=%d\n", ppp_data.capped);
283 seq_printf(m, "unallocated_capacity=%lld\n",
284 ppp_data.unallocated_entitlement);
285
286 /* The last bits of information returned from h_get_ppp are only
287 * valid if the ibm,partition-performance-parameters-level
288 * property is >= 1.
289 */
290 root = of_find_node_by_path("/");
291 if (root) {
292 perf_level = of_get_property(root,
293 "ibm,partition-performance-parameters-level",
294 NULL);
295 if (perf_level && (*perf_level >= 1)) {
296 seq_printf(m,
297 "physical_procs_allocated_to_virtualization=%d\n",
298 ppp_data.phys_platform_procs);
299 seq_printf(m, "max_proc_capacity_available=%d\n",
300 ppp_data.max_proc_cap_avail);
301 seq_printf(m, "entitled_proc_capacity_available=%d\n",
302 ppp_data.entitled_proc_cap_avail);
303 }
304
305 of_node_put(root);
306 }
307 }
308
309 /**
310 * parse_mpp_data
311 * Parse out data returned from h_get_mpp
312 */
313 static void parse_mpp_data(struct seq_file *m)
314 {
315 struct hvcall_mpp_data mpp_data;
316 int rc;
317
318 rc = h_get_mpp(&mpp_data);
319 if (rc)
320 return;
321
322 seq_printf(m, "entitled_memory=%ld\n", mpp_data.entitled_mem);
323
324 if (mpp_data.mapped_mem != -1)
325 seq_printf(m, "mapped_entitled_memory=%ld\n",
326 mpp_data.mapped_mem);
327
328 seq_printf(m, "entitled_memory_group_number=%d\n", mpp_data.group_num);
329 seq_printf(m, "entitled_memory_pool_number=%d\n", mpp_data.pool_num);
330
331 seq_printf(m, "entitled_memory_weight=%d\n", mpp_data.mem_weight);
332 seq_printf(m, "unallocated_entitled_memory_weight=%d\n",
333 mpp_data.unallocated_mem_weight);
334 seq_printf(m, "unallocated_io_mapping_entitlement=%ld\n",
335 mpp_data.unallocated_entitlement);
336
337 if (mpp_data.pool_size != -1)
338 seq_printf(m, "entitled_memory_pool_size=%ld bytes\n",
339 mpp_data.pool_size);
340
341 seq_printf(m, "entitled_memory_loan_request=%ld\n",
342 mpp_data.loan_request);
343
344 seq_printf(m, "backing_memory=%ld bytes\n", mpp_data.backing_mem);
345 }
346
347 #define SPLPAR_CHARACTERISTICS_TOKEN 20
348 #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
349
350 /*
351 * parse_system_parameter_string()
352 * Retrieve the potential_processors, max_entitled_capacity and friends
353 * through the get-system-parameter rtas call. Replace keyword strings as
354 * necessary.
355 */
356 static void parse_system_parameter_string(struct seq_file *m)
357 {
358 int call_status;
359
360 unsigned char *local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
361 if (!local_buffer) {
362 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
363 __FILE__, __func__, __LINE__);
364 return;
365 }
366
367 spin_lock(&rtas_data_buf_lock);
368 memset(rtas_data_buf, 0, SPLPAR_MAXLENGTH);
369 call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
370 NULL,
371 SPLPAR_CHARACTERISTICS_TOKEN,
372 __pa(rtas_data_buf),
373 RTAS_DATA_BUF_SIZE);
374 memcpy(local_buffer, rtas_data_buf, SPLPAR_MAXLENGTH);
375 spin_unlock(&rtas_data_buf_lock);
376
377 if (call_status != 0) {
378 printk(KERN_INFO
379 "%s %s Error calling get-system-parameter (0x%x)\n",
380 __FILE__, __func__, call_status);
381 } else {
382 int splpar_strlen;
383 int idx, w_idx;
384 char *workbuffer = kzalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
385 if (!workbuffer) {
386 printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
387 __FILE__, __func__, __LINE__);
388 kfree(local_buffer);
389 return;
390 }
391 #ifdef LPARCFG_DEBUG
392 printk(KERN_INFO "success calling get-system-parameter \n");
393 #endif
394 splpar_strlen = local_buffer[0] * 256 + local_buffer[1];
395 local_buffer += 2; /* step over strlen value */
396
397 w_idx = 0;
398 idx = 0;
399 while ((*local_buffer) && (idx < splpar_strlen)) {
400 workbuffer[w_idx++] = local_buffer[idx++];
401 if ((local_buffer[idx] == ',')
402 || (local_buffer[idx] == '\0')) {
403 workbuffer[w_idx] = '\0';
404 if (w_idx) {
405 /* avoid the empty string */
406 seq_printf(m, "%s\n", workbuffer);
407 }
408 memset(workbuffer, 0, SPLPAR_MAXLENGTH);
409 idx++; /* skip the comma */
410 w_idx = 0;
411 } else if (local_buffer[idx] == '=') {
412 /* code here to replace workbuffer contents
413 with different keyword strings */
414 if (0 == strcmp(workbuffer, "MaxEntCap")) {
415 strcpy(workbuffer,
416 "partition_max_entitled_capacity");
417 w_idx = strlen(workbuffer);
418 }
419 if (0 == strcmp(workbuffer, "MaxPlatProcs")) {
420 strcpy(workbuffer,
421 "system_potential_processors");
422 w_idx = strlen(workbuffer);
423 }
424 }
425 }
426 kfree(workbuffer);
427 local_buffer -= 2; /* back up over strlen value */
428 }
429 kfree(local_buffer);
430 }
431
432 /* Return the number of processors in the system.
433 * This function reads through the device tree and counts
434 * the virtual processors, this does not include threads.
435 */
436 static int lparcfg_count_active_processors(void)
437 {
438 struct device_node *cpus_dn = NULL;
439 int count = 0;
440
441 while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) {
442 #ifdef LPARCFG_DEBUG
443 printk(KERN_ERR "cpus_dn %p \n", cpus_dn);
444 #endif
445 count++;
446 }
447 return count;
448 }
449
450 static void pseries_cmo_data(struct seq_file *m)
451 {
452 int cpu;
453 unsigned long cmo_faults = 0;
454 unsigned long cmo_fault_time = 0;
455
456 seq_printf(m, "cmo_enabled=%d\n", firmware_has_feature(FW_FEATURE_CMO));
457
458 if (!firmware_has_feature(FW_FEATURE_CMO))
459 return;
460
461 for_each_possible_cpu(cpu) {
462 cmo_faults += lppaca[cpu].cmo_faults;
463 cmo_fault_time += lppaca[cpu].cmo_fault_time;
464 }
465
466 seq_printf(m, "cmo_faults=%lu\n", cmo_faults);
467 seq_printf(m, "cmo_fault_time_usec=%lu\n",
468 cmo_fault_time / tb_ticks_per_usec);
469 seq_printf(m, "cmo_primary_psp=%d\n", cmo_get_primary_psp());
470 seq_printf(m, "cmo_secondary_psp=%d\n", cmo_get_secondary_psp());
471 seq_printf(m, "cmo_page_size=%lu\n", cmo_get_page_size());
472 }
473
474 static void splpar_dispatch_data(struct seq_file *m)
475 {
476 int cpu;
477 unsigned long dispatches = 0;
478 unsigned long dispatch_dispersions = 0;
479
480 for_each_possible_cpu(cpu) {
481 dispatches += lppaca[cpu].yield_count;
482 dispatch_dispersions += lppaca[cpu].dispersion_count;
483 }
484
485 seq_printf(m, "dispatches=%lu\n", dispatches);
486 seq_printf(m, "dispatch_dispersions=%lu\n", dispatch_dispersions);
487 }
488
489 static int pseries_lparcfg_data(struct seq_file *m, void *v)
490 {
491 int partition_potential_processors;
492 int partition_active_processors;
493 struct device_node *rtas_node;
494 const int *lrdrp = NULL;
495
496 rtas_node = of_find_node_by_path("/rtas");
497 if (rtas_node)
498 lrdrp = of_get_property(rtas_node, "ibm,lrdr-capacity", NULL);
499
500 if (lrdrp == NULL) {
501 partition_potential_processors = vdso_data->processorCount;
502 } else {
503 partition_potential_processors = *(lrdrp + 4);
504 }
505 of_node_put(rtas_node);
506
507 partition_active_processors = lparcfg_count_active_processors();
508
509 if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
510 /* this call handles the ibm,get-system-parameter contents */
511 parse_system_parameter_string(m);
512 parse_ppp_data(m);
513 parse_mpp_data(m);
514 pseries_cmo_data(m);
515 splpar_dispatch_data(m);
516
517 seq_printf(m, "purr=%ld\n", get_purr());
518 } else { /* non SPLPAR case */
519
520 seq_printf(m, "system_active_processors=%d\n",
521 partition_potential_processors);
522
523 seq_printf(m, "system_potential_processors=%d\n",
524 partition_potential_processors);
525
526 seq_printf(m, "partition_max_entitled_capacity=%d\n",
527 partition_potential_processors * 100);
528
529 seq_printf(m, "partition_entitled_capacity=%d\n",
530 partition_active_processors * 100);
531 }
532
533 seq_printf(m, "partition_active_processors=%d\n",
534 partition_active_processors);
535
536 seq_printf(m, "partition_potential_processors=%d\n",
537 partition_potential_processors);
538
539 seq_printf(m, "shared_processor_mode=%d\n", lppaca[0].shared_proc);
540
541 seq_printf(m, "slb_size=%d\n", mmu_slb_size);
542
543 return 0;
544 }
545
546 static ssize_t update_ppp(u64 *entitlement, u8 *weight)
547 {
548 struct hvcall_ppp_data ppp_data;
549 u8 new_weight;
550 u64 new_entitled;
551 ssize_t retval;
552
553 /* Get our current parameters */
554 retval = h_get_ppp(&ppp_data);
555 if (retval)
556 return retval;
557
558 if (entitlement) {
559 new_weight = ppp_data.weight;
560 new_entitled = *entitlement;
561 } else if (weight) {
562 new_weight = *weight;
563 new_entitled = ppp_data.entitlement;
564 } else
565 return -EINVAL;
566
567 pr_debug("%s: current_entitled = %llu, current_weight = %u\n",
568 __func__, ppp_data.entitlement, ppp_data.weight);
569
570 pr_debug("%s: new_entitled = %llu, new_weight = %u\n",
571 __func__, new_entitled, new_weight);
572
573 retval = plpar_hcall_norets(H_SET_PPP, new_entitled, new_weight);
574 return retval;
575 }
576
577 /**
578 * update_mpp
579 *
580 * Update the memory entitlement and weight for the partition. Caller must
581 * specify either a new entitlement or weight, not both, to be updated
582 * since the h_set_mpp call takes both entitlement and weight as parameters.
583 */
584 static ssize_t update_mpp(u64 *entitlement, u8 *weight)
585 {
586 struct hvcall_mpp_data mpp_data;
587 u64 new_entitled;
588 u8 new_weight;
589 ssize_t rc;
590
591 if (entitlement) {
592 /* Check with vio to ensure the new memory entitlement
593 * can be handled.
594 */
595 rc = vio_cmo_entitlement_update(*entitlement);
596 if (rc)
597 return rc;
598 }
599
600 rc = h_get_mpp(&mpp_data);
601 if (rc)
602 return rc;
603
604 if (entitlement) {
605 new_weight = mpp_data.mem_weight;
606 new_entitled = *entitlement;
607 } else if (weight) {
608 new_weight = *weight;
609 new_entitled = mpp_data.entitled_mem;
610 } else
611 return -EINVAL;
612
613 pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
614 __func__, mpp_data.entitled_mem, mpp_data.mem_weight);
615
616 pr_debug("%s: new_entitled = %llu, new_weight = %u\n",
617 __func__, new_entitled, new_weight);
618
619 rc = plpar_hcall_norets(H_SET_MPP, new_entitled, new_weight);
620 return rc;
621 }
622
623 /*
624 * Interface for changing system parameters (variable capacity weight
625 * and entitled capacity). Format of input is "param_name=value";
626 * anything after value is ignored. Valid parameters at this time are
627 * "partition_entitled_capacity" and "capacity_weight". We use
628 * H_SET_PPP to alter parameters.
629 *
630 * This function should be invoked only on systems with
631 * FW_FEATURE_SPLPAR.
632 */
633 static ssize_t lparcfg_write(struct file *file, const char __user * buf,
634 size_t count, loff_t * off)
635 {
636 int kbuf_sz = 64;
637 char kbuf[kbuf_sz];
638 char *tmp;
639 u64 new_entitled, *new_entitled_ptr = &new_entitled;
640 u8 new_weight, *new_weight_ptr = &new_weight;
641 ssize_t retval;
642
643 if (!firmware_has_feature(FW_FEATURE_SPLPAR) ||
644 firmware_has_feature(FW_FEATURE_ISERIES))
645 return -EINVAL;
646
647 if (count > kbuf_sz)
648 return -EINVAL;
649
650 if (copy_from_user(kbuf, buf, count))
651 return -EFAULT;
652
653 kbuf[count - 1] = '\0';
654 tmp = strchr(kbuf, '=');
655 if (!tmp)
656 return -EINVAL;
657
658 *tmp++ = '\0';
659
660 if (!strcmp(kbuf, "partition_entitled_capacity")) {
661 char *endp;
662 *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
663 if (endp == tmp)
664 return -EINVAL;
665
666 retval = update_ppp(new_entitled_ptr, NULL);
667 } else if (!strcmp(kbuf, "capacity_weight")) {
668 char *endp;
669 *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
670 if (endp == tmp)
671 return -EINVAL;
672
673 retval = update_ppp(NULL, new_weight_ptr);
674 } else if (!strcmp(kbuf, "entitled_memory")) {
675 char *endp;
676 *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
677 if (endp == tmp)
678 return -EINVAL;
679
680 retval = update_mpp(new_entitled_ptr, NULL);
681 } else if (!strcmp(kbuf, "entitled_memory_weight")) {
682 char *endp;
683 *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
684 if (endp == tmp)
685 return -EINVAL;
686
687 retval = update_mpp(NULL, new_weight_ptr);
688 } else
689 return -EINVAL;
690
691 if (retval == H_SUCCESS || retval == H_CONSTRAINED) {
692 retval = count;
693 } else if (retval == H_BUSY) {
694 retval = -EBUSY;
695 } else if (retval == H_HARDWARE) {
696 retval = -EIO;
697 } else if (retval == H_PARAMETER) {
698 retval = -EINVAL;
699 }
700
701 return retval;
702 }
703
704 #else /* CONFIG_PPC_PSERIES */
705
706 static int pseries_lparcfg_data(struct seq_file *m, void *v)
707 {
708 return 0;
709 }
710
711 static ssize_t lparcfg_write(struct file *file, const char __user * buf,
712 size_t count, loff_t * off)
713 {
714 return -EINVAL;
715 }
716
717 #endif /* CONFIG_PPC_PSERIES */
718
719 static int lparcfg_data(struct seq_file *m, void *v)
720 {
721 struct device_node *rootdn;
722 const char *model = "";
723 const char *system_id = "";
724 const char *tmp;
725 const unsigned int *lp_index_ptr;
726 unsigned int lp_index = 0;
727
728 seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
729
730 rootdn = of_find_node_by_path("/");
731 if (rootdn) {
732 tmp = of_get_property(rootdn, "model", NULL);
733 if (tmp) {
734 model = tmp;
735 /* Skip "IBM," - see platforms/iseries/dt.c */
736 if (firmware_has_feature(FW_FEATURE_ISERIES))
737 model += 4;
738 }
739 tmp = of_get_property(rootdn, "system-id", NULL);
740 if (tmp) {
741 system_id = tmp;
742 /* Skip "IBM," - see platforms/iseries/dt.c */
743 if (firmware_has_feature(FW_FEATURE_ISERIES))
744 system_id += 4;
745 }
746 lp_index_ptr = of_get_property(rootdn, "ibm,partition-no",
747 NULL);
748 if (lp_index_ptr)
749 lp_index = *lp_index_ptr;
750 of_node_put(rootdn);
751 }
752 seq_printf(m, "serial_number=%s\n", system_id);
753 seq_printf(m, "system_type=%s\n", model);
754 seq_printf(m, "partition_id=%d\n", (int)lp_index);
755
756 if (firmware_has_feature(FW_FEATURE_ISERIES))
757 return iseries_lparcfg_data(m, v);
758 return pseries_lparcfg_data(m, v);
759 }
760
761 static int lparcfg_open(struct inode *inode, struct file *file)
762 {
763 return single_open(file, lparcfg_data, NULL);
764 }
765
766 static const struct file_operations lparcfg_fops = {
767 .owner = THIS_MODULE,
768 .read = seq_read,
769 .write = lparcfg_write,
770 .open = lparcfg_open,
771 .release = single_release,
772 };
773
774 static int __init lparcfg_init(void)
775 {
776 struct proc_dir_entry *ent;
777 mode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
778
779 /* Allow writing if we have FW_FEATURE_SPLPAR */
780 if (firmware_has_feature(FW_FEATURE_SPLPAR) &&
781 !firmware_has_feature(FW_FEATURE_ISERIES))
782 mode |= S_IWUSR;
783
784 ent = proc_create("ppc64/lparcfg", mode, NULL, &lparcfg_fops);
785 if (!ent) {
786 printk(KERN_ERR "Failed to create ppc64/lparcfg\n");
787 return -EIO;
788 }
789
790 proc_ppc64_lparcfg = ent;
791 return 0;
792 }
793
794 static void __exit lparcfg_cleanup(void)
795 {
796 if (proc_ppc64_lparcfg)
797 remove_proc_entry("lparcfg", proc_ppc64_lparcfg->parent);
798 }
799
800 module_init(lparcfg_init);
801 module_exit(lparcfg_cleanup);
802 MODULE_DESCRIPTION("Interface for LPAR configuration data");
803 MODULE_AUTHOR("Dave Engebretsen");
804 MODULE_LICENSE("GPL");
Linux with added FPC-III support