[PATCH] ppc64: lparcfg whitespace and wordwrap cleanup.

This patch is the result of running Lindent against
arch/ppc64/kernel/lparcfg.c.

This cleans up an assortment of whitespace and wordwrap inconsistencies.
Signed-off-by: Will Schmidt <willschm@us.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

arch/ppc64/kernel/lparcfg.c

@@ -40,25 +40,31 @@
 /* #define LPARCFG_DEBUG */
 
 /* find a better place for this function... */
-void log_plpar_hcall_return(unsigned long rc,char * tag)
+void log_plpar_hcall_return(unsigned long rc, char *tag)
 {
-	if (rc ==0 ) /* success, return */
+	if (rc == 0)		/* success, return */
 		return;
 /* check for null tag ? */
 	if (rc == H_Hardware)
-		printk(KERN_INFO "plpar-hcall (%s) failed with hardware fault\n",tag);
+		printk(KERN_INFO
+		       "plpar-hcall (%s) failed with hardware fault\n", tag);
 	else if (rc == H_Function)
-		printk(KERN_INFO "plpar-hcall (%s) failed; function not allowed\n",tag);
+		printk(KERN_INFO
+		       "plpar-hcall (%s) failed; function not allowed\n", tag);
 	else if (rc == H_Authority)
-		printk(KERN_INFO "plpar-hcall (%s) failed; not authorized to this function\n",tag);
+		printk(KERN_INFO
+		       "plpar-hcall (%s) failed; not authorized to this function\n",
+		       tag);
 	else if (rc == H_Parameter)
-		printk(KERN_INFO "plpar-hcall (%s) failed; Bad parameter(s)\n",tag);
+		printk(KERN_INFO "plpar-hcall (%s) failed; Bad parameter(s)\n",
+		       tag);
 	else
-		printk(KERN_INFO "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",tag,rc);
+		printk(KERN_INFO
+		       "plpar-hcall (%s) failed with unexpected rc(0x%lx)\n",
+		       tag, rc);
 
 }
 
-
 static struct proc_dir_entry *proc_ppc64_lparcfg;
 #define LPARCFG_BUFF_SIZE 4096
 
@@ -78,59 +84,60 @@ static int lparcfg_data(struct seq_file *m, void *v)
 
 	shared = (int)(lpaca->lppaca_ptr->xSharedProc);
 	seq_printf(m, "serial_number=%c%c%c%c%c%c%c\n",
-		      e2a(xItExtVpdPanel.mfgID[2]),
-		      e2a(xItExtVpdPanel.mfgID[3]),
-		      e2a(xItExtVpdPanel.systemSerial[1]),
-		      e2a(xItExtVpdPanel.systemSerial[2]),
-		      e2a(xItExtVpdPanel.systemSerial[3]),
-		      e2a(xItExtVpdPanel.systemSerial[4]),
-		      e2a(xItExtVpdPanel.systemSerial[5])); 
+		   e2a(xItExtVpdPanel.mfgID[2]),
+		   e2a(xItExtVpdPanel.mfgID[3]),
+		   e2a(xItExtVpdPanel.systemSerial[1]),
+		   e2a(xItExtVpdPanel.systemSerial[2]),
+		   e2a(xItExtVpdPanel.systemSerial[3]),
+		   e2a(xItExtVpdPanel.systemSerial[4]),
+		   e2a(xItExtVpdPanel.systemSerial[5]));
 
 	seq_printf(m, "system_type=%c%c%c%c\n",
-		      e2a(xItExtVpdPanel.machineType[0]),
-		      e2a(xItExtVpdPanel.machineType[1]),
-		      e2a(xItExtVpdPanel.machineType[2]),
-		      e2a(xItExtVpdPanel.machineType[3])); 
+		   e2a(xItExtVpdPanel.machineType[0]),
+		   e2a(xItExtVpdPanel.machineType[1]),
+		   e2a(xItExtVpdPanel.machineType[2]),
+		   e2a(xItExtVpdPanel.machineType[3]));
 
-	lp_index = HvLpConfig_getLpIndex(); 
+	lp_index = HvLpConfig_getLpIndex();
 	seq_printf(m, "partition_id=%d\n", (int)lp_index);
 
 	seq_printf(m, "system_active_processors=%d\n",
-		      (int)HvLpConfig_getSystemPhysicalProcessors()); 
+		   (int)HvLpConfig_getSystemPhysicalProcessors());
 
 	seq_printf(m, "system_potential_processors=%d\n",
-		      (int)HvLpConfig_getSystemPhysicalProcessors()); 
+		   (int)HvLpConfig_getSystemPhysicalProcessors());
 
-	processors = (int)HvLpConfig_getPhysicalProcessors(); 
+	processors = (int)HvLpConfig_getPhysicalProcessors();
 	seq_printf(m, "partition_active_processors=%d\n", processors);
 
-	max_processors = (int)HvLpConfig_getMaxPhysicalProcessors(); 
+	max_processors = (int)HvLpConfig_getMaxPhysicalProcessors();
 	seq_printf(m, "partition_potential_processors=%d\n", max_processors);
 
-	if(shared) {
-		entitled_capacity = HvLpConfig_getSharedProcUnits(); 
-		max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits(); 
+	if (shared) {
+		entitled_capacity = HvLpConfig_getSharedProcUnits();
+		max_entitled_capacity = HvLpConfig_getMaxSharedProcUnits();
 	} else {
-		entitled_capacity = processors * 100; 
-		max_entitled_capacity = max_processors * 100; 
+		entitled_capacity = processors * 100;
+		max_entitled_capacity = max_processors * 100;
 	}
 	seq_printf(m, "partition_entitled_capacity=%d\n", entitled_capacity);
 
 	seq_printf(m, "partition_max_entitled_capacity=%d\n",
-		      max_entitled_capacity);
+		   max_entitled_capacity);
 
-	if(shared) {
-		pool_id = HvLpConfig_getSharedPoolIndex(); 
+	if (shared) {
+		pool_id = HvLpConfig_getSharedPoolIndex();
 		seq_printf(m, "pool=%d\n", (int)pool_id);
 		seq_printf(m, "pool_capacity=%d\n",
-		    (int)(HvLpConfig_getNumProcsInSharedPool(pool_id)*100));
+			   (int)(HvLpConfig_getNumProcsInSharedPool(pool_id) *
+				 100));
 	}
 
 	seq_printf(m, "shared_processor_mode=%d\n", shared);
 
 	return 0;
 }
-#endif /* CONFIG_PPC_ISERIES */
+#endif				/* CONFIG_PPC_ISERIES */
 
 #ifdef CONFIG_PPC_PSERIES
 /* 
@@ -158,11 +165,13 @@ static int lparcfg_data(struct seq_file *m, void *v)
  *                  XXXX  - Processors active on platform. 
  */
 static unsigned int h_get_ppp(unsigned long *entitled,
-		unsigned long  *unallocated, unsigned long *aggregation,
-		unsigned long *resource)
+			      unsigned long *unallocated,
+			      unsigned long *aggregation,
+			      unsigned long *resource)
 {
 	unsigned long rc;
-	rc = plpar_hcall_4out(H_GET_PPP,0,0,0,0,entitled,unallocated,aggregation,resource);
+	rc = plpar_hcall_4out(H_GET_PPP, 0, 0, 0, 0, entitled, unallocated,
+			      aggregation, resource);
 
 	log_plpar_hcall_return(rc, "H_GET_PPP");
 
@@ -185,7 +194,7 @@ static unsigned long get_purr(void);
  */
 static unsigned long get_purr()
 {
-	unsigned long sum_purr=0;
+	unsigned long sum_purr = 0;
 	return sum_purr;
 }
 
@@ -202,7 +211,7 @@ static void parse_system_parameter_string(struct seq_file *m)
 {
 	int call_status;
 
-	char * local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
+	char *local_buffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
 	if (!local_buffer) {
 		printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
 		       __FILE__, __FUNCTION__, __LINE__);
@@ -219,22 +228,23 @@ static void parse_system_parameter_string(struct seq_file *m)
 	spin_unlock(&rtas_data_buf_lock);
 
 	if (call_status != 0) {
-		printk(KERN_INFO "%s %s Error calling get-system-parameter (0x%x)\n",
+		printk(KERN_INFO
+		       "%s %s Error calling get-system-parameter (0x%x)\n",
 		       __FILE__, __FUNCTION__, call_status);
 	} else {
 		int splpar_strlen;
 		int idx, w_idx;
-		char * workbuffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
+		char *workbuffer = kmalloc(SPLPAR_MAXLENGTH, GFP_KERNEL);
 		if (!workbuffer) {
-			printk(KERN_ERR "%s %s kmalloc failure at line %d \n",__FILE__,__FUNCTION__,__LINE__);
+			printk(KERN_ERR "%s %s kmalloc failure at line %d \n",
+			       __FILE__, __FUNCTION__, __LINE__);
 			return;
 		}
-
 #ifdef LPARCFG_DEBUG
 		printk(KERN_INFO "success calling get-system-parameter \n");
 #endif
 		splpar_strlen = local_buffer[0] * 16 + local_buffer[1];
-		local_buffer += 2; /* step over strlen value */
+		local_buffer += 2;	/* step over strlen value */
 
 		memset(workbuffer, 0, SPLPAR_MAXLENGTH);
 		w_idx = 0;
@@ -253,13 +263,15 @@ static void parse_system_parameter_string(struct seq_file *m)
 				w_idx = 0;
 			} else if (local_buffer[idx] == '=') {
 				/* code here to replace workbuffer contents
-				 with different keyword strings */
-				if (0 == strcmp(workbuffer,"MaxEntCap")) {
-					strcpy(workbuffer, "partition_max_entitled_capacity");
+				   with different keyword strings */
+				if (0 == strcmp(workbuffer, "MaxEntCap")) {
+					strcpy(workbuffer,
+					       "partition_max_entitled_capacity");
 					w_idx = strlen(workbuffer);
 				}
-				if (0 == strcmp(workbuffer,"MaxPlatProcs")) {
-					strcpy(workbuffer, "system_potential_processors");
+				if (0 == strcmp(workbuffer, "MaxPlatProcs")) {
+					strcpy(workbuffer,
+					       "system_potential_processors");
 					w_idx = strlen(workbuffer);
 				}
 			}
@@ -283,7 +295,7 @@ static int lparcfg_count_active_processors(void)
 
 	while ((cpus_dn = of_find_node_by_type(cpus_dn, "cpu"))) {
 #ifdef LPARCFG_DEBUG
-		printk(KERN_ERR "cpus_dn %p \n",cpus_dn);
+		printk(KERN_ERR "cpus_dn %p \n", cpus_dn);
 #endif
 		count++;
 	}
@@ -306,12 +318,11 @@ static int lparcfg_data(struct seq_file *m, void *v)
 		model = get_property(rootdn, "model", NULL);
 		system_id = get_property(rootdn, "system-id", NULL);
 		lp_index_ptr = (unsigned int *)
-			get_property(rootdn, "ibm,partition-no", NULL);
+		    get_property(rootdn, "ibm,partition-no", NULL);
 		if (lp_index_ptr)
 			lp_index = *lp_index_ptr;
 	}
 
-
 	seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
 
 	seq_printf(m, "serial_number=%s\n", system_id);
@@ -350,14 +361,12 @@ static int lparcfg_data(struct seq_file *m, void *v)
 		/* this call handles the ibm,get-system-parameter contents */
 		parse_system_parameter_string(m);
 
-		seq_printf(m, "partition_entitled_capacity=%ld\n",
-			      h_entitled);
+		seq_printf(m, "partition_entitled_capacity=%ld\n", h_entitled);
 
-		seq_printf(m, "group=%ld\n",
-			      (h_aggregation >> 2*8) & 0xffff);
+		seq_printf(m, "group=%ld\n", (h_aggregation >> 2 * 8) & 0xffff);
 
 		seq_printf(m, "system_active_processors=%ld\n",
-			      (h_resource >> 0*8) & 0xffff);
+			   (h_resource >> 0 * 8) & 0xffff);
 
 		/* pool related entries are apropriate for shared configs */
 		if (paca[0].lppaca.xSharedProc) {
@@ -365,11 +374,11 @@ static int lparcfg_data(struct seq_file *m, void *v)
 			h_pic(&pool_idle_time, &pool_procs);
 
 			seq_printf(m, "pool=%ld\n",
-				   (h_aggregation >> 0*8) & 0xffff);
+				   (h_aggregation >> 0 * 8) & 0xffff);
 
 			/* report pool_capacity in percentage */
 			seq_printf(m, "pool_capacity=%ld\n",
-				   ((h_resource >> 2*8) & 0xffff)*100);
+				   ((h_resource >> 2 * 8) & 0xffff) * 100);
 
 			seq_printf(m, "pool_idle_time=%ld\n", pool_idle_time);
 
@@ -377,42 +386,39 @@ static int lparcfg_data(struct seq_file *m, void *v)
 		}
 
 		seq_printf(m, "unallocated_capacity_weight=%ld\n",
-			      (h_resource >> 4*8) & 0xFF);
+			   (h_resource >> 4 * 8) & 0xFF);
 
 		seq_printf(m, "capacity_weight=%ld\n",
-			      (h_resource >> 5*8) & 0xFF);
+			   (h_resource >> 5 * 8) & 0xFF);
+
+		seq_printf(m, "capped=%ld\n", (h_resource >> 6 * 8) & 0x01);
 
-		seq_printf(m, "capped=%ld\n",
-			      (h_resource >> 6*8) & 0x01);
+		seq_printf(m, "unallocated_capacity=%ld\n", h_unallocated);
 
-		seq_printf(m, "unallocated_capacity=%ld\n",
-			      h_unallocated);
+		seq_printf(m, "purr=%ld\n", purr);
 
-		seq_printf(m, "purr=%ld\n",
-			      purr);
+	} else {		/* non SPLPAR case */
 
-	} else /* non SPLPAR case */ {
 		seq_printf(m, "system_active_processors=%d\n",
-			      partition_potential_processors);
+			   partition_potential_processors);
 
 		seq_printf(m, "system_potential_processors=%d\n",
-			      partition_potential_processors);
+			   partition_potential_processors);
 
 		seq_printf(m, "partition_max_entitled_capacity=%d\n",
-			      partition_potential_processors * 100);
+			   partition_potential_processors * 100);
 
 		seq_printf(m, "partition_entitled_capacity=%d\n",
-			      partition_active_processors * 100);
+			   partition_active_processors * 100);
 	}
 
 	seq_printf(m, "partition_active_processors=%d\n",
-			      partition_active_processors);
+		   partition_active_processors);
 
 	seq_printf(m, "partition_potential_processors=%d\n",
-			      partition_potential_processors);
+		   partition_potential_processors);
 
-	seq_printf(m, "shared_processor_mode=%d\n",
-			paca[0].lppaca.xSharedProc);
+	seq_printf(m, "shared_processor_mode=%d\n", paca[0].lppaca.xSharedProc);
 
 	return 0;
 }
@@ -427,14 +433,15 @@ static int lparcfg_data(struct seq_file *m, void *v)
  * This function should be invoked only on systems with
  * FW_FEATURE_SPLPAR.
  */
-static ssize_t lparcfg_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
+static ssize_t lparcfg_write(struct file *file, const char __user * buf,
+			     size_t count, loff_t * off)
 {
 	char *kbuf;
 	char *tmp;
 	u64 new_entitled, *new_entitled_ptr = &new_entitled;
 	u8 new_weight, *new_weight_ptr = &new_weight;
 
-	unsigned long current_entitled;    /* parameters for h_get_ppp */
+	unsigned long current_entitled;	/* parameters for h_get_ppp */
 	unsigned long dummy;
 	unsigned long resource;
 	u8 current_weight;
@@ -459,13 +466,13 @@ static ssize_t lparcfg_write(struct file *file, const char __user *buf, size_t c
 
 	if (!strcmp(kbuf, "partition_entitled_capacity")) {
 		char *endp;
-		*new_entitled_ptr = (u64)simple_strtoul(tmp, &endp, 10);
+		*new_entitled_ptr = (u64) simple_strtoul(tmp, &endp, 10);
 		if (endp == tmp)
 			goto out;
 		new_weight_ptr = &current_weight;
 	} else if (!strcmp(kbuf, "capacity_weight")) {
 		char *endp;
-		*new_weight_ptr = (u8)simple_strtoul(tmp, &endp, 10);
+		*new_weight_ptr = (u8) simple_strtoul(tmp, &endp, 10);
 		if (endp == tmp)
 			goto out;
 		new_entitled_ptr = &current_entitled;
@@ -479,7 +486,7 @@ static ssize_t lparcfg_write(struct file *file, const char __user *buf, size_t c
 		goto out;
 	}
 
-	current_weight = (resource>>5*8)&0xFF;
+	current_weight = (resource >> 5 * 8) & 0xFF;
 
 	pr_debug("%s: current_entitled = %lu, current_weight = %lu\n",
 		 __FUNCTION__, current_entitled, current_weight);
@@ -504,23 +511,23 @@ static ssize_t lparcfg_write(struct file *file, const char __user *buf, size_t c
 		retval = -EIO;
 	}
 
-out:
+      out:
 	kfree(kbuf);
 	return retval;
 }
 
-#endif /* CONFIG_PPC_PSERIES */
+#endif				/* CONFIG_PPC_PSERIES */
 
-static int lparcfg_open(struct inode * inode, struct file * file)
+static int lparcfg_open(struct inode *inode, struct file *file)
 {
-	return single_open(file,lparcfg_data,NULL);
+	return single_open(file, lparcfg_data, NULL);
 }
 
 struct file_operations lparcfg_fops = {
-	owner:		THIS_MODULE,
-	read:		seq_read,
-	open:		lparcfg_open,
-	release:	single_release,
+      owner:THIS_MODULE,
+      read:seq_read,
+      open:lparcfg_open,
+      release:single_release,
 };
 
 int __init lparcfg_init(void)
@@ -539,7 +546,8 @@ int __init lparcfg_init(void)
 		ent->proc_fops = &lparcfg_fops;
 		ent->data = kmalloc(LPARCFG_BUFF_SIZE, GFP_KERNEL);
 		if (!ent->data) {
-			printk(KERN_ERR "Failed to allocate buffer for lparcfg\n");
+			printk(KERN_ERR
+			       "Failed to allocate buffer for lparcfg\n");
 			remove_proc_entry("lparcfg", ent->parent);
 			return -ENOMEM;
 		}
@@ -556,7 +564,7 @@ void __exit lparcfg_cleanup(void)
 {
 	if (proc_ppc64_lparcfg) {
 		if (proc_ppc64_lparcfg->data) {
-		    kfree(proc_ppc64_lparcfg->data);
+			kfree(proc_ppc64_lparcfg->data);
 		}
 		remove_proc_entry("lparcfg", proc_ppc64_lparcfg->parent);
 	}