lparcfg.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612
  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. #include <linux/config.h>
  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/HvLpConfig.h>
  29. #include <asm/lppaca.h>
  30. #include <asm/hvcall.h>
  31. #include <asm/cputable.h>
  32. #include <asm/rtas.h>
  33. #include <asm/system.h>
  34. #include <asm/time.h>
  35. #include <asm/iSeries/ItExtVpdPanel.h>
  36. #include <asm/prom.h>
  37. #define MODULE_VERS "1.6"
  38. #define MODULE_NAME "lparcfg"
  39. /* #define LPARCFG_DEBUG */
  40. /* find a better place for this function... */
  41. void log_plpar_hcall_return(unsigned long rc, char *tag)
  42. {
  43. if (rc == 0) /* success, return */
  44. return;
  45. /* check for null tag ? */
  46. if (rc == H_Hardware)
  47. printk(KERN_INFO
  48. "plpar-hcall (%s) failed with hardware fault\n", tag);
  49. else if (rc == H_Function)
  50. printk(KERN_INFO
  51. "plpar-hcall (%s) failed; function not allowed\n", tag);
  52. else if (rc == H_Authority)
  53. printk(KERN_INFO
  54. "plpar-hcall (%s) failed; not authorized to this function\n",
  55. tag);
  56. else if (rc == H_Parameter)
  57. printk(KERN_INFO "plpar-hcall (%s) failed; Bad parameter(s)\n",
  58. tag);
  59. else
  60. printk(KERN_INFO
  61. "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",
  62. tag, rc);
  63. }
  64. static struct proc_dir_entry *proc_ppc64_lparcfg;
  65. #define LPARCFG_BUFF_SIZE 4096
  66. #ifdef CONFIG_PPC_ISERIES
  67. /*
  68. * For iSeries legacy systems, the PPA purr function is available from the
  69. * emulated_time_base field in the paca.
  70. */
  71. static unsigned long get_purr(void)
  72. {
  73. unsigned long sum_purr = 0;
  74. int cpu;
  75. struct paca_struct *lpaca;
  76. for_each_cpu(cpu) {
  77. lpaca = paca + cpu;
  78. sum_purr += lpaca->lppaca.emulated_time_base;
  79. #ifdef PURR_DEBUG
  80. printk(KERN_INFO "get_purr for cpu (%d) has value (%ld) \n",
  81. cpu, lpaca->lppaca.emulated_time_base);
  82. #endif
  83. }
  84. return sum_purr;
  85. }
  86. #define lparcfg_write NULL
  87. /*
  88. * Methods used to fetch LPAR data when running on an iSeries platform.
  89. */
  90. static int lparcfg_data(struct seq_file *m, void *v)
  91. {
  92. unsigned long pool_id, lp_index;
  93. int shared, entitled_capacity, max_entitled_capacity;
  94. int processors, max_processors;
  95. struct paca_struct *lpaca = get_paca();
  96. unsigned long purr = get_purr();
  97. seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
  98. shared = (int)(lpaca->lppaca_ptr->shared_proc);
  99. seq_printf(m, "serial_number=%c%c%c%c%c%c%c\n",
  100. e2a(xItExtVpdPanel.mfgID[2]),
  101. e2a(xItExtVpdPanel.mfgID[3]),
  102. e2a(xItExtVpdPanel.systemSerial[1]),
  103. e2a(xItExtVpdPanel.systemSerial[2]),
  104. e2a(xItExtVpdPanel.systemSerial[3]),
  105. e2a(xItExtVpdPanel.systemSerial[4]),
  106. e2a(xItExtVpdPanel.systemSerial[5]));
  107. seq_printf(m, "system_type=%c%c%c%c\n",
  108. e2a(xItExtVpdPanel.machineType[0]),
  109. e2a(xItExtVpdPanel.machineType[1]),
  110. e2a(xItExtVpdPanel.machineType[2]),
  111. e2a(xItExtVpdPanel.machineType[3]));
  112. lp_index = HvLpConfig_getLpIndex();
  113. seq_printf(m, "partition_id=%d\n", (int)lp_index);
  114. seq_printf(m, "system_active_processors=%d\n",
  115. (int)HvLpConfig_getSystemPhysicalProcessors());
  116. seq_printf(m, "system_potential_processors=%d\n",
  117. (int)HvLpConfig_getSystemPhysicalProcessors());
  118. processors = (int)HvLpConfig_getPhysicalProcessors();
  119. seq_printf(m, "partition_active_processors=%d\n", processors);
  120. max_processors = (int)HvLpConfig_getMaxPhysicalProcessors();
  121. seq_printf(m, "partition_potential_processors=%d\n", max_processors);
  122. if (shared) {
  123. entitled_capacity = HvLpConfig_getSharedProcUnits();
  124. max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits();
  125. } else {
  126. entitled_capacity = processors * 100;
  127. max_entitled_capacity = max_processors * 100;
  128. }
  129. seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity);
  130. seq_printf(m, "partition_max_entitled_capacity=%d\n",
  131. max_entitled_capacity);
  132. if (shared) {
  133. pool_id = HvLpConfig_getSharedPoolIndex();
  134. seq_printf(m, "pool=%d\n", (int)pool_id);
  135. seq_printf(m, "pool_capacity=%d\n",
  136. (int)(HvLpConfig_getNumProcsInSharedPool(pool_id) *
  137. 100));
  138. seq_printf(m, "purr=%ld\n", purr);
  139. }
  140. seq_printf(m, "shared_processor_mode=%d\n", shared);
  141. return 0;
  142. }
  143. #endif /* CONFIG_PPC_ISERIES */
  144. #ifdef CONFIG_PPC_PSERIES
  145. /*
  146. * Methods used to fetch LPAR data when running on a pSeries platform.
  147. */
  148. /*
  149. * H_GET_PPP hcall returns info in 4 parms.
  150. * entitled_capacity,unallocated_capacity,
  151. * aggregation, resource_capability).
  152. *
  153. * R4 = Entitled Processor Capacity Percentage.
  154. * R5 = Unallocated Processor Capacity Percentage.
  155. * R6 (AABBCCDDEEFFGGHH).
  156. * XXXX - reserved (0)
  157. * XXXX - reserved (0)
  158. * XXXX - Group Number
  159. * XXXX - Pool Number.
  160. * R7 (IIJJKKLLMMNNOOPP).
  161. * XX - reserved. (0)
  162. * XX - bit 0-6 reserved (0). bit 7 is Capped indicator.
  163. * XX - variable processor Capacity Weight
  164. * XX - Unallocated Variable Processor Capacity Weight.
  165. * XXXX - Active processors in Physical Processor Pool.
  166. * XXXX - Processors active on platform.
  167. */
  168. static unsigned int h_get_ppp(unsigned long *entitled,
  169. unsigned long *unallocated,
  170. unsigned long *aggregation,
  171. unsigned long *resource)
  172. {
  173. unsigned long rc;
  174. rc = plpar_hcall_4out(H_GET_PPP, 0, 0, 0, 0, entitled, unallocated,
  175. aggregation, resource);
  176. log_plpar_hcall_return(rc, "H_GET_PPP");
  177. return rc;
  178. }
  179. static void h_pic(unsigned long *pool_idle_time, unsigned long *num_procs)
  180. {
  181. unsigned long rc;
  182. unsigned long dummy;
  183. rc = plpar_hcall(H_PIC, 0, 0, 0, 0, pool_idle_time, num_procs, &dummy);
  184. log_plpar_hcall_return(rc, "H_PIC");
  185. }
  186. static unsigned long get_purr(void);
  187. /* Track sum of all purrs across all processors. This is used to further */
  188. /* calculate usage values by different applications */
  189. static unsigned long get_purr(void)
  190. {
  191. unsigned long sum_purr = 0;
  192. int cpu;
  193. struct cpu_usage *cu;
  194. for_each_cpu(cpu) {
  195. cu = &per_cpu(cpu_usage_array, cpu);
  196. sum_purr += cu->current_tb;
  197. }
  198. return sum_purr;
  199. }
  200. #define SPLPAR_CHARACTERISTICS_TOKEN 20
  201. #define SPLPAR_MAXLENGTH 1026*(sizeof(char))
  202. /*
  203. * parse_system_parameter_string()
  204. * Retrieve the potential_processors, max_entitled_capacity and friends
  205. * through the get-system-parameter rtas call. Replace keyword strings as
  206. * necessary.
  207. */
  208. static void parse_system_parameter_string(struct seq_file *m)
  209. {
  210. int call_status;
  211. char *local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
  212. if (!local_buffer) {
  213. printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
  214. __FILE__, __FUNCTION__, __LINE__);
  215. return;
  216. }
  217. spin_lock(&rtas_data_buf_lock);
  218. memset(rtas_data_buf, 0, SPLPAR_MAXLENGTH);
  219. call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
  220. NULL,
  221. SPLPAR_CHARACTERISTICS_TOKEN,
  222. __pa(rtas_data_buf));
  223. memcpy(local_buffer, rtas_data_buf, SPLPAR_MAXLENGTH);
  224. spin_unlock(&rtas_data_buf_lock);
  225. if (call_status != 0) {
  226. printk(KERN_INFO
  227. "%s %s Error calling get-system-parameter (0x%x)\n",
  228. __FILE__, __FUNCTION__, call_status);
  229. } else {
  230. int splpar_strlen;
  231. int idx, w_idx;
  232. char *workbuffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
  233. if (!workbuffer) {
  234. printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
  235. __FILE__, __FUNCTION__, __LINE__);
  236. return;
  237. }
  238. #ifdef LPARCFG_DEBUG
  239. printk(KERN_INFO "success calling get-system-parameter \n");
  240. #endif
  241. splpar_strlen = local_buffer[0] * 16 + local_buffer[1];
  242. local_buffer += 2; /* step over strlen value */
  243. memset(workbuffer, 0, SPLPAR_MAXLENGTH);
  244. w_idx = 0;
  245. idx = 0;
  246. while ((*local_buffer) && (idx < splpar_strlen)) {
  247. workbuffer[w_idx++] = local_buffer[idx++];
  248. if ((local_buffer[idx] == ',')
  249. || (local_buffer[idx] == '\0')) {
  250. workbuffer[w_idx] = '\0';
  251. if (w_idx) {
  252. /* avoid the empty string */
  253. seq_printf(m, "%s\n", workbuffer);
  254. }
  255. memset(workbuffer, 0, SPLPAR_MAXLENGTH);
  256. idx++; /* skip the comma */
  257. w_idx = 0;
  258. } else if (local_buffer[idx] == '=') {
  259. /* code here to replace workbuffer contents
  260. with different keyword strings */
  261. if (0 == strcmp(workbuffer, "MaxEntCap")) {
  262. strcpy(workbuffer,
  263. "partition_max_entitled_capacity");
  264. w_idx = strlen(workbuffer);
  265. }
  266. if (0 == strcmp(workbuffer, "MaxPlatProcs")) {
  267. strcpy(workbuffer,
  268. "system_potential_processors");
  269. w_idx = strlen(workbuffer);
  270. }
  271. }
  272. }
  273. kfree(workbuffer);
  274. local_buffer -= 2; /* back up over strlen value */
  275. }
  276. kfree(local_buffer);
  277. }
  278. static int lparcfg_count_active_processors(void);
  279. /* Return the number of processors in the system.
  280. * This function reads through the device tree and counts
  281. * the virtual processors, this does not include threads.
  282. */
  283. static int lparcfg_count_active_processors(void)
  284. {
  285. struct device_node *cpus_dn = NULL;
  286. int count = 0;
  287. while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) {
  288. #ifdef LPARCFG_DEBUG
  289. printk(KERN_ERR "cpus_dn %p \n", cpus_dn);
  290. #endif
  291. count++;
  292. }
  293. return count;
  294. }
  295. static int lparcfg_data(struct seq_file *m, void *v)
  296. {
  297. int partition_potential_processors;
  298. int partition_active_processors;
  299. struct device_node *rootdn;
  300. const char *model = "";
  301. const char *system_id = "";
  302. unsigned int *lp_index_ptr, lp_index = 0;
  303. struct device_node *rtas_node;
  304. int *lrdrp;
  305. rootdn = find_path_device("/");
  306. if (rootdn) {
  307. model = get_property(rootdn, "model", NULL);
  308. system_id = get_property(rootdn, "system-id", NULL);
  309. lp_index_ptr = (unsigned int *)
  310. get_property(rootdn, "ibm,partition-no", NULL);
  311. if (lp_index_ptr)
  312. lp_index = *lp_index_ptr;
  313. }
  314. seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
  315. seq_printf(m, "serial_number=%s\n", system_id);
  316. seq_printf(m, "system_type=%s\n", model);
  317. seq_printf(m, "partition_id=%d\n", (int)lp_index);
  318. rtas_node = find_path_device("/rtas");
  319. lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity", NULL);
  320. if (lrdrp == NULL) {
  321. partition_potential_processors = systemcfg->processorCount;
  322. } else {
  323. partition_potential_processors = *(lrdrp + 4);
  324. }
  325. partition_active_processors = lparcfg_count_active_processors();
  326. if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) {
  327. unsigned long h_entitled, h_unallocated;
  328. unsigned long h_aggregation, h_resource;
  329. unsigned long pool_idle_time, pool_procs;
  330. unsigned long purr;
  331. h_get_ppp(&h_entitled, &h_unallocated, &h_aggregation,
  332. &h_resource);
  333. seq_printf(m, "R4=0x%lx\n", h_entitled);
  334. seq_printf(m, "R5=0x%lx\n", h_unallocated);
  335. seq_printf(m, "R6=0x%lx\n", h_aggregation);
  336. seq_printf(m, "R7=0x%lx\n", h_resource);
  337. purr = get_purr();
  338. /* this call handles the ibm,get-system-parameter contents */
  339. parse_system_parameter_string(m);
  340. seq_printf(m, "partition_entitled_capacity=%ld\n", h_entitled);
  341. seq_printf(m, "group=%ld\n", (h_aggregation >> 2 * 8) & 0xffff);
  342. seq_printf(m, "system_active_processors=%ld\n",
  343. (h_resource >> 0 * 8) & 0xffff);
  344. /* pool related entries are apropriate for shared configs */
  345. if (paca[0].lppaca.shared_proc) {
  346. h_pic(&pool_idle_time, &pool_procs);
  347. seq_printf(m, "pool=%ld\n",
  348. (h_aggregation >> 0 * 8) & 0xffff);
  349. /* report pool_capacity in percentage */
  350. seq_printf(m, "pool_capacity=%ld\n",
  351. ((h_resource >> 2 * 8) & 0xffff) * 100);
  352. seq_printf(m, "pool_idle_time=%ld\n", pool_idle_time);
  353. seq_printf(m, "pool_num_procs=%ld\n", pool_procs);
  354. }
  355. seq_printf(m, "unallocated_capacity_weight=%ld\n",
  356. (h_resource >> 4 * 8) & 0xFF);
  357. seq_printf(m, "capacity_weight=%ld\n",
  358. (h_resource >> 5 * 8) & 0xFF);
  359. seq_printf(m, "capped=%ld\n", (h_resource >> 6 * 8) & 0x01);
  360. seq_printf(m, "unallocated_capacity=%ld\n", h_unallocated);
  361. seq_printf(m, "purr=%ld\n", purr);
  362. } else { /* non SPLPAR case */
  363. seq_printf(m, "system_active_processors=%d\n",
  364. partition_potential_processors);
  365. seq_printf(m, "system_potential_processors=%d\n",
  366. partition_potential_processors);
  367. seq_printf(m, "partition_max_entitled_capacity=%d\n",
  368. partition_potential_processors * 100);
  369. seq_printf(m, "partition_entitled_capacity=%d\n",
  370. partition_active_processors * 100);
  371. }
  372. seq_printf(m, "partition_active_processors=%d\n",
  373. partition_active_processors);
  374. seq_printf(m, "partition_potential_processors=%d\n",
  375. partition_potential_processors);
  376. seq_printf(m, "shared_processor_mode=%d\n", paca[0].lppaca.shared_proc);
  377. return 0;
  378. }
  379. /*
  380. * Interface for changing system parameters (variable capacity weight
  381. * and entitled capacity). Format of input is "param_name=value";
  382. * anything after value is ignored. Valid parameters at this time are
  383. * "partition_entitled_capacity" and "capacity_weight". We use
  384. * H_SET_PPP to alter parameters.
  385. *
  386. * This function should be invoked only on systems with
  387. * FW_FEATURE_SPLPAR.
  388. */
  389. static ssize_t lparcfg_write(struct file *file, const char __user * buf,
  390. size_t count, loff_t * off)
  391. {
  392. char *kbuf;
  393. char *tmp;
  394. u64 new_entitled, *new_entitled_ptr = &new_entitled;
  395. u8 new_weight, *new_weight_ptr = &new_weight;
  396. unsigned long current_entitled; /* parameters for h_get_ppp */
  397. unsigned long dummy;
  398. unsigned long resource;
  399. u8 current_weight;
  400. ssize_t retval = -ENOMEM;
  401. kbuf = kmalloc(count, GFP_KERNEL);
  402. if (!kbuf)
  403. goto out;
  404. retval = -EFAULT;
  405. if (copy_from_user(kbuf, buf, count))
  406. goto out;
  407. retval = -EINVAL;
  408. kbuf[count - 1] = '\0';
  409. tmp = strchr(kbuf, '=');
  410. if (!tmp)
  411. goto out;
  412. *tmp++ = '\0';
  413. if (!strcmp(kbuf, "partition_entitled_capacity")) {
  414. char *endp;
  415. *new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
  416. if (endp == tmp)
  417. goto out;
  418. new_weight_ptr = &current_weight;
  419. } else if (!strcmp(kbuf, "capacity_weight")) {
  420. char *endp;
  421. *new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
  422. if (endp == tmp)
  423. goto out;
  424. new_entitled_ptr = &current_entitled;
  425. } else
  426. goto out;
  427. /* Get our current parameters */
  428. retval = h_get_ppp(&current_entitled, &dummy, &dummy, &resource);
  429. if (retval) {
  430. retval = -EIO;
  431. goto out;
  432. }
  433. current_weight = (resource >> 5 * 8) & 0xFF;
  434. pr_debug("%s: current_entitled = %lu, current_weight = %lu\n",
  435. __FUNCTION__, current_entitled, current_weight);
  436. pr_debug("%s: new_entitled = %lu, new_weight = %lu\n",
  437. __FUNCTION__, *new_entitled_ptr, *new_weight_ptr);
  438. retval = plpar_hcall_norets(H_SET_PPP, *new_entitled_ptr,
  439. *new_weight_ptr);
  440. if (retval == H_Success || retval == H_Constrained) {
  441. retval = count;
  442. } else if (retval == H_Busy) {
  443. retval = -EBUSY;
  444. } else if (retval == H_Hardware) {
  445. retval = -EIO;
  446. } else if (retval == H_Parameter) {
  447. retval = -EINVAL;
  448. } else {
  449. printk(KERN_WARNING "%s: received unknown hv return code %ld",
  450. __FUNCTION__, retval);
  451. retval = -EIO;
  452. }
  453. out:
  454. kfree(kbuf);
  455. return retval;
  456. }
  457. #endif /* CONFIG_PPC_PSERIES */
  458. static int lparcfg_open(struct inode *inode, struct file *file)
  459. {
  460. return single_open(file, lparcfg_data, NULL);
  461. }
  462. struct file_operations lparcfg_fops = {
  463. .owner = THIS_MODULE,
  464. .read = seq_read,
  465. .open = lparcfg_open,
  466. .release = single_release,
  467. };
  468. int __init lparcfg_init(void)
  469. {
  470. struct proc_dir_entry *ent;
  471. mode_t mode = S_IRUSR;
  472. /* Allow writing if we have FW_FEATURE_SPLPAR */
  473. if (cur_cpu_spec->firmware_features & FW_FEATURE_SPLPAR) {
  474. lparcfg_fops.write = lparcfg_write;
  475. mode |= S_IWUSR;
  476. }
  477. ent = create_proc_entry("ppc64/lparcfg", mode, NULL);
  478. if (ent) {
  479. ent->proc_fops = &lparcfg_fops;
  480. ent->data = kmalloc(LPARCFG_BUFF_SIZE, GFP_KERNEL);
  481. if (!ent->data) {
  482. printk(KERN_ERR
  483. "Failed to allocate buffer for lparcfg\n");
  484. remove_proc_entry("lparcfg", ent->parent);
  485. return -ENOMEM;
  486. }
  487. } else {
  488. printk(KERN_ERR "Failed to create ppc64/lparcfg\n");
  489. return -EIO;
  490. }
  491. proc_ppc64_lparcfg = ent;
  492. return 0;
  493. }
  494. void __exit lparcfg_cleanup(void)
  495. {
  496. if (proc_ppc64_lparcfg) {
  497. if (proc_ppc64_lparcfg->data) {
  498. kfree(proc_ppc64_lparcfg->data);
  499. }
  500. remove_proc_entry("lparcfg", proc_ppc64_lparcfg->parent);
  501. }
  502. }
  503. module_init(lparcfg_init);
  504. module_exit(lparcfg_cleanup);
  505. MODULE_DESCRIPTION("Interface for LPAR configuration data");
  506. MODULE_AUTHOR("Dave Engebretsen");
  507. MODULE_LICENSE("GPL");