[PATCH] paride.c fed through Lindent

drivers/block/paride/paride.c

@@ -42,47 +42,47 @@
 
 #define MAX_PROTOS	32
 
-static struct pi_protocol	*protocols[MAX_PROTOS];
+static struct pi_protocol *protocols[MAX_PROTOS];
 
-static spinlock_t	pi_spinlock = SPIN_LOCK_UNLOCKED;
+static spinlock_t pi_spinlock = SPIN_LOCK_UNLOCKED;
 
-void pi_write_regr( PIA *pi, int cont, int regr, int val)
-
-{	pi->proto->write_regr(pi,cont,regr,val);
+void pi_write_regr(PIA * pi, int cont, int regr, int val)
+{
+	pi->proto->write_regr(pi, cont, regr, val);
 }
 
 EXPORT_SYMBOL(pi_write_regr);
 
-int pi_read_regr( PIA *pi, int cont, int regr)
-
-{	return pi->proto->read_regr(pi,cont,regr);
+int pi_read_regr(PIA * pi, int cont, int regr)
+{
+	return pi->proto->read_regr(pi, cont, regr);
 }
 
 EXPORT_SYMBOL(pi_read_regr);
 
-void pi_write_block( PIA *pi, char * buf, int count)
-
-{	pi->proto->write_block(pi,buf,count);
+void pi_write_block(PIA * pi, char *buf, int count)
+{
+	pi->proto->write_block(pi, buf, count);
 }
 
 EXPORT_SYMBOL(pi_write_block);
 
-void pi_read_block( PIA *pi, char * buf, int count)
-
-{       pi->proto->read_block(pi,buf,count);
+void pi_read_block(PIA * pi, char *buf, int count)
+{
+	pi->proto->read_block(pi, buf, count);
 }
 
 EXPORT_SYMBOL(pi_read_block);
 
 #ifdef CONFIG_PARPORT
 
-static void pi_wake_up( void *p)
-
-{       PIA  *pi = (PIA *) p;
+static void pi_wake_up(void *p)
+{
+	PIA *pi = (PIA *) p;
 	unsigned long flags;
-	void (*cont)(void) = NULL;
+	void (*cont) (void) = NULL;
 
-	spin_lock_irqsave(&pi_spinlock,flags);
+	spin_lock_irqsave(&pi_spinlock, flags);
 
 	if (pi->claim_cont && !parport_claim(pi->pardev)) {
 		cont = pi->claim_cont;
@@ -90,95 +90,91 @@ static void pi_wake_up( void *p)
 		pi->claimed = 1;
 	}
 
-	spin_unlock_irqrestore(&pi_spinlock,flags);	
+	spin_unlock_irqrestore(&pi_spinlock, flags);
 
 	wake_up(&(pi->parq));
 
-	if (cont) cont();
+	if (cont)
+		cont();
 }
 
 #endif
 
-void pi_do_claimed( PIA *pi, void(*cont)(void))
-
+void pi_do_claimed(PIA * pi, void (*cont) (void))
+{
 #ifdef CONFIG_PARPORT
+	unsigned long flags;
 
-{	unsigned long flags;
-
-	spin_lock_irqsave(&pi_spinlock,flags); 
+	spin_lock_irqsave(&pi_spinlock, flags);
 
-	if (!pi->pardev || !parport_claim(pi->pardev)) {
-		pi->claimed = 1;
-		spin_unlock_irqrestore(&pi_spinlock,flags);
-		cont();
-	} else {
+	if (pi->pardev && parport_claim(pi->pardev)) {
 		pi->claim_cont = cont;
-		spin_unlock_irqrestore(&pi_spinlock,flags);	
+		spin_unlock_irqrestore(&pi_spinlock, flags);
+		return;
 	}
+	pi->claimed = 1;
+	spin_unlock_irqrestore(&pi_spinlock, flags);
+#endif
+	cont();
 }
 
-#else
-
-{	cont();
-}
-
-#endif
 
 EXPORT_SYMBOL(pi_do_claimed);
 
-static void pi_claim( PIA *pi)
-
-{	if (pi->claimed) return;
+static void pi_claim(PIA * pi)
+{
+	if (pi->claimed)
+		return;
 	pi->claimed = 1;
 #ifdef CONFIG_PARPORT
-        if (pi->pardev)
-		wait_event (pi->parq,
-			    !parport_claim ((struct pardevice *)pi->pardev));
+	if (pi->pardev)
+		wait_event(pi->parq,
+			   !parport_claim((struct pardevice *) pi->pardev));
 #endif
 }
 
-static void pi_unclaim( PIA *pi)
-
-{	pi->claimed = 0;
+static void pi_unclaim(PIA * pi)
+{
+	pi->claimed = 0;
 #ifdef CONFIG_PARPORT
-        if (pi->pardev) parport_release((struct pardevice *)(pi->pardev));
-#endif 
+	if (pi->pardev)
+		parport_release((struct pardevice *) (pi->pardev));
+#endif
 }
 
-void pi_connect( PIA *pi)
-
-{	pi_claim(pi);
+void pi_connect(PIA * pi)
+{
+	pi_claim(pi);
 	pi->proto->connect(pi);
 }
 
 EXPORT_SYMBOL(pi_connect);
 
-void pi_disconnect( PIA *pi)
-
-{	pi->proto->disconnect(pi);
+void pi_disconnect(PIA * pi)
+{
+	pi->proto->disconnect(pi);
 	pi_unclaim(pi);
 }
 
 EXPORT_SYMBOL(pi_disconnect);
 
-static void pi_unregister_parport( PIA *pi)
-
+static void pi_unregister_parport(PIA * pi)
 {
 #ifdef CONFIG_PARPORT
-        if (pi->pardev) {
-           parport_unregister_device((struct pardevice *)(pi->pardev));
-	   pi->pardev = NULL;
+	if (pi->pardev) {
+		parport_unregister_device((struct pardevice *) (pi->pardev));
+		pi->pardev = NULL;
 	}
 #endif
 }
 
-void pi_release( PIA *pi)
-
-{	pi_unregister_parport(pi);
+void pi_release(PIA * pi)
+{
+	pi_unregister_parport(pi);
 #ifndef CONFIG_PARPORT
 	if (pi->reserved)
-		release_region(pi->port,pi->reserved);
-#endif /* !CONFIG_PARPORT */
+		release_region(pi->port, pi->reserved);
+#endif				/* !CONFIG_PARPORT */
 	pi->proto->release_proto(pi);
 }
 
@@ -187,50 +183,53 @@ EXPORT_SYMBOL(pi_release);
 #define WR(r,v)         pi_write_regr(pi,0,r,v)
 #define RR(r)           (pi_read_regr(pi,0,r))
 
-static int pi_test_proto( PIA *pi, char * scratch, int verbose )
-
-{       int     j, k;
-        int     e[2] = {0,0};
+static int pi_test_proto(PIA * pi, char *scratch, int verbose)
+{
+	int j, k;
+	int e[2] = { 0, 0 };
 
 	if (pi->proto->test_proto) {
 		pi_claim(pi);
-		j = pi->proto->test_proto(pi,scratch,verbose);
+		j = pi->proto->test_proto(pi, scratch, verbose);
 		pi_unclaim(pi);
 		return j;
 	}
 
-        pi_connect(pi);
+	pi_connect(pi);
 
-        for (j=0;j<2;j++) {
-                WR(6,0xa0+j*0x10);
-                for (k=0;k<256;k++) {
-                        WR(2,k^0xaa);
-                        WR(3,k^0x55);
-                        if (RR(2) != (k^0xaa)) e[j]++;
-                        }
-                }
+	for (j = 0; j < 2; j++) {
+		WR(6, 0xa0 + j * 0x10);
+		for (k = 0; k < 256; k++) {
+			WR(2, k ^ 0xaa);
+			WR(3, k ^ 0x55);
+			if (RR(2) != (k ^ 0xaa))
+				e[j]++;
+		}
+	}
 
-        pi_disconnect(pi);
+	pi_disconnect(pi);
 
-        if (verbose)
-                printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
-                        pi->device,pi->proto->name,pi->port,
-			pi->mode,e[0],e[1]);
+	if (verbose)
+		printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
+		       pi->device, pi->proto->name, pi->port,
+		       pi->mode, e[0], e[1]);
 
-        return (e[0] && e[1]);  /* not here if both > 0 */
+	return (e[0] && e[1]);	/* not here if both > 0 */
 }
 
-int  pi_register( PIP *pr)
-
-{	int k;
+int pi_register(PIP * pr)
+{
+	int k;
 
-	for (k=0;k<MAX_PROTOS;k++) 
-	   if (protocols[k] && !strcmp(pr->name,protocols[k]->name)) {
-		printk("paride: %s protocol already registered\n",pr->name);
-		return 0;
-	   }
+	for (k = 0; k < MAX_PROTOS; k++)
+		if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
+			printk("paride: %s protocol already registered\n",
+			       pr->name);
+			return 0;
+		}
 	k = 0;
-	while((k<MAX_PROTOS) && (protocols[k])) k++;
+	while ((k < MAX_PROTOS) && (protocols[k]))
+		k++;
 	if (k == MAX_PROTOS) {
 		printk("paride: protocol table full\n");
 		return 0;
@@ -238,194 +237,209 @@ int  pi_register( PIP *pr)
 	MOD_INC_USE_COUNT;
 	protocols[k] = pr;
 	pr->index = k;
-	printk("paride: %s registered as protocol %d\n",pr->name,k);
+	printk("paride: %s registered as protocol %d\n", pr->name, k);
 	return 1;
-}	
+}
 
 EXPORT_SYMBOL(pi_register);
 
-void pi_unregister( PIP *pr)
-
-{	if (!pr) return;
+void pi_unregister(PIP * pr)
+{
+	if (!pr)
+		return;
 	if (protocols[pr->index] != pr) {
-		printk("paride: %s not registered\n",pr->name);
+		printk("paride: %s not registered\n", pr->name);
 		return;
-	} 
+	}
 	protocols[pr->index] = 0;
 	MOD_DEC_USE_COUNT;
 }
 
 EXPORT_SYMBOL(pi_unregister);
 
-static int pi_register_parport( PIA *pi, int verbose)
-
+static int pi_register_parport(PIA * pi, int verbose)
 {
 #ifdef CONFIG_PARPORT
 
 	struct parport *port;
 
-	port = parport_find_base (pi->port);
+	port = parport_find_base(pi->port);
 	if (!port)
-	  return 0;
+		return 0;
 
 	pi->pardev = parport_register_device(port,
-					     pi->device,NULL,
-					     pi_wake_up,NULL,
-					     0,(void *)pi);
-	parport_put_port (port);
+					     pi->device, NULL,
+					     pi_wake_up, NULL, 0, (void *) pi);
+	parport_put_port(port);
 	if (!pi->pardev)
-	  return 0;
+		return 0;
 
 	init_waitqueue_head(&pi->parq);
 
-	if (verbose) printk("%s: 0x%x is %s\n",pi->device,pi->port,
-			    port->name);
-	
-	pi->parname = (char *)port->name;
+	if (verbose)
+		printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
+
+	pi->parname = (char *) port->name;
 #endif
 
 	return 1;
 }
 
-static int pi_probe_mode( PIA *pi, int max, char * scratch, int verbose)
-
-{	int	best, range;
+static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
+{
+	int best, range;
 
 	if (pi->mode != -1) {
-		if (pi->mode >= max) return 0;
+		if (pi->mode >= max)
+			return 0;
 		range = 3;
-		if (pi->mode >= pi->proto->epp_first) range = 8;
-		if ((range == 8) && (pi->port % 8)) return 0;
+		if (pi->mode >= pi->proto->epp_first)
+			range = 8;
+		if ((range == 8) && (pi->port % 8))
+			return 0;
 		pi->reserved = range;
-		return (!pi_test_proto(pi,scratch,verbose));
+		return (!pi_test_proto(pi, scratch, verbose));
 	}
 	best = -1;
-	for(pi->mode=0;pi->mode<max;pi->mode++) {
+	for (pi->mode = 0; pi->mode < max; pi->mode++) {
 		range = 3;
-		if (pi->mode >= pi->proto->epp_first) range = 8;
-		if ((range == 8) && (pi->port % 8)) break;
+		if (pi->mode >= pi->proto->epp_first)
+			range = 8;
+		if ((range == 8) && (pi->port % 8))
+			break;
 		pi->reserved = range;
-		if (!pi_test_proto(pi,scratch,verbose)) best = pi->mode;
+		if (!pi_test_proto(pi, scratch, verbose))
+			best = pi->mode;
 	}
 	pi->mode = best;
 	return (best > -1);
 }
 
-static int pi_probe_unit( PIA *pi, int unit, char * scratch, int verbose)
-
-{	int max,s,e;
+static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
+{
+	int max, s, e;
 
-	s = unit; e = s+1;
+	s = unit;
+	e = s + 1;
 
-	if (s == -1) { 
-		s = 0; 
-		e = pi->proto->max_units; 
+	if (s == -1) {
+		s = 0;
+		e = pi->proto->max_units;
 	}
 
-	if (!pi_register_parport(pi,verbose))
-	  return 0;
+	if (!pi_register_parport(pi, verbose))
+		return 0;
 
 	if (pi->proto->test_port) {
 		pi_claim(pi);
 		max = pi->proto->test_port(pi);
 		pi_unclaim(pi);
-	}
-	else max = pi->proto->max_mode;
+	} else
+		max = pi->proto->max_mode;
 
 	if (pi->proto->probe_unit) {
-	   pi_claim(pi);
-	   for (pi->unit=s;pi->unit<e;pi->unit++)
-	      if (pi->proto->probe_unit(pi)) {
-		 pi_unclaim(pi);
-		 if (pi_probe_mode(pi,max,scratch,verbose)) return 1;
-	         pi_unregister_parport(pi); 
-		 return 0;
-	         }
-	   pi_unclaim(pi);
-	   pi_unregister_parport(pi); 
-	   return 0;
-	   }
-
-	if (!pi_probe_mode(pi,max,scratch,verbose)) {
-	   pi_unregister_parport(pi); 
-	   return 0;
+		pi_claim(pi);
+		for (pi->unit = s; pi->unit < e; pi->unit++)
+			if (pi->proto->probe_unit(pi)) {
+				pi_unclaim(pi);
+				if (pi_probe_mode(pi, max, scratch, verbose))
+					return 1;
+				pi_unregister_parport(pi);
+				return 0;
+			}
+		pi_unclaim(pi);
+		pi_unregister_parport(pi);
+		return 0;
+	}
+
+	if (!pi_probe_mode(pi, max, scratch, verbose)) {
+		pi_unregister_parport(pi);
+		return 0;
 	}
 	return 1;
-		
-}
 
-int pi_init(PIA *pi, int autoprobe, int port, int mode, 
-	    int unit, int protocol, int delay, char * scratch, 
-	    int devtype, int verbose, char *device )
+}
 
-{	int p,k,s,e;
-	int lpts[7] = {0x3bc,0x378,0x278,0x268,0x27c,0x26c,0};
+int pi_init(PIA * pi, int autoprobe, int port, int mode,
+	int unit, int protocol, int delay, char *scratch,
+	int devtype, int verbose, char *device)
+{
+	int p, k, s, e;
+	int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
 
-	s = protocol; e = s+1;
+	s = protocol;
+	e = s + 1;
 
 	if (!protocols[0])
-		request_module ("paride_protocol");
+		request_module("paride_protocol");
 
 	if (autoprobe) {
-		s = 0; 
+		s = 0;
 		e = MAX_PROTOS;
 	} else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
-		    (!protocols[s]) || (unit < 0) || 
-		    (unit >= protocols[s]->max_units)) {
-			printk("%s: Invalid parameters\n",device);
-			return 0;
-		        }
-
-	for (p=s;p<e;p++) {
-	  if (protocols[p]) {
-		pi->proto = protocols[p];
-		pi->private = 0;
-		pi->proto->init_proto(pi);
-		if (delay == -1) pi->delay = pi->proto->default_delay;
-		  else pi->delay = delay;
-		pi->devtype = devtype;
-		pi->device = device;
-
-		pi->parname = NULL;
-		pi->pardev = NULL;
-		init_waitqueue_head(&pi->parq);
-		pi->claimed = 0;
-		pi->claim_cont = NULL;
-	        
-		pi->mode = mode;
-		if (port != -1) {
-			pi->port = port;
-			if (pi_probe_unit(pi,unit,scratch,verbose)) break;
-			pi->port = 0;
-		} else { 
-			k = 0;
-			while ((pi->port = lpts[k++]))
-			   if (pi_probe_unit(pi,unit,scratch,verbose)) break;
-      			if (pi->port) break;
+		   (!protocols[s]) || (unit < 0) ||
+		   (unit >= protocols[s]->max_units)) {
+		printk("%s: Invalid parameters\n", device);
+		return 0;
+	}
+
+	for (p = s; p < e; p++) {
+		if (protocols[p]) {
+			pi->proto = protocols[p];
+			pi->private = 0;
+			pi->proto->init_proto(pi);
+			if (delay == -1)
+				pi->delay = pi->proto->default_delay;
+			else
+				pi->delay = delay;
+			pi->devtype = devtype;
+			pi->device = device;
+
+			pi->parname = NULL;
+			pi->pardev = NULL;
+			init_waitqueue_head(&pi->parq);
+			pi->claimed = 0;
+			pi->claim_cont = NULL;
+
+			pi->mode = mode;
+			if (port != -1) {
+				pi->port = port;
+				if (pi_probe_unit(pi, unit, scratch, verbose))
+					break;
+				pi->port = 0;
+			} else {
+				k = 0;
+				while ((pi->port = lpts[k++]))
+					if (pi_probe_unit
+					    (pi, unit, scratch, verbose))
+						break;
+				if (pi->port)
+					break;
+			}
+			pi->proto->release_proto(pi);
 		}
-		pi->proto->release_proto(pi);
-	  }
 	}
 
 	if (!pi->port) {
-		if (autoprobe) printk("%s: Autoprobe failed\n",device);
-		else printk("%s: Adapter not found\n",device);
+		if (autoprobe)
+			printk("%s: Autoprobe failed\n", device);
+		else
+			printk("%s: Adapter not found\n", device);
 		return 0;
 	}
-
 #ifndef CONFIG_PARPORT
-	if (!request_region(pi->port,pi->reserved,pi->device))
-		{
-		printk(KERN_WARNING"paride: Unable to request region 0x%x\n", pi->port);
+	if (!request_region(pi->port, pi->reserved, pi->device)) {
+		printk(KERN_WARNING "paride: Unable to request region 0x%x\n",
+		       pi->port);
 		return 0;
-		}
-#endif /* !CONFIG_PARPORT */
+	}
+#endif				/* !CONFIG_PARPORT */
 
 	if (pi->parname)
-	   printk("%s: Sharing %s at 0x%x\n",pi->device,
-			pi->parname,pi->port);
+		printk("%s: Sharing %s at 0x%x\n", pi->device,
+		       pi->parname, pi->port);
 
-	pi->proto->log_adapter(pi,scratch,verbose);
+	pi->proto->log_adapter(pi, scratch, verbose);
 
 	return 1;
 }