2 * PowerPC64 LPAR Configuration Information Driver
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.
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.
17 * This driver creates a proc file at /proc/ppc64/lparcfg which contains
18 * keyword - value pairs that specify the configuration of the partition.
21 #include <linux/config.h>
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/proc_fs.h>
26 #include <linux/init.h>
27 #include <linux/seq_file.h>
28 #include <asm/uaccess.h>
29 #include <asm/iseries/hv_lp_config.h>
30 #include <asm/lppaca.h>
31 #include <asm/hvcall.h>
32 #include <asm/firmware.h>
34 #include <asm/system.h>
36 #include <asm/iseries/it_exp_vpd_panel.h>
38 #include <asm/systemcfg.h>
40 #define MODULE_VERS "1.6"
41 #define MODULE_NAME "lparcfg"
43 /* #define LPARCFG_DEBUG */
45 /* find a better place for this function... */
46 void log_plpar_hcall_return(unsigned long rc
, char *tag
)
48 if (rc
== 0) /* success, return */
50 /* check for null tag ? */
53 "plpar-hcall (%s) failed with hardware fault\n", tag
);
54 else if (rc
== H_Function
)
56 "plpar-hcall (%s) failed; function not allowed\n", tag
);
57 else if (rc
== H_Authority
)
59 "plpar-hcall (%s) failed; not authorized to this function\n",
61 else if (rc
== H_Parameter
)
62 printk(KERN_INFO
"plpar-hcall (%s) failed; Bad parameter(s)\n",
66 "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",
71 static struct proc_dir_entry
*proc_ppc64_lparcfg
;
72 #define LPARCFG_BUFF_SIZE 4096
74 #ifdef CONFIG_PPC_ISERIES
77 * For iSeries legacy systems, the PPA purr function is available from the
78 * emulated_time_base field in the paca.
80 static unsigned long get_purr(void)
82 unsigned long sum_purr
= 0;
84 struct paca_struct
*lpaca
;
88 sum_purr
+= lpaca
->lppaca
.emulated_time_base
;
91 printk(KERN_INFO
"get_purr for cpu (%d) has value (%ld) \n",
92 cpu
, lpaca
->lppaca
.emulated_time_base
);
98 #define lparcfg_write NULL
101 * Methods used to fetch LPAR data when running on an iSeries platform.
103 static int lparcfg_data(struct seq_file
*m
, void *v
)
105 unsigned long pool_id
, lp_index
;
106 int shared
, entitled_capacity
, max_entitled_capacity
;
107 int processors
, max_processors
;
108 struct paca_struct
*lpaca
= get_paca();
109 unsigned long purr
= get_purr();
111 seq_printf(m
, "%s %s \n", MODULE_NAME
, MODULE_VERS
);
113 shared
= (int)(lpaca
->lppaca_ptr
->shared_proc
);
114 seq_printf(m
, "serial_number=%c%c%c%c%c%c%c\n",
115 e2a(xItExtVpdPanel
.mfgID
[2]),
116 e2a(xItExtVpdPanel
.mfgID
[3]),
117 e2a(xItExtVpdPanel
.systemSerial
[1]),
118 e2a(xItExtVpdPanel
.systemSerial
[2]),
119 e2a(xItExtVpdPanel
.systemSerial
[3]),
120 e2a(xItExtVpdPanel
.systemSerial
[4]),
121 e2a(xItExtVpdPanel
.systemSerial
[5]));
123 seq_printf(m
, "system_type=%c%c%c%c\n",
124 e2a(xItExtVpdPanel
.machineType
[0]),
125 e2a(xItExtVpdPanel
.machineType
[1]),
126 e2a(xItExtVpdPanel
.machineType
[2]),
127 e2a(xItExtVpdPanel
.machineType
[3]));
129 lp_index
= HvLpConfig_getLpIndex();
130 seq_printf(m
, "partition_id=%d\n", (int)lp_index
);
132 seq_printf(m
, "system_active_processors=%d\n",
133 (int)HvLpConfig_getSystemPhysicalProcessors());
135 seq_printf(m
, "system_potential_processors=%d\n",
136 (int)HvLpConfig_getSystemPhysicalProcessors());
138 processors
= (int)HvLpConfig_getPhysicalProcessors();
139 seq_printf(m
, "partition_active_processors=%d\n", processors
);
141 max_processors
= (int)HvLpConfig_getMaxPhysicalProcessors();
142 seq_printf(m
, "partition_potential_processors=%d\n", max_processors
);
145 entitled_capacity
= HvLpConfig_getSharedProcUnits();
146 max_entitled_capacity
= HvLpConfig_getMaxSharedProcUnits();
148 entitled_capacity
= processors
* 100;
149 max_entitled_capacity
= max_processors
* 100;
151 seq_printf(m
, "partition_entitled_capacity=%d\n", entitled_capacity
);
153 seq_printf(m
, "partition_max_entitled_capacity=%d\n",
154 max_entitled_capacity
);
157 pool_id
= HvLpConfig_getSharedPoolIndex();
158 seq_printf(m
, "pool=%d\n", (int)pool_id
);
159 seq_printf(m
, "pool_capacity=%d\n",
160 (int)(HvLpConfig_getNumProcsInSharedPool(pool_id
) *
162 seq_printf(m
, "purr=%ld\n", purr
);
165 seq_printf(m
, "shared_processor_mode=%d\n", shared
);
169 #endif /* CONFIG_PPC_ISERIES */
171 #ifdef CONFIG_PPC_PSERIES
173 * Methods used to fetch LPAR data when running on a pSeries platform.
177 * H_GET_PPP hcall returns info in 4 parms.
178 * entitled_capacity,unallocated_capacity,
179 * aggregation, resource_capability).
181 * R4 = Entitled Processor Capacity Percentage.
182 * R5 = Unallocated Processor Capacity Percentage.
183 * R6 (AABBCCDDEEFFGGHH).
184 * XXXX - reserved (0)
185 * XXXX - reserved (0)
186 * XXXX - Group Number
187 * XXXX - Pool Number.
188 * R7 (IIJJKKLLMMNNOOPP).
190 * XX - bit 0-6 reserved (0). bit 7 is Capped indicator.
191 * XX - variable processor Capacity Weight
192 * XX - Unallocated Variable Processor Capacity Weight.
193 * XXXX - Active processors in Physical Processor Pool.
194 * XXXX - Processors active on platform.
196 static unsigned int h_get_ppp(unsigned long *entitled
,
197 unsigned long *unallocated
,
198 unsigned long *aggregation
,
199 unsigned long *resource
)
202 rc
= plpar_hcall_4out(H_GET_PPP
, 0, 0, 0, 0, entitled
, unallocated
,
203 aggregation
, resource
);
205 log_plpar_hcall_return(rc
, "H_GET_PPP");
210 static void h_pic(unsigned long *pool_idle_time
, unsigned long *num_procs
)
214 rc
= plpar_hcall(H_PIC
, 0, 0, 0, 0, pool_idle_time
, num_procs
, &dummy
);
216 log_plpar_hcall_return(rc
, "H_PIC");
219 static unsigned long get_purr(void);
221 /* Track sum of all purrs across all processors. This is used to further */
222 /* calculate usage values by different applications */
224 static unsigned long get_purr(void)
226 unsigned long sum_purr
= 0;
228 struct cpu_usage
*cu
;
231 cu
= &per_cpu(cpu_usage_array
, cpu
);
232 sum_purr
+= cu
->current_tb
;
237 #define SPLPAR_CHARACTERISTICS_TOKEN 20
238 #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
241 * parse_system_parameter_string()
242 * Retrieve the potential_processors, max_entitled_capacity and friends
243 * through the get-system-parameter rtas call. Replace keyword strings as
246 static void parse_system_parameter_string(struct seq_file
*m
)
250 char *local_buffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
252 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
253 __FILE__
, __FUNCTION__
, __LINE__
);
257 spin_lock(&rtas_data_buf_lock
);
258 memset(rtas_data_buf
, 0, SPLPAR_MAXLENGTH
);
259 call_status
= rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
261 SPLPAR_CHARACTERISTICS_TOKEN
,
262 __pa(rtas_data_buf
));
263 memcpy(local_buffer
, rtas_data_buf
, SPLPAR_MAXLENGTH
);
264 spin_unlock(&rtas_data_buf_lock
);
266 if (call_status
!= 0) {
268 "%s %s Error calling get-system-parameter (0x%x)\n",
269 __FILE__
, __FUNCTION__
, call_status
);
273 char *workbuffer
= kmalloc(SPLPAR_MAXLENGTH
, GFP_KERNEL
);
275 printk(KERN_ERR
"%s %s kmalloc failure at line %d \n",
276 __FILE__
, __FUNCTION__
, __LINE__
);
281 printk(KERN_INFO
"success calling get-system-parameter \n");
283 splpar_strlen
= local_buffer
[0] * 16 + local_buffer
[1];
284 local_buffer
+= 2; /* step over strlen value */
286 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
289 while ((*local_buffer
) && (idx
< splpar_strlen
)) {
290 workbuffer
[w_idx
++] = local_buffer
[idx
++];
291 if ((local_buffer
[idx
] == ',')
292 || (local_buffer
[idx
] == '\0')) {
293 workbuffer
[w_idx
] = '\0';
295 /* avoid the empty string */
296 seq_printf(m
, "%s\n", workbuffer
);
298 memset(workbuffer
, 0, SPLPAR_MAXLENGTH
);
299 idx
++; /* skip the comma */
301 } else if (local_buffer
[idx
] == '=') {
302 /* code here to replace workbuffer contents
303 with different keyword strings */
304 if (0 == strcmp(workbuffer
, "MaxEntCap")) {
306 "partition_max_entitled_capacity");
307 w_idx
= strlen(workbuffer
);
309 if (0 == strcmp(workbuffer
, "MaxPlatProcs")) {
311 "system_potential_processors");
312 w_idx
= strlen(workbuffer
);
317 local_buffer
-= 2; /* back up over strlen value */
322 static int lparcfg_count_active_processors(void);
324 /* Return the number of processors in the system.
325 * This function reads through the device tree and counts
326 * the virtual processors, this does not include threads.
328 static int lparcfg_count_active_processors(void)
330 struct device_node
*cpus_dn
= NULL
;
333 while ((cpus_dn
= of_find_node_by_type(cpus_dn
, "cpu"))) {
335 printk(KERN_ERR
"cpus_dn %p \n", cpus_dn
);
342 static int lparcfg_data(struct seq_file
*m
, void *v
)
344 int partition_potential_processors
;
345 int partition_active_processors
;
346 struct device_node
*rootdn
;
347 const char *model
= "";
348 const char *system_id
= "";
349 unsigned int *lp_index_ptr
, lp_index
= 0;
350 struct device_node
*rtas_node
;
353 rootdn
= find_path_device("/");
355 model
= get_property(rootdn
, "model", NULL
);
356 system_id
= get_property(rootdn
, "system-id", NULL
);
357 lp_index_ptr
= (unsigned int *)
358 get_property(rootdn
, "ibm,partition-no", NULL
);
360 lp_index
= *lp_index_ptr
;
363 seq_printf(m
, "%s %s \n", MODULE_NAME
, MODULE_VERS
);
365 seq_printf(m
, "serial_number=%s\n", system_id
);
367 seq_printf(m
, "system_type=%s\n", model
);
369 seq_printf(m
, "partition_id=%d\n", (int)lp_index
);
371 rtas_node
= find_path_device("/rtas");
372 lrdrp
= (int *)get_property(rtas_node
, "ibm,lrdr-capacity", NULL
);
375 partition_potential_processors
= _systemcfg
->processorCount
;
377 partition_potential_processors
= *(lrdrp
+ 4);
380 partition_active_processors
= lparcfg_count_active_processors();
382 if (firmware_has_feature(FW_FEATURE_SPLPAR
)) {
383 unsigned long h_entitled
, h_unallocated
;
384 unsigned long h_aggregation
, h_resource
;
385 unsigned long pool_idle_time
, pool_procs
;
388 h_get_ppp(&h_entitled
, &h_unallocated
, &h_aggregation
,
391 seq_printf(m
, "R4=0x%lx\n", h_entitled
);
392 seq_printf(m
, "R5=0x%lx\n", h_unallocated
);
393 seq_printf(m
, "R6=0x%lx\n", h_aggregation
);
394 seq_printf(m
, "R7=0x%lx\n", h_resource
);
398 /* this call handles the ibm,get-system-parameter contents */
399 parse_system_parameter_string(m
);
401 seq_printf(m
, "partition_entitled_capacity=%ld\n", h_entitled
);
403 seq_printf(m
, "group=%ld\n", (h_aggregation
>> 2 * 8) & 0xffff);
405 seq_printf(m
, "system_active_processors=%ld\n",
406 (h_resource
>> 0 * 8) & 0xffff);
408 /* pool related entries are apropriate for shared configs */
409 if (paca
[0].lppaca
.shared_proc
) {
411 h_pic(&pool_idle_time
, &pool_procs
);
413 seq_printf(m
, "pool=%ld\n",
414 (h_aggregation
>> 0 * 8) & 0xffff);
416 /* report pool_capacity in percentage */
417 seq_printf(m
, "pool_capacity=%ld\n",
418 ((h_resource
>> 2 * 8) & 0xffff) * 100);
420 seq_printf(m
, "pool_idle_time=%ld\n", pool_idle_time
);
422 seq_printf(m
, "pool_num_procs=%ld\n", pool_procs
);
425 seq_printf(m
, "unallocated_capacity_weight=%ld\n",
426 (h_resource
>> 4 * 8) & 0xFF);
428 seq_printf(m
, "capacity_weight=%ld\n",
429 (h_resource
>> 5 * 8) & 0xFF);
431 seq_printf(m
, "capped=%ld\n", (h_resource
>> 6 * 8) & 0x01);
433 seq_printf(m
, "unallocated_capacity=%ld\n", h_unallocated
);
435 seq_printf(m
, "purr=%ld\n", purr
);
437 } else { /* non SPLPAR case */
439 seq_printf(m
, "system_active_processors=%d\n",
440 partition_potential_processors
);
442 seq_printf(m
, "system_potential_processors=%d\n",
443 partition_potential_processors
);
445 seq_printf(m
, "partition_max_entitled_capacity=%d\n",
446 partition_potential_processors
* 100);
448 seq_printf(m
, "partition_entitled_capacity=%d\n",
449 partition_active_processors
* 100);
452 seq_printf(m
, "partition_active_processors=%d\n",
453 partition_active_processors
);
455 seq_printf(m
, "partition_potential_processors=%d\n",
456 partition_potential_processors
);
458 seq_printf(m
, "shared_processor_mode=%d\n", paca
[0].lppaca
.shared_proc
);
464 * Interface for changing system parameters (variable capacity weight
465 * and entitled capacity). Format of input is "param_name=value";
466 * anything after value is ignored. Valid parameters at this time are
467 * "partition_entitled_capacity" and "capacity_weight". We use
468 * H_SET_PPP to alter parameters.
470 * This function should be invoked only on systems with
473 static ssize_t
lparcfg_write(struct file
*file
, const char __user
* buf
,
474 size_t count
, loff_t
* off
)
478 u64 new_entitled
, *new_entitled_ptr
= &new_entitled
;
479 u8 new_weight
, *new_weight_ptr
= &new_weight
;
481 unsigned long current_entitled
; /* parameters for h_get_ppp */
483 unsigned long resource
;
486 ssize_t retval
= -ENOMEM
;
488 kbuf
= kmalloc(count
, GFP_KERNEL
);
493 if (copy_from_user(kbuf
, buf
, count
))
497 kbuf
[count
- 1] = '\0';
498 tmp
= strchr(kbuf
, '=');
504 if (!strcmp(kbuf
, "partition_entitled_capacity")) {
506 *new_entitled_ptr
= (u64
) simple_strtoul(tmp
, &endp
, 10);
509 new_weight_ptr
= ¤t_weight
;
510 } else if (!strcmp(kbuf
, "capacity_weight")) {
512 *new_weight_ptr
= (u8
) simple_strtoul(tmp
, &endp
, 10);
515 new_entitled_ptr
= ¤t_entitled
;
519 /* Get our current parameters */
520 retval
= h_get_ppp(¤t_entitled
, &dummy
, &dummy
, &resource
);
526 current_weight
= (resource
>> 5 * 8) & 0xFF;
528 pr_debug("%s: current_entitled = %lu, current_weight = %lu\n",
529 __FUNCTION__
, current_entitled
, current_weight
);
531 pr_debug("%s: new_entitled = %lu, new_weight = %lu\n",
532 __FUNCTION__
, *new_entitled_ptr
, *new_weight_ptr
);
534 retval
= plpar_hcall_norets(H_SET_PPP
, *new_entitled_ptr
,
537 if (retval
== H_Success
|| retval
== H_Constrained
) {
539 } else if (retval
== H_Busy
) {
541 } else if (retval
== H_Hardware
) {
543 } else if (retval
== H_Parameter
) {
546 printk(KERN_WARNING
"%s: received unknown hv return code %ld",
547 __FUNCTION__
, retval
);
556 #endif /* CONFIG_PPC_PSERIES */
558 static int lparcfg_open(struct inode
*inode
, struct file
*file
)
560 return single_open(file
, lparcfg_data
, NULL
);
563 struct file_operations lparcfg_fops
= {
564 .owner
= THIS_MODULE
,
566 .open
= lparcfg_open
,
567 .release
= single_release
,
570 int __init
lparcfg_init(void)
572 struct proc_dir_entry
*ent
;
573 mode_t mode
= S_IRUSR
| S_IRGRP
| S_IROTH
;
575 /* Allow writing if we have FW_FEATURE_SPLPAR */
576 if (firmware_has_feature(FW_FEATURE_SPLPAR
)) {
577 lparcfg_fops
.write
= lparcfg_write
;
581 ent
= create_proc_entry("ppc64/lparcfg", mode
, NULL
);
583 ent
->proc_fops
= &lparcfg_fops
;
584 ent
->data
= kmalloc(LPARCFG_BUFF_SIZE
, GFP_KERNEL
);
587 "Failed to allocate buffer for lparcfg\n");
588 remove_proc_entry("lparcfg", ent
->parent
);
592 printk(KERN_ERR
"Failed to create ppc64/lparcfg\n");
596 proc_ppc64_lparcfg
= ent
;
600 void __exit
lparcfg_cleanup(void)
602 if (proc_ppc64_lparcfg
) {
603 kfree(proc_ppc64_lparcfg
->data
);
604 remove_proc_entry("lparcfg", proc_ppc64_lparcfg
->parent
);
608 module_init(lparcfg_init
);
609 module_exit(lparcfg_cleanup
);
610 MODULE_DESCRIPTION("Interface for LPAR configuration data");
611 MODULE_AUTHOR("Dave Engebretsen");
612 MODULE_LICENSE("GPL");