xpp: style - Run Lindent

* Here it is:
  KERNEL_STYLE="-npro -kr -i8 -ts8 -sob -l80 -ss -ncs -cp1"
  TYPEDEFS='
	-T gfp_t
	-T __user
	-T u_char
	-T __u8
	-T byte
	-T bool
	-T charp
	-T xusb_t
	-T xbus_t
	-T xpd_t
	-T xproto_table_t
	-T xproto_entry_t
	-T xframe_t
	-T xpacket_t
	-T reg_cmd_t
	'

  indent $TYPEDEFS $KERNEL_STYLE \
	--ignore-newlines	\
	--indent-label0	\
	--no-space-after-function-call-names	\
	"$@"

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Acked-By: Tzafrir Cohen <tzafrir.cohen@xorcom.com>

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10428 a0bf4364-ded3-4de4-8d8a-66a801d63aff

1 files changed, 284 insertions, 235 deletions

diff --git a/drivers/dahdi/xpp/xbus-pcm.c b/drivers/dahdi/xpp/xbus-pcm.c
index f597a47..2e24db4 100644
--- a/drivers/dahdi/xpp/xbus-pcm.c
+++ b/drivers/dahdi/xpp/xbus-pcm.c
@@ -22,7 +22,7 @@
 #include <linux/version.h>
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
-#  warning "This module is tested only with 2.6 kernels"
+#warning "This module is tested only with 2.6 kernels"
 #endif
 
 #include <linux/kernel.h>
@@ -37,29 +37,32 @@ static const char rcsid[] = "$Id$";
 
 extern int debug;
 #ifdef	OPTIMIZE_CHANMUTE
-static DEF_PARM_BOOL(optimize_chanmute, 1, 0644, "Optimize by muting inactive channels");
+static DEF_PARM_BOOL(optimize_chanmute, 1, 0644,
+		     "Optimize by muting inactive channels");
 #endif
 
 static DEF_PARM(int, disable_pcm, 0, 0644, "Disable all PCM transmissions");
 #ifdef	DEBUG_PCMTX
-DEF_PARM(int, pcmtx, -1, 0644, "Forced PCM value to transmit (negative to disable)");
+DEF_PARM(int, pcmtx, -1, 0644,
+	 "Forced PCM value to transmit (negative to disable)");
 DEF_PARM(int, pcmtx_chan, 0, 0644, "channel to force PCM value");
 #endif
-static DEF_PARM_BOOL(disable_pll_sync, 0, 0644, "Disable automatic adjustment of AB clocks");
+static DEF_PARM_BOOL(disable_pll_sync, 0, 0644,
+		     "Disable automatic adjustment of AB clocks");
 
-static xbus_t			*syncer;		/* current syncer */
-static atomic_t			xpp_tick_counter = ATOMIC_INIT(0);
-static struct xpp_ticker	dahdi_ticker;
+static xbus_t *syncer;		/* current syncer */
+static atomic_t xpp_tick_counter = ATOMIC_INIT(0);
+static struct xpp_ticker dahdi_ticker;
 /*
  * The ref_ticker points to the current referece tick source.
  * I.e: one of our AB or dahdi_ticker
  */
-static struct xpp_ticker	*ref_ticker;
+static struct xpp_ticker *ref_ticker;
 static DEFINE_SPINLOCK(ref_ticker_lock);
 static DEFINE_SPINLOCK(elect_syncer_lock);
-static bool			force_dahdi_sync;	/* from /sys/bus/astribanks/drivers/xppdrv/sync */
-static xbus_t			*global_ticker;
-static struct xpp_ticker	global_ticks_series;
+static bool force_dahdi_sync;	/* from /sys/bus/astribanks/drivers/xppdrv/sync */
+static xbus_t *global_ticker;
+static struct xpp_ticker global_ticks_series;
 
 #define	PROC_SYNC		"sync"
 #define SYNC_CYCLE		500	/* Sampling cycle in usec */
@@ -80,7 +83,7 @@ static struct xpp_ticker	global_ticks_series;
 #define	SYNC_ADJ_SLOW	10000
 
 #ifdef	DAHDI_SYNC_TICK
-static unsigned int		dahdi_tick_count;
+static unsigned int dahdi_tick_count;
 #endif
 
 /*------------------------- SYNC Handling --------------------------*/
@@ -89,7 +92,7 @@ static void send_drift(xbus_t *xbus, int drift);
 
 static void ticker_set_cycle(struct xpp_ticker *ticker, int cycle)
 {
-	unsigned long	flags;
+	unsigned long flags;
 
 	spin_lock_irqsave(&ticker->lock, flags);
 	if (cycle < SYNC_ADJ_QUICK)
@@ -111,16 +114,16 @@ static void xpp_ticker_init(struct xpp_ticker *ticker)
 
 static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t)
 {
-	unsigned long	flags;
-	long		usec;
-	bool		cycled = 0;
+	unsigned long flags;
+	long usec;
+	bool cycled = 0;
 
 	spin_lock_irqsave(&ticker->lock, flags);
 	ticker->last_sample.tv = *t;
 	if ((ticker->count % ticker->cycle) == ticker->cycle - 1) {	/* rate adjust */
-		usec = (long)usec_diff(
-				&ticker->last_sample.tv,
-				&ticker->first_sample.tv);
+		usec =
+		    (long)usec_diff(&ticker->last_sample.tv,
+				    &ticker->first_sample.tv);
 		ticker->first_sample = ticker->last_sample;
 		ticker->tick_period = usec / ticker->cycle;
 		cycled = 1;
@@ -137,12 +140,12 @@ static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t)
  */
 static inline void xbus_drift_clear(xbus_t *xbus)
 {
-	struct xpp_drift	*di = &xbus->drift;
+	struct xpp_drift *di = &xbus->drift;
 
 	do_gettimeofday(&di->last_lost_tick.tv);
 	ticker_set_cycle(&xbus->ticker, SYNC_ADJ_QUICK);
 	di->max_speed = -SYNC_ADJ_MAX;
-	di->min_speed =  SYNC_ADJ_MAX;
+	di->min_speed = SYNC_ADJ_MAX;
 }
 
 void xpp_drift_init(xbus_t *xbus)
@@ -184,9 +187,9 @@ static void sample_tick(xbus_t *xbus, int sample)
  */
 static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 {
-	struct xpp_drift	*di = &xbus->drift;
-	struct xpp_ticker	*ticker = &xbus->ticker;
-	unsigned long		flags;
+	struct xpp_drift *di = &xbus->drift;
+	struct xpp_ticker *ticker = &xbus->ticker;
+	unsigned long flags;
 
 	spin_lock_irqsave(&di->lock, flags);
 	xpp_ticker_step(&xbus->ticker, tv);
@@ -194,14 +197,15 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 	 * Do we need to be synchronized and is there an established reference
 	 * ticker (another Astribank or another DAHDI device) already?
 	 */
-	if (ref_ticker && ref_ticker != &xbus->ticker && syncer && xbus->sync_mode == SYNC_MODE_PLL) {
-		int	new_delta_tick = ticker->count - ref_ticker->count;
-		int	lost_ticks = new_delta_tick - di->delta_tick;
-		long	usec_delta;
+	if (ref_ticker && ref_ticker != &xbus->ticker && syncer
+	    && xbus->sync_mode == SYNC_MODE_PLL) {
+		int new_delta_tick = ticker->count - ref_ticker->count;
+		int lost_ticks = new_delta_tick - di->delta_tick;
+		long usec_delta;
 
 		di->delta_tick = new_delta_tick;
 		if (lost_ticks) {
-			static int	rate_limit;
+			static int rate_limit;
 
 			/*
 			 * We just lost some ticks. Just report it and don't
@@ -215,8 +219,8 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 				 * startup.
 				 */
 				XBUS_DBG(SYNC, xbus, "Lost %d tick%s\n",
-					lost_ticks,
-					(abs(lost_ticks) > 1) ? "s": "");
+					 lost_ticks,
+					 (abs(lost_ticks) > 1) ? "s" : "");
 			}
 			if (abs(lost_ticks) > 100) {
 				xbus_drift_clear(xbus);
@@ -224,24 +228,28 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 			}
 		} else {
 			/* Sample a delta */
-			usec_delta = (long)usec_diff(
-					&ticker->last_sample.tv,
-					&ref_ticker->last_sample.tv);
+			usec_delta =
+			    (long)usec_diff(&ticker->last_sample.tv,
+					    &ref_ticker->last_sample.tv);
 			sample_tick(xbus, usec_delta);
-			if ((ticker->count % SYNC_CYCLE) > (SYNC_CYCLE - SYNC_CYCLE_SAMPLE))
-				di->delta_sum  += usec_delta;
+			if ((ticker->count % SYNC_CYCLE) >
+			    (SYNC_CYCLE - SYNC_CYCLE_SAMPLE))
+				di->delta_sum += usec_delta;
 
 			if ((ticker->count % SYNC_CYCLE) == 0) {
 				/*
 				 * Full sampling cycle passed. Let's calculate
 				 */
-				int	offset		= di->delta_sum / SYNC_CYCLE_SAMPLE - SYNC_CENTER;
-				int	offset_prev	= di->offset_prev;
-				int	speed		= xbus->sync_adjustment;
-				int	fix		= 0;
-				int	best_speed	= (di->max_speed + di->min_speed) >> 1;
-
-				if      (offset > 0 && offset < SYNC_DELTA) {
+				int offset =
+				    di->delta_sum / SYNC_CYCLE_SAMPLE -
+				    SYNC_CENTER;
+				int offset_prev = di->offset_prev;
+				int speed = xbus->sync_adjustment;
+				int fix = 0;
+				int best_speed =
+				    (di->max_speed + di->min_speed) >> 1;
+
+				if (offset > 0 && offset < SYNC_DELTA) {
 					speed = best_speed - 1;
 				} else if (offset < 0 && offset > -SYNC_DELTA) {
 					speed = best_speed + 1;
@@ -258,26 +266,32 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 				if (speed < -SYNC_ADJ_MAX)
 					speed = -SYNC_ADJ_MAX;
 				if (speed > SYNC_ADJ_MAX)
-					speed =  SYNC_ADJ_MAX;
+					speed = SYNC_ADJ_MAX;
 				if (speed < di->min_speed)
-					di->min_speed    = speed;
+					di->min_speed = speed;
 				if (speed > di->max_speed)
-					di->max_speed    = speed;
+					di->max_speed = speed;
 				if (offset > di->offset_max)
 					di->offset_max = offset;
 				if (offset < di->offset_min)
 					di->offset_min = offset;
 
-				XBUS_DBG(SYNC, xbus, "offset: %d, min_speed=%d, max_speed=%d, usec_delta(last)=%ld\n",
-					 offset_prev, di->min_speed, di->max_speed, usec_delta);
-				XBUS_DBG(SYNC, xbus, "ADJ: speed=%d (best_speed=%d) fix=%d\n",
-					speed, best_speed, fix);
+				XBUS_DBG(SYNC, xbus,
+					 "offset: %d, min_speed=%d, max_speed=%d, usec_delta(last)=%ld\n",
+					 offset_prev, di->min_speed,
+					 di->max_speed, usec_delta);
+				XBUS_DBG(SYNC, xbus,
+					 "ADJ: speed=%d (best_speed=%d) fix=%d\n",
+					 speed, best_speed, fix);
 				xbus->sync_adjustment_offset = speed;
-				if (xbus != syncer && xbus->sync_adjustment != speed)
+				if (xbus != syncer
+				    && xbus->sync_adjustment != speed)
 					send_drift(xbus, speed);
-				di->sync_inaccuracy = abs(offset) + abs(di->offset_range) / 2;
+				di->sync_inaccuracy =
+				    abs(offset) + abs(di->offset_range) / 2;
 				if (ticker->count >= SYNC_CYCLE * SYNC_CONVERGE) {
-					di->offset_range = di->offset_max - di->offset_min;
+					di->offset_range =
+					    di->offset_max - di->offset_min;
 					di->offset_min = INT_MAX;
 					di->offset_max = -INT_MAX;
 					if (di->max_speed > best_speed)
@@ -286,7 +300,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 						di->min_speed++;
 				}
 				di->offset_prev = offset;
-				di->delta_sum      = 0;
+				di->delta_sum = 0;
 			}
 		}
 	}
@@ -295,11 +309,11 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
 
 const char *sync_mode_name(enum sync_mode mode)
 {
-	static const char	*sync_mode_names[] = {
-		[SYNC_MODE_AB]		= "AB",
-		[SYNC_MODE_NONE]	= "NONE",
-		[SYNC_MODE_PLL]		= "PLL",
-		[SYNC_MODE_QUERY]	= "QUERY",
+	static const char *sync_mode_names[] = {
+		[SYNC_MODE_AB] = "AB",
+		[SYNC_MODE_NONE] = "NONE",
+		[SYNC_MODE_PLL] = "PLL",
+		[SYNC_MODE_QUERY] = "QUERY",
 	};
 	if (mode >= ARRAY_SIZE(sync_mode_names))
 		return NULL;
@@ -311,7 +325,7 @@ const char *sync_mode_name(enum sync_mode mode)
  */
 static void xpp_set_syncer(xbus_t *xbus, bool on)
 {
-	if (!xbus) {	/* Special case, no more syncers */
+	if (!xbus) {		/* Special case, no more syncers */
 		DBG(SYNC, "No more syncers\n");
 		syncer = NULL;
 		if (ref_ticker != &dahdi_ticker)
@@ -328,14 +342,14 @@ static void xpp_set_syncer(xbus_t *xbus, bool on)
 			ref_ticker = NULL;
 	} else
 		XBUS_DBG(SYNC, xbus, "ignore %s (current syncer: %s)\n",
-			(on)?"ON":"OFF",
-			(syncer) ? syncer->busname : "NO-SYNC");
+			 (on) ? "ON" : "OFF",
+			 (syncer) ? syncer->busname : "NO-SYNC");
 }
 
 static void xbus_command_timer(unsigned long param)
 {
-	xbus_t		*xbus = (xbus_t *)param;
-	struct timeval	now;
+	xbus_t *xbus = (xbus_t *)param;
+	struct timeval now;
 
 	BUG_ON(!xbus);
 	do_gettimeofday(&now);
@@ -346,7 +360,7 @@ static void xbus_command_timer(unsigned long param)
 
 void xbus_set_command_timer(xbus_t *xbus, bool on)
 {
-	XBUS_DBG(SYNC, xbus, "%s\n", (on)?"ON":"OFF");
+	XBUS_DBG(SYNC, xbus, "%s\n", (on) ? "ON" : "OFF");
 	if (on) {
 		if (!timer_pending(&xbus->command_timer)) {
 			XBUS_DBG(SYNC, xbus, "add_timer\n");
@@ -359,7 +373,7 @@ void xbus_set_command_timer(xbus_t *xbus, bool on)
 		XBUS_DBG(SYNC, xbus, "del_timer\n");
 		del_timer(&xbus->command_timer);
 	}
-	xbus->self_ticking = ! on;
+	xbus->self_ticking = !on;
 }
 
 /*
@@ -367,19 +381,20 @@ void xbus_set_command_timer(xbus_t *xbus, bool on)
  */
 void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift)
 {
-	unsigned long	flags;
-	unsigned long	flags2;
+	unsigned long flags;
+	unsigned long flags2;
 
 	spin_lock_irqsave(&xbus->lock, flags);
 	spin_lock_irqsave(&ref_ticker_lock, flags2);
 	xbus->sync_adjustment = (signed char)drift;
 	if (xbus->sync_mode == mode) {
 		XBUS_DBG(SYNC, xbus, "Already in mode '%s'. Ignored\n",
-				sync_mode_name(mode));
+			 sync_mode_name(mode));
 		goto out;
 	}
 	XBUS_DBG(SYNC, xbus, "Mode %s (%d), drift=%d (pcm_rx_counter=%d)\n",
-		sync_mode_name(mode), mode, drift, atomic_read(&xbus->pcm_rx_counter));
+		 sync_mode_name(mode), mode, drift,
+		 atomic_read(&xbus->pcm_rx_counter));
 	switch (mode) {
 	case SYNC_MODE_AB:
 		xbus->sync_mode = mode;
@@ -393,12 +408,12 @@ void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift)
 		xpp_set_syncer(xbus, 0);
 		global_ticker = xbus;
 		break;
-	case SYNC_MODE_NONE:		/* lost sync source */
+	case SYNC_MODE_NONE:	/* lost sync source */
 		xbus->sync_mode = mode;
 		xbus_set_command_timer(xbus, 1);
 		xpp_set_syncer(xbus, 0);
 		break;
-	case SYNC_MODE_QUERY:		/* ignore           */
+	case SYNC_MODE_QUERY:	/* ignore           */
 		break;
 	default:
 		XBUS_ERR(xbus, "%s: unknown mode=0x%X\n", __func__, mode);
@@ -410,7 +425,7 @@ out:
 
 void xbus_request_sync(xbus_t *xbus, enum sync_mode mode)
 {
-	unsigned long	flags;
+	unsigned long flags;
 
 	BUG_ON(!xbus);
 	XBUS_DBG(SYNC, xbus, "sent request (mode=%d)\n", mode);
@@ -436,11 +451,11 @@ void xbus_request_sync(xbus_t *xbus, enum sync_mode mode)
 
 static void reset_sync_counters(void)
 {
-	int	i;
+	int i;
 
 	//DBG(SYNC, "%d\n", atomic_read(&xpp_tick_counter));
 	for (i = 0; i < MAX_BUSES; i++) {
-		xbus_t	*xbus = get_xbus(__func__, i);
+		xbus_t *xbus = get_xbus(__func__, i);
 
 		if (xbus == NULL)
 			continue;
@@ -448,15 +463,16 @@ static void reset_sync_counters(void)
 		 * Don't send to non self_ticking Astribanks:
 		 *  - Maybe they didn't finish initialization
 		 *  - Or maybe they didn't answer us in the first place
-		      (e.g: wrong firmware version, etc).
+		 (e.g: wrong firmware version, etc).
 		 */
 		if (xbus->self_ticking) {
 			if (!XBUS_FLAGS(xbus, CONNECTED)) {
 				XBUS_DBG(GENERAL, xbus,
-					"Dropped packet. Is shutting down.\n");
+					 "Dropped packet. Is shutting down.\n");
 			} else {
 				/* Reset sync LEDs once in a while */
-				CALL_PROTO(GLOBAL, RESET_SYNC_COUNTERS, xbus, NULL);
+				CALL_PROTO(GLOBAL, RESET_SYNC_COUNTERS, xbus,
+					   NULL);
 			}
 		}
 		put_xbus(__func__, xbus);
@@ -465,8 +481,8 @@ static void reset_sync_counters(void)
 
 static void send_drift(xbus_t *xbus, int drift)
 {
-	struct timeval          now;
-	const char              *msg;
+	struct timeval now;
+	const char *msg;
 
 	BUG_ON(abs(drift) > SYNC_ADJ_MAX);
 	do_gettimeofday(&now);
@@ -474,17 +490,19 @@ static void send_drift(xbus_t *xbus, int drift)
 		msg = "up";
 	else
 		msg = "down";
-	XBUS_DBG(SYNC, xbus, "%sDRIFT adjust %s (%d) (last update %ld seconds ago)\n",
-		(disable_pll_sync) ? "Fake " : "",
-		msg, drift, now.tv_sec - xbus->pll_updated_at);
+	XBUS_DBG(SYNC, xbus,
+		 "%sDRIFT adjust %s (%d) (last update %ld seconds ago)\n",
+		 (disable_pll_sync) ? "Fake " : "", msg, drift,
+		 now.tv_sec - xbus->pll_updated_at);
 	if (!disable_pll_sync)
-		CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL, drift);
+		CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL,
+			   drift);
 	xbus->pll_updated_at = now.tv_sec;
 }
 
 static void global_tick(void)
 {
-	struct timeval	now;
+	struct timeval now;
 
 	do_gettimeofday(&now);
 	atomic_inc(&xpp_tick_counter);
@@ -496,10 +514,10 @@ static void global_tick(void)
 #ifdef	DAHDI_SYNC_TICK
 void dahdi_sync_tick(struct dahdi_span *span, int is_master)
 {
-	struct phonedev	*phonedev = container_of(span, struct phonedev, span);
-	xpd_t		*xpd = container_of(phonedev, struct xpd, phonedev);
-	static int	redundant_ticks;	/* for extra spans */
-	struct timeval	now;
+	struct phonedev *phonedev = container_of(span, struct phonedev, span);
+	xpd_t *xpd = container_of(phonedev, struct xpd, phonedev);
+	static int redundant_ticks;	/* for extra spans */
+	struct timeval now;
 
 	if (!force_dahdi_sync)
 		goto noop;
@@ -509,25 +527,26 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master)
 	 * Detect if any of our spans is dahdi sync master
 	 */
 	if (is_master) {
-		static int	rate_limit;
+		static int rate_limit;
 
 		if ((rate_limit++ % 10003) == 0)
-			XPD_NOTICE(xpd, "Is a DAHDI sync master: ignore sync from DAHDI\n");
+			XPD_NOTICE(xpd,
+				   "Is a DAHDI sync master: ignore sync from DAHDI\n");
 		goto noop;
 	}
 	/* Now we know for sure someone else is dahdi sync master */
 	if (syncer) {
-		static int	rate_limit;
+		static int rate_limit;
 
 		if ((rate_limit++ % 5003) == 0)
 			XBUS_DBG(SYNC, syncer,
-				"is a SYNCer: ignore sync from DAHDI\n");
+				 "is a SYNCer: ignore sync from DAHDI\n");
 		goto noop;
 	}
 	/* ignore duplicate calls from all our registered spans */
 	if ((redundant_ticks++ % total_registered_spans()) != 0) {
 #if 0
-		static int	rate_limit;
+		static int rate_limit;
 
 		if ((rate_limit++ % 1003) < 16)
 			XPD_NOTICE(xpd, "boop (%d)\n", dahdi_tick_count);
@@ -549,16 +568,15 @@ noop:
  */
 static void update_sync_master(xbus_t *new_syncer, bool force_dahdi)
 {
-	const char	*msg;
-	int		i;
-	unsigned long	flags;
+	const char *msg;
+	int i;
+	unsigned long flags;
 
 	WARN_ON(new_syncer && force_dahdi);	/* Ambigous */
 	force_dahdi_sync = force_dahdi;
 	msg = (force_dahdi_sync) ? "DAHDI" : "NO-SYNC";
-	DBG(SYNC, "%s => %s\n",
-		(syncer) ? syncer->busname : msg,
-		(new_syncer) ? new_syncer->busname : msg);
+	DBG(SYNC, "%s => %s\n", (syncer) ? syncer->busname : msg,
+	    (new_syncer) ? new_syncer->busname : msg);
 	/*
 	 * This global locking protects:
 	 *   - The ref_ticker so it won't be used while we change it.
@@ -575,7 +593,7 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi)
 		xbus_drift_clear(syncer);	/* Clean old data */
 	if (new_syncer) {
 		XBUS_DBG(SYNC, new_syncer, "pcm_rx_counter=%d\n",
-			atomic_read(&new_syncer->pcm_rx_counter));
+			 atomic_read(&new_syncer->pcm_rx_counter));
 		force_dahdi_sync = 0;
 		ref_ticker = &new_syncer->ticker;
 		xbus_drift_clear(new_syncer);	/* Clean new data */
@@ -590,15 +608,16 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi)
 	DBG(SYNC, "stop unwanted syncers\n");
 	/* Shut all down except the wanted sync master */
 	for (i = 0; i < MAX_BUSES; i++) {
-		xbus_t	*xbus = get_xbus(__func__, i);
+		xbus_t *xbus = get_xbus(__func__, i);
 		if (xbus == NULL)
 			continue;
 		if (XBUS_FLAGS(xbus, CONNECTED) && xbus != new_syncer) {
 			if (xbus->self_ticking)
 				xbus_request_sync(xbus,
-						xbus->sync_mode_default);
+						  xbus->sync_mode_default);
 			else
-				XBUS_DBG(SYNC, xbus, "Not self_ticking yet. Ignore\n");
+				XBUS_DBG(SYNC, xbus,
+					 "Not self_ticking yet. Ignore\n");
 		}
 		put_xbus(__func__, xbus);
 	}
@@ -606,18 +625,18 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi)
 
 void elect_syncer(const char *msg)
 {
-	int	i;
-	int	j;
-	uint	timing_priority = INT_MAX;
-	xpd_t	*best_xpd = NULL;
-	xbus_t	*the_xbus = NULL;
-	unsigned long	flags;
+	int i;
+	int j;
+	uint timing_priority = INT_MAX;
+	xpd_t *best_xpd = NULL;
+	xbus_t *the_xbus = NULL;
+	unsigned long flags;
 
 	spin_lock_irqsave(&elect_syncer_lock, flags);
 	DBG(SYNC, "%s: %s syncer=%s\n", __func__, msg,
-			(syncer) ? syncer->busname : "NULL");
+	    (syncer) ? syncer->busname : "NULL");
 	for (i = 0; i < MAX_BUSES; i++) {
-		xbus_t	*xbus = get_xbus(__func__, i);
+		xbus_t *xbus = get_xbus(__func__, i);
 
 		if (xbus == NULL)
 			continue;
@@ -625,15 +644,18 @@ void elect_syncer(const char *msg)
 			if (!the_xbus)
 				the_xbus = xbus;	/* First candidate */
 			for (j = 0; j < MAX_XPDS; j++) {
-				xpd_t	*xpd = xpd_of(xbus, j);
-				int	prio;
+				xpd_t *xpd = xpd_of(xbus, j);
+				int prio;
 
-				if (!xpd || !xpd->card_present || !IS_PHONEDEV(xpd))
+				if (!xpd || !xpd->card_present
+				    || !IS_PHONEDEV(xpd))
 					continue;
-				prio = CALL_PHONE_METHOD(card_timing_priority, xpd);
+				prio =
+				    CALL_PHONE_METHOD(card_timing_priority,
+						      xpd);
 				if (prio < 0) {
 					DBG(SYNC, "%s/%s: skip sync\n",
-						xbus->busname, xpd->xpdname);
+					    xbus->busname, xpd->xpdname);
 					continue;
 				}
 				if (prio > 0 && prio < timing_priority) {
@@ -646,11 +668,12 @@ void elect_syncer(const char *msg)
 	}
 	if (best_xpd) {
 		the_xbus = best_xpd->xbus;
-		XPD_DBG(SYNC, best_xpd, "%s: elected with priority %d\n", msg, timing_priority);
+		XPD_DBG(SYNC, best_xpd, "%s: elected with priority %d\n", msg,
+			timing_priority);
 	} else if (the_xbus) {
 		XBUS_DBG(SYNC, the_xbus, "%s: elected\n", msg);
 	} else {
-		unsigned long	flags;
+		unsigned long flags;
 
 		DBG(SYNC, "%s: No more syncers\n", msg);
 		spin_lock_irqsave(&ref_ticker_lock, flags);
@@ -681,10 +704,10 @@ void update_wanted_pcm_mask(xpd_t *xpd, xpp_line_t new_mask, uint new_pcm_len)
  */
 void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask)
 {
-	int		i;
-	int		line_count = 0;
-	unsigned long	flags;
-	uint		pcm_len;
+	int i;
+	int line_count = 0;
+	unsigned long flags;
+	uint pcm_len;
 
 	spin_lock_irqsave(&PHONEDEV(xpd).lock_recompute_pcm, flags);
 	//XPD_DBG(SIGNAL, xpd, "pcm_mask=0x%X\n", pcm_mask);
@@ -694,8 +717,8 @@ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask)
 	pcm_mask &= ~(PHONEDEV(xpd).digital_inputs);
 	pcm_mask &= ~(PHONEDEV(xpd).digital_outputs);
 	for_each_line(xpd, i)
-		if (IS_SET(pcm_mask, i))
-			line_count++;
+	    if (IS_SET(pcm_mask, i))
+		line_count++;
 	/*
 	 * FIXME: Workaround a bug in sync code of the Astribank.
 	 *        Send dummy PCM for sync.
@@ -705,17 +728,17 @@ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask)
 		line_count = 1;
 	}
 	pcm_len = (line_count)
-		? RPACKET_HEADERSIZE + sizeof(xpp_line_t) + line_count * DAHDI_CHUNKSIZE
-		: 0L;
+	    ? RPACKET_HEADERSIZE + sizeof(xpp_line_t) +
+	    line_count * DAHDI_CHUNKSIZE : 0L;
 	update_wanted_pcm_mask(xpd, pcm_mask, pcm_len);
 	spin_unlock_irqrestore(&PHONEDEV(xpd).lock_recompute_pcm, flags);
 }
 
 void fill_beep(u_char *buf, int num, int duration)
 {
-	bool	alternate = (duration) ? (jiffies/(duration*1000)) & 0x1 : 0;
-	int	which;
-	u_char	*snd;
+	bool alternate = (duration) ? (jiffies / (duration * 1000)) & 0x1 : 0;
+	int which;
+	u_char *snd;
 
 	/*
 	 * debug tones
@@ -739,18 +762,21 @@ void fill_beep(u_char *buf, int num, int duration)
 
 static void do_ec(xpd_t *xpd)
 {
-	int	i;
+	int i;
 
-	for (i = 0;i < PHONEDEV(xpd).span.channels; i++) {
-		struct dahdi_chan	*chan = XPD_CHAN(xpd, i);
+	for (i = 0; i < PHONEDEV(xpd).span.channels; i++) {
+		struct dahdi_chan *chan = XPD_CHAN(xpd, i);
 
 		if (unlikely(IS_SET(PHONEDEV(xpd).digital_signalling, i)))	/* Don't echo cancel BRI D-chans */
 			continue;
-		if (!IS_SET(PHONEDEV(xpd).wanted_pcm_mask, i))			/* No ec for unwanted PCM */
+		if (!IS_SET(PHONEDEV(xpd).wanted_pcm_mask, i))	/* No ec for unwanted PCM */
 			continue;
-		dahdi_ec_chunk(chan, chan->readchunk, PHONEDEV(xpd).ec_chunk2[i]);
-		memcpy(PHONEDEV(xpd).ec_chunk2[i], PHONEDEV(xpd).ec_chunk1[i], DAHDI_CHUNKSIZE);
-		memcpy(PHONEDEV(xpd).ec_chunk1[i], chan->writechunk, DAHDI_CHUNKSIZE);
+		dahdi_ec_chunk(chan, chan->readchunk,
+			       PHONEDEV(xpd).ec_chunk2[i]);
+		memcpy(PHONEDEV(xpd).ec_chunk2[i], PHONEDEV(xpd).ec_chunk1[i],
+		       DAHDI_CHUNKSIZE);
+		memcpy(PHONEDEV(xpd).ec_chunk1[i], chan->writechunk,
+		       DAHDI_CHUNKSIZE);
 	}
 }
 
@@ -762,26 +788,26 @@ static void do_ec(xpd_t *xpd)
    set the DAHDI_FLAG_RBS in this case.  */
 
 /* Opt: If the span uses A/B bits, set them here */
-int (*rbsbits)(struct dahdi_chan *chan, int bits);
+int (*rbsbits) (struct dahdi_chan * chan, int bits);
 
 /* Option 2: If you don't know about sig bits, but do have their
    equivalents (i.e. you can disconnect battery, detect off hook,
    generate ring, etc directly) then you can just specify a
    sethook function, and we'll call you with appropriate hook states
    to set.  Still set the DAHDI_FLAG_RBS in this case as well */
-int (*hooksig)(struct dahdi_chan *chan, enum dahdi_txsig hookstate);
+int (*hooksig) (struct dahdi_chan * chan, enum dahdi_txsig hookstate);
 
 /* Option 3: If you can't use sig bits, you can write a function
    which handles the individual hook states  */
-int (*sethook)(struct dahdi_chan *chan, int hookstate);
+int (*sethook) (struct dahdi_chan * chan, int hookstate);
 #endif
 
 static bool pcm_valid(xpd_t *xpd, xpacket_t *pack)
 {
-	xpp_line_t	lines = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines);
-	int		i;
-	int		count = 0;
-	uint16_t	good_len;
+	xpp_line_t lines = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines);
+	int i;
+	int count = 0;
+	uint16_t good_len;
 
 	BUG_ON(!pack);
 	BUG_ON(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL, PCM_READ));
@@ -799,8 +825,9 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack)
 
 		XPD_COUNTER(xpd, RECV_ERRORS)++;
 		if ((rate_limit++ % 1000) <= 10) {
-			XPD_ERR(xpd, "BAD PCM REPLY: packet_len=%d (should be %d), count=%d\n",
-					XPACKET_LEN(pack), good_len, count);
+			XPD_ERR(xpd,
+				"BAD PCM REPLY: packet_len=%d (should be %d), count=%d\n",
+				XPACKET_LEN(pack), good_len, count);
 			dump_packet("BAD PCM REPLY", pack, 1);
 		}
 		return 0;
@@ -808,13 +835,11 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack)
 	return 1;
 }
 
-
-
 static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe)
 {
-	unsigned long	flags;
-	struct timeval	now;
-	unsigned long	usec;
+	unsigned long flags;
+	struct timeval now;
+	unsigned long usec;
 
 	spin_lock_irqsave(&xbus->lock, flags);
 	do_gettimeofday(&now);
@@ -824,13 +849,15 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe)
 		usec = usec_diff(&now, &xbus->last_tx_sync);
 		xbus->last_tx_sync = now;
 		/* ignore startup statistics */
-		if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) {
+		if (likely
+		    (atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) {
 			if (abs(usec - 1000) > TICK_TOLERANCE) {
-				static int	rate_limit;
+				static int rate_limit;
 
 				if ((rate_limit++ % 5003) == 0)
-					XBUS_DBG(SYNC, xbus, "Bad PCM TX timing(%d): usec=%ld.\n",
-							rate_limit, usec);
+					XBUS_DBG(SYNC, xbus,
+						 "Bad PCM TX timing(%d): usec=%ld.\n",
+						 rate_limit, usec);
 			}
 			if (usec > xbus->max_tx_sync)
 				xbus->max_tx_sync = usec;
@@ -840,7 +867,7 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe)
 	}
 	spin_unlock_irqrestore(&xbus->lock, flags);
 	/* OK, really send it */
-	if (debug & DBG_PCM )
+	if (debug & DBG_PCM)
 		dump_xframe("TX_XFRAME_PCM", xbus, xframe, debug);
 	send_pcm_frame(xbus, xframe);
 	XBUS_COUNTER(xbus, TX_XFRAME_PCM)++;
@@ -856,10 +883,10 @@ dropit:
  */
 void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
 {
-	__u8		*pcm;
-	unsigned long	flags;
-	xpp_line_t	wanted_lines;
-	int		i;
+	__u8 *pcm;
+	unsigned long flags;
+	xpp_line_t wanted_lines;
+	int i;
 
 	BUG_ON(!xpd);
 	BUG_ON(!pack);
@@ -868,18 +895,20 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
 	pcm = RPACKET_FIELD(pack, GLOBAL, PCM_WRITE, pcm);
 	spin_lock_irqsave(&xpd->lock, flags);
 	for (i = 0; i < PHONEDEV(xpd).channels; i++) {
-		struct dahdi_chan	*chan = XPD_CHAN(xpd, i);
+		struct dahdi_chan *chan = XPD_CHAN(xpd, i);
 
 		if (IS_SET(wanted_lines, i)) {
 			if (SPAN_REGISTERED(xpd)) {
 #ifdef	DEBUG_PCMTX
-				int	channo = chan->channo;
+				int channo = chan->channo;
 
 				if (pcmtx >= 0 && pcmtx_chan == channo)
-					memset((u_char *)pcm, pcmtx, DAHDI_CHUNKSIZE);
+					memset((u_char *)pcm, pcmtx,
+					       DAHDI_CHUNKSIZE);
 				else
 #endif
-					memcpy((u_char *)pcm, chan->writechunk, DAHDI_CHUNKSIZE);
+					memcpy((u_char *)pcm, chan->writechunk,
+					       DAHDI_CHUNKSIZE);
 			} else
 				memset((u_char *)pcm, 0x7F, DAHDI_CHUNKSIZE);
 			pcm += DAHDI_CHUNKSIZE;
@@ -891,11 +920,11 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
 
 void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
 {
-	__u8		*pcm;
-	xpp_line_t	pcm_mask;
-	xpp_line_t	pcm_mute;
-	unsigned long	flags;
-	int		i;
+	__u8 *pcm;
+	xpp_line_t pcm_mask;
+	xpp_line_t pcm_mute;
+	unsigned long flags;
+	int i;
 
 	pcm = RPACKET_FIELD(pack, GLOBAL, PCM_READ, pcm);
 	pcm_mask = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines);
@@ -908,14 +937,17 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
 	if (!SPAN_REGISTERED(xpd))
 		goto out;
 	for (i = 0; i < PHONEDEV(xpd).channels; i++) {
-		volatile u_char	*r = XPD_CHAN(xpd, i)->readchunk;
-		bool		got_data = IS_SET(pcm_mask, i);
+		volatile u_char *r = XPD_CHAN(xpd, i)->readchunk;
+		bool got_data = IS_SET(pcm_mask, i);
 
 		if (got_data && !IS_SET(pcm_mute, i)) {
 			/* We have and want real data */
-			// memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE);	// DEBUG
+			// memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE);  // DEBUG
 			memcpy((u_char *)r, pcm, DAHDI_CHUNKSIZE);
-		} else if (IS_SET(PHONEDEV(xpd).wanted_pcm_mask | PHONEDEV(xpd).silence_pcm, i)) {
+		} else
+		    if (IS_SET
+			(PHONEDEV(xpd).wanted_pcm_mask | PHONEDEV(xpd).
+			 silence_pcm, i)) {
 			/* Inject SILENCE */
 			memset((u_char *)r, 0x7F, DAHDI_CHUNKSIZE);
 			if (IS_SET(PHONEDEV(xpd).silence_pcm, i)) {
@@ -923,8 +955,10 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
 				 * This will clear the EC buffers until next tick
 				 * So we don't have noise residues from the past.
 				 */
-				memset(PHONEDEV(xpd).ec_chunk2[i], 0x7F, DAHDI_CHUNKSIZE);
-				memset(PHONEDEV(xpd).ec_chunk1[i], 0x7F, DAHDI_CHUNKSIZE);
+				memset(PHONEDEV(xpd).ec_chunk2[i], 0x7F,
+				       DAHDI_CHUNKSIZE);
+				memset(PHONEDEV(xpd).ec_chunk1[i], 0x7F,
+				       DAHDI_CHUNKSIZE);
 			}
 		}
 		if (got_data)
@@ -939,6 +973,7 @@ int generic_echocancel_timeslot(xpd_t *xpd, int pos)
 {
 	return xpd->addr.unit * 32 + pos;
 }
+
 EXPORT_SYMBOL(generic_echocancel_timeslot);
 
 int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask)
@@ -949,7 +984,7 @@ int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask)
 	XPD_DBG(GENERAL, xpd, "0x%8X\n", ec_mask);
 	if (!ECHOOPS(xpd->xbus)) {
 		XPD_DBG(GENERAL, xpd,
-				"No echo canceller in XBUS: Doing nothing.\n");
+			"No echo canceller in XBUS: Doing nothing.\n");
 		return -EINVAL;
 	}
 	for (i = 0; i < PHONEDEV(xpd).channels; i++) {
@@ -959,14 +994,15 @@ int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask)
 	CALL_EC_METHOD(ec_update, xpd->xbus, xpd->xbus);
 	return 0;
 }
+
 EXPORT_SYMBOL(generic_echocancel_setmask);
 
 static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
 {
-	__u8		*xframe_end;
-	xpacket_t	*pack;
-	__u8		*p;
-	int		ret = -EPROTO;	/* Assume error */
+	__u8 *xframe_end;
+	xpacket_t *pack;
+	__u8 *p;
+	int ret = -EPROTO;	/* Assume error */
 
 	if (debug & DBG_PCM)
 		dump_xframe("RX_XFRAME_PCM", xbus, xframe, debug);
@@ -975,42 +1011,48 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
 	p = xframe->packets;
 	xframe_end = p + XFRAME_LEN(xframe);
 	do {
-		int		len;
-		xpd_t		*xpd;
+		int len;
+		xpd_t *xpd;
 
 		pack = (xpacket_t *)p;
 		len = XPACKET_LEN(pack);
 		/* Sanity checks */
 		if (unlikely(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL, PCM_READ))) {
-			static int	rate_limit;
+			static int rate_limit;
 
 			if ((rate_limit++ % 1003) == 0) {
 				XBUS_NOTICE(xbus,
-					"%s: Non-PCM packet within a PCM xframe. (%d)\n",
-					__func__, rate_limit);
-				dump_xframe("In PCM xframe", xbus, xframe, debug);
+					    "%s: Non-PCM packet within a PCM xframe. (%d)\n",
+					    __func__, rate_limit);
+				dump_xframe("In PCM xframe", xbus, xframe,
+					    debug);
 			}
 			goto out;
 		}
 		p += len;
 		if (p > xframe_end || len < RPACKET_HEADERSIZE) {
-			static int	rate_limit;
+			static int rate_limit;
 
 			if ((rate_limit++ % 1003) == 0) {
 				XBUS_NOTICE(xbus,
-					"%s: Invalid packet length %d. (%d)\n",
-					__func__, len, rate_limit);
+					    "%s: Invalid packet length %d. (%d)\n",
+					    __func__, len, rate_limit);
 				dump_xframe("BAD LENGTH", xbus, xframe, debug);
 			}
 			goto out;
 		}
-		xpd = xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
+		xpd =
+		    xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack),
+			       XPACKET_ADDR_SUBUNIT(pack));
 		if (unlikely(!xpd)) {
-			static int	rate_limit;
+			static int rate_limit;
 
 			if ((rate_limit++ % 1003) == 0) {
-				notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "RECEIVE PCM");
-				dump_xframe("Unknown XPD addr", xbus, xframe, debug);
+				notify_bad_xpd(__func__, xbus,
+					       XPACKET_ADDR(pack),
+					       "RECEIVE PCM");
+				dump_xframe("Unknown XPD addr", xbus, xframe,
+					    debug);
 			}
 			goto out;
 		}
@@ -1021,7 +1063,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
 			CALL_PHONE_METHOD(card_pcm_tospan, xpd, pack);
 		}
 	} while (p < xframe_end);
-	ret = 0;	/* all good */
+	ret = 0;		/* all good */
 	XBUS_COUNTER(xbus, RX_XFRAME_PCM)++;
 out:
 	FREE_RECV_XFRAME(xbus, xframe);
@@ -1035,11 +1077,11 @@ int generic_timing_priority(xpd_t *xpd)
 
 static void xbus_tick(xbus_t *xbus)
 {
-	int		i;
-	xpd_t		*xpd;
-	xframe_t	*xframe = NULL;
-	xpacket_t	*pack = NULL;
-	bool		sent_sync_bit = 0;
+	int i;
+	xpd_t *xpd;
+	xframe_t *xframe = NULL;
+	xpacket_t *pack = NULL;
+	bool sent_sync_bit = 0;
 
 	/*
 	 * Update dahdi
@@ -1048,15 +1090,15 @@ static void xbus_tick(xbus_t *xbus)
 		xpd = xpd_of(xbus, i);
 		if (xpd && SPAN_REGISTERED(xpd)) {
 #ifdef	OPTIMIZE_CHANMUTE
-			int		j;
-			xpp_line_t	xmit_mask = PHONEDEV(xpd).wanted_pcm_mask;
+			int j;
+			xpp_line_t xmit_mask = PHONEDEV(xpd).wanted_pcm_mask;
 
 			xmit_mask |= PHONEDEV(xpd).silence_pcm;
 			xmit_mask |= PHONEDEV(xpd).digital_signalling;
 			for_each_line(xpd, j) {
 				XPD_CHAN(xpd, j)->chanmute = (optimize_chanmute)
-					? !IS_SET(xmit_mask, j)
-					: 0;
+				    ? !IS_SET(xmit_mask, j)
+				    : 0;
 			}
 #endif
 			/*
@@ -1075,31 +1117,36 @@ static void xbus_tick(xbus_t *xbus)
 		if (!IS_PHONEDEV(xpd))
 			continue;
 		if (SPAN_REGISTERED(xpd)) {
-			size_t	pcm_len = PHONEDEV(xpd).pcm_len;
+			size_t pcm_len = PHONEDEV(xpd).pcm_len;
 
 			if (pcm_len && xpd->card_present) {
 				do {
-					// pack = NULL;		/* FORCE single packet frames */
+					// pack = NULL;         /* FORCE single packet frames */
 					if (xframe && !pack) {	/* FULL frame */
 						pcm_frame_out(xbus, xframe);
 						xframe = NULL;
-						XBUS_COUNTER(xbus, TX_PCM_FRAG)++;
+						XBUS_COUNTER(xbus,
+							     TX_PCM_FRAG)++;
 					}
-					if (!xframe) {		/* Alloc frame */
-						xframe = ALLOC_SEND_XFRAME(xbus);
+					if (!xframe) {	/* Alloc frame */
+						xframe =
+						    ALLOC_SEND_XFRAME(xbus);
 						if (!xframe) {
 							static int rate_limit;
 
-							if ((rate_limit++ % 3001) == 0)
+							if ((rate_limit++ %
+							     3001) == 0)
 								XBUS_ERR(xbus,
-									"%s: failed to allocate new xframe\n",
-									__func__);
+									 "%s: failed to allocate new xframe\n",
+									 __func__);
 							return;
 						}
 					}
-					pack = xframe_next_packet(xframe, pcm_len);
+					pack =
+					    xframe_next_packet(xframe, pcm_len);
 				} while (!pack);
-				XPACKET_INIT(pack, GLOBAL, PCM_WRITE, xpd->xbus_idx, 1, 0);
+				XPACKET_INIT(pack, GLOBAL, PCM_WRITE,
+					     xpd->xbus_idx, 1, 0);
 				XPACKET_LEN(pack) = pcm_len;
 				if (!sent_sync_bit) {
 					XPACKET_ADDR_SYNC(pack) = 1;
@@ -1110,7 +1157,7 @@ static void xbus_tick(xbus_t *xbus)
 			}
 		}
 	}
-	if (xframe)	/* clean any leftovers */
+	if (xframe)		/* clean any leftovers */
 		pcm_frame_out(xbus, xframe);
 	/*
 	 * Receive PCM
@@ -1118,20 +1165,23 @@ static void xbus_tick(xbus_t *xbus)
 	while ((xframe = xframe_dequeue(&xbus->pcm_tospan)) != NULL) {
 		copy_pcm_tospan(xbus, xframe);
 		if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) {
-			struct timeval	now;
-			unsigned long	usec;
+			struct timeval now;
+			unsigned long usec;
 
 			do_gettimeofday(&now);
 			usec = usec_diff(&now, &xbus->last_rx_sync);
 			xbus->last_rx_sync = now;
 			/* ignore startup statistics */
-			if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) {
+			if (likely
+			    (atomic_read(&xbus->pcm_rx_counter) >
+			     BIG_TICK_INTERVAL)) {
 				if (abs(usec - 1000) > TICK_TOLERANCE) {
-					static int	rate_limit;
+					static int rate_limit;
 
 					if ((rate_limit++ % 5003) == 0)
-						XBUS_DBG(SYNC, xbus, "Bad PCM RX timing(%d): usec=%ld.\n",
-								rate_limit, usec);
+						XBUS_DBG(SYNC, xbus,
+							 "Bad PCM RX timing(%d): usec=%ld.\n",
+							 rate_limit, usec);
 				}
 				if (usec > xbus->max_rx_sync)
 					xbus->max_rx_sync = usec;
@@ -1162,8 +1212,8 @@ static void xbus_tick(xbus_t *xbus)
 
 static void do_tick(xbus_t *xbus, const struct timeval *tv_received)
 {
-	int		counter = atomic_read(&xpp_tick_counter);
-	unsigned long	flags;
+	int counter = atomic_read(&xpp_tick_counter);
+	unsigned long flags;
 
 	xbus_command_queue_tick(xbus);
 	if (global_ticker == xbus)
@@ -1179,12 +1229,12 @@ static void do_tick(xbus_t *xbus, const struct timeval *tv_received)
 void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe)
 {
 	if (!xframe_enqueue(&xbus->pcm_tospan, xframe)) {
-		static int	rate_limit;
+		static int rate_limit;
 
 		if ((rate_limit++ % 1003) == 0)
 			XBUS_DBG(SYNC, xbus,
-					"Failed to enqueue received pcm frame. (%d)\n",
-					rate_limit);
+				 "Failed to enqueue received pcm frame. (%d)\n",
+				 rate_limit);
 		FREE_RECV_XFRAME(xbus, xframe);
 	}
 	/*
@@ -1201,9 +1251,9 @@ void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe)
 
 int exec_sync_command(const char *buf, size_t count)
 {
-	int	ret = count;
-	int	xbusno;
-	xbus_t	*xbus;
+	int ret = count;
+	int xbusno;
+	xbus_t *xbus;
 
 	if (strncmp("DAHDI", buf, 6) == 0) {	/* Ignore the newline */
 		DBG(SYNC, "DAHDI");
@@ -1235,11 +1285,12 @@ int exec_sync_command(const char *buf, size_t count)
 
 int fill_sync_string(char *buf, size_t count)
 {
-	int	len = 0;
+	int len = 0;
 
 	if (!syncer) {
-		len += snprintf(buf, count, "%s\n",
-			(force_dahdi_sync) ? "DAHDI" : "NO-SYNC");
+		len +=
+		    snprintf(buf, count, "%s\n",
+			     (force_dahdi_sync) ? "DAHDI" : "NO-SYNC");
 	} else
 		len += snprintf(buf, count, "SYNC=%02d\n", syncer->num);
 	return len;
@@ -1247,11 +1298,11 @@ int fill_sync_string(char *buf, size_t count)
 
 int xbus_pcm_init(void *toplevel)
 {
-	int			ret = 0;
+	int ret = 0;
 
 #ifdef	OPTIMIZE_CHANMUTE
 	INFO("FEATURE: with CHANMUTE optimization (%sactivated)\n",
-		(optimize_chanmute)?"":"de");
+	     (optimize_chanmute) ? "" : "de");
 #endif
 #ifdef	DAHDI_SYNC_TICK
 	INFO("FEATURE: with sync_tick() from DAHDI\n");
@@ -1267,7 +1318,6 @@ void xbus_pcm_shutdown(void)
 {
 }
 
-
 EXPORT_SYMBOL(xbus_request_sync);
 EXPORT_SYMBOL(got_new_syncer);
 EXPORT_SYMBOL(elect_syncer);
@@ -1283,4 +1333,3 @@ EXPORT_SYMBOL(generic_timing_priority);
 EXPORT_SYMBOL(pcmtx);
 EXPORT_SYMBOL(pcmtx_chan);
 #endif
-