1 files changed, 177 insertions, 162 deletions

diff --git a/drivers/alsa/usx2y.c b/drivers/alsa/usx2y.c
index 23efeb3..b0a6d12 100644
--- a/drivers/alsa/usx2y.c
+++ b/drivers/alsa/usx2y.c
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2001 Paul Davis 
+    Copyright (C) 2001 Paul Davis
     Copyright (C) 2005 Karsten Wiese, Rui Nuno Capela
 
     This program is free software; you can redistribute it and/or modify
@@ -16,7 +16,7 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-*/
+ */
 
 #include "hardware.h"
 #include "alsa_driver.h"
@@ -36,14 +36,14 @@
 int dbg_offset;
 char dbg_buffer[8096];
 #endif
-static 
+static
 int usx2y_set_input_monitor_mask (jack_hardware_t *hw, unsigned long mask)
 {
 	return -1;
 }
 
 static
-int usx2y_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode) 
+int usx2y_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode)
 {
 	return -1;
 }
@@ -51,78 +51,85 @@ int usx2y_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode)
 static void
 usx2y_release (jack_hardware_t *hw)
 {
-	usx2y_t *h = (usx2y_t *) hw->private;
+	usx2y_t *h = (usx2y_t*)hw->private;
 
-	if (h == 0)
+	if (h == 0) {
 		return;
-        
-	if (h->hwdep_handle)
-		snd_hwdep_close(h->hwdep_handle);
+	}
+
+	if (h->hwdep_handle) {
+		snd_hwdep_close (h->hwdep_handle);
+	}
 
-	free(h);
+	free (h);
 }
 
 static int
 usx2y_driver_get_channel_addresses_playback (alsa_driver_t *driver,
-					snd_pcm_uframes_t *playback_avail)
+					     snd_pcm_uframes_t *playback_avail)
 {
 	channel_t chn;
 	int iso;
 	snd_pcm_uframes_t playback_iso_avail;
 	char *playback;
 
-	usx2y_t *h = (usx2y_t *) driver->hw->private;
+	usx2y_t *h = (usx2y_t*)driver->hw->private;
 
 	if (0 > h->playback_iso_start) {
 		int bytes = driver->playback_sample_bytes * 2 * driver->frames_per_cycle *
-			driver->user_nperiods;
+			    driver->user_nperiods;
 		iso = h->hwdep_pcm_shm->playback_iso_start;
-		if (0 > iso)
+		if (0 > iso) {
 			return 0; /* FIXME: return -1; */
-		if (++iso >= ARRAY_SIZE(h->hwdep_pcm_shm->captured_iso))
+		}
+		if (++iso >= ARRAY_SIZE (h->hwdep_pcm_shm->captured_iso)) {
 			iso = 0;
-		while((bytes -= h->hwdep_pcm_shm->captured_iso[iso].length) > 0)
-			if (++iso >= ARRAY_SIZE(h->hwdep_pcm_shm->captured_iso))
+		}
+		while ((bytes -= h->hwdep_pcm_shm->captured_iso[iso].length) > 0)
+			if (++iso >= ARRAY_SIZE (h->hwdep_pcm_shm->captured_iso)) {
 				iso = 0;
+			}
 		h->playback_iso_bytes_done = h->hwdep_pcm_shm->captured_iso[iso].length + bytes;
 #ifdef DBGHWDEP
-		dbg_offset = sprintf(dbg_buffer, "first iso = %i %i@%p:%i\n",
-					iso, h->hwdep_pcm_shm->captured_iso[iso].length,
-					h->hwdep_pcm_shm->playback,
-					h->hwdep_pcm_shm->captured_iso[iso].offset);
+		dbg_offset = sprintf (dbg_buffer, "first iso = %i %i@%p:%i\n",
+				      iso, h->hwdep_pcm_shm->captured_iso[iso].length,
+				      h->hwdep_pcm_shm->playback,
+				      h->hwdep_pcm_shm->captured_iso[iso].offset);
 #endif
 	} else {
 		iso = h->playback_iso_start;
 	}
 #ifdef DBGHWDEP
-	dbg_offset += sprintf(dbg_buffer + dbg_offset, "iso = %i(%i;%i); ", iso,
-				h->hwdep_pcm_shm->captured_iso[iso].offset,
-				h->hwdep_pcm_shm->captured_iso[iso].frame);
+	dbg_offset += sprintf (dbg_buffer + dbg_offset, "iso = %i(%i;%i); ", iso,
+			       h->hwdep_pcm_shm->captured_iso[iso].offset,
+			       h->hwdep_pcm_shm->captured_iso[iso].frame);
 #endif
 	playback = h->hwdep_pcm_shm->playback +
-		h->hwdep_pcm_shm->captured_iso[iso].offset +
-		h->playback_iso_bytes_done;
+		   h->hwdep_pcm_shm->captured_iso[iso].offset +
+		   h->playback_iso_bytes_done;
 	playback_iso_avail = (h->hwdep_pcm_shm->captured_iso[iso].length -
-		h->playback_iso_bytes_done) /
-		(driver->playback_sample_bytes * 2);
+			      h->playback_iso_bytes_done) /
+			     (driver->playback_sample_bytes * 2);
 	if (*playback_avail >= playback_iso_avail) {
 		*playback_avail = playback_iso_avail;
-		if (++iso >= ARRAY_SIZE(h->hwdep_pcm_shm->captured_iso))
+		if (++iso >= ARRAY_SIZE (h->hwdep_pcm_shm->captured_iso)) {
 			iso = 0;
+		}
 		h->playback_iso_bytes_done = 0;
-	} else
+	} else {
 		h->playback_iso_bytes_done =
 			*playback_avail * (driver->playback_sample_bytes * 2);
+	}
 	h->playback_iso_start = iso;
 	for (chn = 0; chn < driver->playback_nchannels; chn++) {
 		const snd_pcm_channel_area_t *a = &driver->playback_areas[chn];
 		driver->playback_addr[chn] = playback + a->first / 8;
 	}
 #ifdef DBGHWDEP
-	if (dbg_offset < (sizeof(dbg_buffer) - 256))
-		dbg_offset += sprintf(dbg_buffer + dbg_offset, "avail %li@%p\n", *playback_avail, driver->playback_addr[0]);
-	else {
-		printf(dbg_buffer);
+	if (dbg_offset < (sizeof(dbg_buffer) - 256)) {
+		dbg_offset += sprintf (dbg_buffer + dbg_offset, "avail %li@%p\n", *playback_avail, driver->playback_addr[0]);
+	} else {
+		printf (dbg_buffer);
 		return -1;
 	}
 #endif
@@ -132,48 +139,51 @@ usx2y_driver_get_channel_addresses_playback (alsa_driver_t *driver,
 
 static int
 usx2y_driver_get_channel_addresses_capture (alsa_driver_t *driver,
-					snd_pcm_uframes_t *capture_avail)
+					    snd_pcm_uframes_t *capture_avail)
 {
 	channel_t chn;
 	int iso;
 	snd_pcm_uframes_t capture_iso_avail;
 	int capture_offset;
 
-	usx2y_t *h = (usx2y_t *) driver->hw->private;
+	usx2y_t *h = (usx2y_t*)driver->hw->private;
 
 	if (0 > h->capture_iso_start) {
 		iso = h->hwdep_pcm_shm->capture_iso_start;
-		if (0 > iso)
+		if (0 > iso) {
 			return 0; /* FIXME: return -1; */
+		}
 		h->capture_iso_bytes_done = 0;
 #ifdef DBGHWDEP
-		dbg_offset = sprintf(dbg_buffer, "cfirst iso = %i %i@%p:%i\n",
-					iso, h->hwdep_pcm_shm->captured_iso[iso].length,
-					h->hwdep_pcm_shm->capture0x8,
-					h->hwdep_pcm_shm->captured_iso[iso].offset);
+		dbg_offset = sprintf (dbg_buffer, "cfirst iso = %i %i@%p:%i\n",
+				      iso, h->hwdep_pcm_shm->captured_iso[iso].length,
+				      h->hwdep_pcm_shm->capture0x8,
+				      h->hwdep_pcm_shm->captured_iso[iso].offset);
 #endif
 	} else {
 		iso = h->capture_iso_start;
 	}
 #ifdef DBGHWDEP
-	dbg_offset += sprintf(dbg_buffer + dbg_offset, "ciso = %i(%i;%i); ", iso,
-				h->hwdep_pcm_shm->captured_iso[iso].offset,
-				h->hwdep_pcm_shm->captured_iso[iso].frame);
+	dbg_offset += sprintf (dbg_buffer + dbg_offset, "ciso = %i(%i;%i); ", iso,
+			       h->hwdep_pcm_shm->captured_iso[iso].offset,
+			       h->hwdep_pcm_shm->captured_iso[iso].frame);
 #endif
 	capture_offset =
 		h->hwdep_pcm_shm->captured_iso[iso].offset +
-			h->capture_iso_bytes_done;
+		h->capture_iso_bytes_done;
 	capture_iso_avail = (h->hwdep_pcm_shm->captured_iso[iso].length -
-		h->capture_iso_bytes_done) /
-		(driver->capture_sample_bytes * 2);
+			     h->capture_iso_bytes_done) /
+			    (driver->capture_sample_bytes * 2);
 	if (*capture_avail >= capture_iso_avail) {
 		*capture_avail = capture_iso_avail;
-		if (++iso >= ARRAY_SIZE(h->hwdep_pcm_shm->captured_iso))
+		if (++iso >= ARRAY_SIZE (h->hwdep_pcm_shm->captured_iso)) {
 			iso = 0;
+		}
 		h->capture_iso_bytes_done = 0;
-	} else
+	} else {
 		h->capture_iso_bytes_done =
 			*capture_avail * (driver->capture_sample_bytes * 2);
+	}
 	h->capture_iso_start = iso;
 	for (chn = 0; chn < driver->capture_nchannels; chn++) {
 		driver->capture_addr[chn] =
@@ -182,21 +192,22 @@ usx2y_driver_get_channel_addresses_capture (alsa_driver_t *driver,
 			((chn & 1) ? driver->capture_sample_bytes : 0);
 	}
 #ifdef DBGHWDEP
- {
-	int f = 0;
-	unsigned *u = driver->capture_addr[0];
-	static unsigned last;
-	dbg_offset += sprintf(dbg_buffer + dbg_offset, "\nvon %6u  bis %6u\n", last, u[0]);
-	while (f < *capture_avail && dbg_offset < (sizeof(dbg_buffer) - 256)) {
-		if (u[f] != last + 1)
-			 dbg_offset += sprintf(dbg_buffer + dbg_offset, "\nooops %6u  %6u\n", last, u[f]);
-		last = u[f++];
-	}
- }
-	if (dbg_offset < (sizeof(dbg_buffer) - 256))
-		dbg_offset += sprintf(dbg_buffer + dbg_offset, "avail %li@%p\n", *capture_avail, driver->capture_addr[0]);
-	else {
-		printf(dbg_buffer);
+	{
+		int f = 0;
+		unsigned *u = driver->capture_addr[0];
+		static unsigned last;
+		dbg_offset += sprintf (dbg_buffer + dbg_offset, "\nvon %6u  bis %6u\n", last, u[0]);
+		while (f < *capture_avail && dbg_offset < (sizeof(dbg_buffer) - 256)) {
+			if (u[f] != last + 1) {
+				dbg_offset += sprintf (dbg_buffer + dbg_offset, "\nooops %6u  %6u\n", last, u[f]);
+			}
+			last = u[f++];
+		}
+	}
+	if (dbg_offset < (sizeof(dbg_buffer) - 256)) {
+		dbg_offset += sprintf (dbg_buffer + dbg_offset, "avail %li@%p\n", *capture_avail, driver->capture_addr[0]);
+	} else {
+		printf (dbg_buffer);
 		return -1;
 	}
 #endif
@@ -210,7 +221,7 @@ usx2y_driver_start (alsa_driver_t *driver)
 	int err, i;
 	snd_pcm_uframes_t poffset, pavail;
 
-	usx2y_t *h = (usx2y_t *) driver->hw->private;
+	usx2y_t *h = (usx2y_t*)driver->hw->private;
 
 	for (i = 0; i < driver->capture_nchannels; i++)
 		// US428 channels 3+4 are on a seperate 2 channel stream.
@@ -225,40 +236,40 @@ usx2y_driver_start (alsa_driver_t *driver)
 	driver->poll_next = 0;
 
 	if ((err = snd_pcm_prepare (driver->playback_handle)) < 0) {
-		jack_error ("ALSA/USX2Y: prepare error for playback: %s", snd_strerror(err));
+		jack_error ("ALSA/USX2Y: prepare error for playback: %s", snd_strerror (err));
 		return -1;
 	}
 
 	if (driver->playback_handle) {
-/* 		int i, j; */
-/* 		char buffer[2000]; */
+/*              int i, j; */
+/*              char buffer[2000]; */
 		h->playback_iso_start =
 			h->capture_iso_start = -1;
-		snd_hwdep_poll_descriptors(h->hwdep_handle, &h->pfds, 1);
+		snd_hwdep_poll_descriptors (h->hwdep_handle, &h->pfds, 1);
 		h->hwdep_pcm_shm = (snd_usX2Y_hwdep_pcm_shm_t*)
-			mmap(NULL, sizeof(snd_usX2Y_hwdep_pcm_shm_t),
-			     PROT_READ,
-			     MAP_SHARED, h->pfds.fd,
-			     0);
+				   mmap (NULL, sizeof(snd_usX2Y_hwdep_pcm_shm_t),
+					 PROT_READ,
+					 MAP_SHARED, h->pfds.fd,
+					 0);
 		if (MAP_FAILED == h->hwdep_pcm_shm) {
-			perror("ALSA/USX2Y: mmap");
+			perror ("ALSA/USX2Y: mmap");
 			return -1;
 		}
-		if (mprotect(h->hwdep_pcm_shm->playback,
-					sizeof(h->hwdep_pcm_shm->playback),
-					PROT_READ|PROT_WRITE)) {
-			perror("ALSA/USX2Y: mprotect");
+		if (mprotect (h->hwdep_pcm_shm->playback,
+			      sizeof(h->hwdep_pcm_shm->playback),
+			      PROT_READ | PROT_WRITE)) {
+			perror ("ALSA/USX2Y: mprotect");
 			return -1;
 		}
-		memset(h->hwdep_pcm_shm->playback, 0, sizeof(h->hwdep_pcm_shm->playback));
-/* 		for (i = 0, j = 0; i < 2000;) { */
-/* 			j += sprintf(buffer + j, "%04hX ", */
-/* 				     *(unsigned short*)(h->hwdep_pcm_shm->capture + i)); */
-/* 			if (((i += 2) % 32) == 0) { */
-/* 				jack_error(buffer); */
-/* 				j = 0; */
-/* 			} */
-/* 		} */
+		memset (h->hwdep_pcm_shm->playback, 0, sizeof(h->hwdep_pcm_shm->playback));
+/*              for (i = 0, j = 0; i < 2000;) { */
+/*                      j += sprintf(buffer + j, "%04hX ", */
+/*                                   *(unsigned short*)(h->hwdep_pcm_shm->capture + i)); */
+/*                      if (((i += 2) % 32) == 0) { */
+/*                              jack_error(buffer); */
+/*                              j = 0; */
+/*                      } */
+/*              } */
 	}
 
 	if (driver->hw_monitoring) {
@@ -269,7 +280,7 @@ usx2y_driver_start (alsa_driver_t *driver)
 	if (driver->playback_handle) {
 		/* fill playback buffer with zeroes, and mark
 		   all fragments as having data.
-		*/
+		 */
 
 		pavail = snd_pcm_avail_update (driver->playback_handle);
 
@@ -278,10 +289,10 @@ usx2y_driver_start (alsa_driver_t *driver)
 			return -1;
 		}
 
-		if (snd_pcm_mmap_begin(
-					driver->playback_handle,
-					&driver->playback_areas,
-					&poffset, &pavail) < 0) {
+		if (snd_pcm_mmap_begin (
+			    driver->playback_handle,
+			    &driver->playback_areas,
+			    &poffset, &pavail) < 0) {
 			return -1;
 		}
 
@@ -292,22 +303,22 @@ usx2y_driver_start (alsa_driver_t *driver)
 		   alsa-lib may have a better function for doing this
 		   here, where the goal is to silence the entire
 		   buffer.
-		*/
+		 */
 		{
-/* 			snd_pcm_uframes_t frag, nframes = driver->buffer_frames; */
-/* 			while (nframes) { */
-/* 				frag = nframes; */
-/* 				if (usx2y_driver_get_channel_addresses_playback(driver, &frag) < 0) */
-/* 					return -1; */
-
-/* 				for (chn = 0; chn < driver->playback_nchannels; chn++) */
-/* 					alsa_driver_silence_on_channel (driver, chn, frag); */
-/* 				nframes -= frag; */
-/* 			} */
+/*                      snd_pcm_uframes_t frag, nframes = driver->buffer_frames; */
+/*                      while (nframes) { */
+/*                              frag = nframes; */
+/*                              if (usx2y_driver_get_channel_addresses_playback(driver, &frag) < 0) */
+/*                                      return -1; */
+
+/*                              for (chn = 0; chn < driver->playback_nchannels; chn++) */
+/*                                      alsa_driver_silence_on_channel (driver, chn, frag); */
+/*                              nframes -= frag; */
+/*                      } */
 		}
 
 		snd_pcm_mmap_commit (driver->playback_handle, poffset,
-						driver->user_nperiods * driver->frames_per_cycle);
+				     driver->user_nperiods * driver->frames_per_cycle);
 
 		if ((err = snd_pcm_start (driver->playback_handle)) < 0) {
 			jack_error ("ALSA/USX2Y: could not start playback (%s)",
@@ -326,16 +337,16 @@ usx2y_driver_start (alsa_driver_t *driver)
 		}
 	}
 
-	driver->playback_nfds =	snd_pcm_poll_descriptors_count (driver->playback_handle);
+	driver->playback_nfds = snd_pcm_poll_descriptors_count (driver->playback_handle);
 	driver->capture_nfds = snd_pcm_poll_descriptors_count (driver->capture_handle);
 
 	if (driver->pfd) {
 		free (driver->pfd);
 	}
 
-	driver->pfd = (struct pollfd *)
-		malloc (sizeof (struct pollfd) *
-			(driver->playback_nfds + driver->capture_nfds + 2));
+	driver->pfd = (struct pollfd*)
+		      malloc (sizeof(struct pollfd) *
+			      (driver->playback_nfds + driver->capture_nfds + 2));
 
 	return 0;
 }
@@ -347,28 +358,28 @@ usx2y_driver_stop (alsa_driver_t *driver)
 	JSList* node;
 	int chn;
 
-	usx2y_t *h = (usx2y_t *) driver->hw->private;
+	usx2y_t *h = (usx2y_t*)driver->hw->private;
 
 	/* silence all capture port buffers, because we might
 	   be entering offline mode.
-	*/
+	 */
 
 	for (chn = 0, node = driver->capture_ports; node;
-		node = jack_slist_next (node), chn++) {
+	     node = jack_slist_next (node), chn++) {
 
 		jack_port_t* port;
 		char* buf;
 		jack_nframes_t nframes = driver->engine->control->buffer_size;
 
-		port = (jack_port_t *) node->data;
+		port = (jack_port_t*)node->data;
 		buf = jack_port_get_buffer (port, nframes);
-		memset (buf, 0, sizeof (jack_default_audio_sample_t) * nframes);
+		memset (buf, 0, sizeof(jack_default_audio_sample_t) * nframes);
 	}
 
 	if (driver->playback_handle) {
 		if ((err = snd_pcm_drop (driver->playback_handle)) < 0) {
 			jack_error ("ALSA/USX2Y: channel flush for playback "
-					"failed (%s)", snd_strerror (err));
+				    "failed (%s)", snd_strerror (err));
 			return -1;
 		}
 	}
@@ -377,7 +388,7 @@ usx2y_driver_stop (alsa_driver_t *driver)
 		driver->hw->set_input_monitor_mask (driver->hw, 0);
 	}
 
-	munmap(h->hwdep_pcm_shm, sizeof(snd_usX2Y_hwdep_pcm_shm_t));
+	munmap (h->hwdep_pcm_shm, sizeof(snd_usX2Y_hwdep_pcm_shm_t));
 
 	return 0;
 }
@@ -390,8 +401,8 @@ usx2y_driver_null_cycle (alsa_driver_t* driver, jack_nframes_t nframes)
 	snd_pcm_uframes_t contiguous, contiguous_;
 	int chn;
 
-	VERBOSE(driver->engine,
-		"usx2y_driver_null_cycle (%p, %i)", driver, nframes);
+	VERBOSE (driver->engine,
+		 "usx2y_driver_null_cycle (%p, %i)", driver, nframes);
 
 	if (driver->capture_handle) {
 		nf = nframes;
@@ -399,25 +410,26 @@ usx2y_driver_null_cycle (alsa_driver_t* driver, jack_nframes_t nframes)
 		while (nf) {
 
 			contiguous = (nf > driver->frames_per_cycle) ?
-				driver->frames_per_cycle : nf;
+				     driver->frames_per_cycle : nf;
 
 			if (snd_pcm_mmap_begin (
-					driver->capture_handle,
-					&driver->capture_areas,
-					(snd_pcm_uframes_t *) &offset,
-					(snd_pcm_uframes_t *) &contiguous)) {
+				    driver->capture_handle,
+				    &driver->capture_areas,
+				    (snd_pcm_uframes_t*)&offset,
+				    (snd_pcm_uframes_t*)&contiguous)) {
 				return -1;
 			}
 			contiguous_ = contiguous;
 			while (contiguous_) {
 				snd_pcm_uframes_t frag = contiguous_;
-				if (usx2y_driver_get_channel_addresses_capture(driver, &frag) < 0)
+				if (usx2y_driver_get_channel_addresses_capture (driver, &frag) < 0) {
 					return -1;
+				}
 				contiguous_ -= frag;
 			}
 
 			if (snd_pcm_mmap_commit (driver->capture_handle,
-						offset, contiguous) < 0) {
+						 offset, contiguous) < 0) {
 				return -1;
 			}
 
@@ -430,13 +442,13 @@ usx2y_driver_null_cycle (alsa_driver_t* driver, jack_nframes_t nframes)
 		offset = 0;
 		while (nf) {
 			contiguous = (nf > driver->frames_per_cycle) ?
-				driver->frames_per_cycle : nf;
+				     driver->frames_per_cycle : nf;
 
 			if (snd_pcm_mmap_begin (
 				    driver->playback_handle,
 				    &driver->playback_areas,
-				    (snd_pcm_uframes_t *) &offset,
-				    (snd_pcm_uframes_t *) &contiguous)) {
+				    (snd_pcm_uframes_t*)&offset,
+				    (snd_pcm_uframes_t*)&contiguous)) {
 				return -1;
 			}
 
@@ -444,8 +456,9 @@ usx2y_driver_null_cycle (alsa_driver_t* driver, jack_nframes_t nframes)
 				snd_pcm_uframes_t frag, nframes = contiguous;
 				while (nframes) {
 					frag = nframes;
-					if (usx2y_driver_get_channel_addresses_playback(driver, &frag) < 0)
+					if (usx2y_driver_get_channel_addresses_playback (driver, &frag) < 0) {
 						return -1;
+					}
 					for (chn = 0; chn < driver->playback_nchannels; chn++)
 						alsa_driver_silence_on_channel (driver, chn, frag);
 					nframes -= frag;
@@ -453,7 +466,7 @@ usx2y_driver_null_cycle (alsa_driver_t* driver, jack_nframes_t nframes)
 			}
 
 			if (snd_pcm_mmap_commit (driver->playback_handle,
-						offset, contiguous) < 0) {
+						 offset, contiguous) < 0) {
 				return -1;
 			}
 
@@ -493,7 +506,7 @@ usx2y_driver_read (alsa_driver_t *driver, jack_nframes_t nframes)
 
 	for (chn = 0, node = driver->capture_ports;
 	     node; node = jack_slist_next (node), chn++) {
-		port = (jack_port_t *) node->data;
+		port = (jack_port_t*)node->data;
 		if (!jack_port_connected (port)) {
 			continue;
 		}
@@ -509,7 +522,7 @@ usx2y_driver_read (alsa_driver_t *driver, jack_nframes_t nframes)
 		}
 		for (chn = 0, node = driver->capture_ports;
 		     node; node = jack_slist_next (node), chn++) {
-			port = (jack_port_t *) node->data;
+			port = (jack_port_t*)node->data;
 			if (!jack_port_connected (port)) {
 				/* no-copy optimization */
 				continue;
@@ -517,10 +530,10 @@ usx2y_driver_read (alsa_driver_t *driver, jack_nframes_t nframes)
 			alsa_driver_read_from_channel (driver, chn,
 						       buf[chn] + nread,
 						       contiguous);
-/* 			sample_move_dS_s24(buf[chn] + nread, */
-/* 					   driver->capture_addr[chn], */
-/* 					   contiguous, */
-/* 					   driver->capture_interleave_skip); */
+/*                      sample_move_dS_s24(buf[chn] + nread, */
+/*                                         driver->capture_addr[chn], */
+/*                                         contiguous, */
+/*                                         driver->capture_interleave_skip); */
 		}
 		nread += contiguous;
 		nframes -= contiguous;
@@ -562,24 +575,24 @@ usx2y_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
 	driver->input_monitor_mask = 0;
 
 	for (chn = 0, node = driver->capture_ports; node;
-		node = jack_slist_next (node), chn++) {
-		if (((jack_port_t *) node->data)->shared->monitor_requests) {
-			driver->input_monitor_mask |= (1<<chn);
+	     node = jack_slist_next (node), chn++) {
+		if (((jack_port_t*)node->data)->shared->monitor_requests) {
+			driver->input_monitor_mask |= (1 << chn);
 		}
 	}
 
 	if (driver->hw_monitoring) {
 		if ((driver->hw->input_monitor_mask
-			!= driver->input_monitor_mask)
-			&& !driver->all_monitor_in) {
+		     != driver->input_monitor_mask)
+		    && !driver->all_monitor_in) {
 			driver->hw->set_input_monitor_mask (
 				driver->hw, driver->input_monitor_mask);
 		}
 	}
 
-	if (snd_pcm_mmap_begin(driver->playback_handle,
-			       &driver->playback_areas,
-			       &offset, &nframes_) < 0) {
+	if (snd_pcm_mmap_begin (driver->playback_handle,
+				&driver->playback_areas,
+				&offset, &nframes_) < 0) {
 		jack_error ("ALSA/USX2Y: %s: mmap areas info error",
 			    driver->alsa_name_capture);
 		return -1;
@@ -587,7 +600,7 @@ usx2y_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
 
 	for (chn = 0, node = driver->playback_ports;
 	     node; node = jack_slist_next (node), chn++) {
-		port = (jack_port_t *) node->data;
+		port = (jack_port_t*)node->data;
 		buf[chn] = jack_port_get_buffer (port, nframes_);
 	}
 
@@ -600,7 +613,7 @@ usx2y_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
 		}
 		for (chn = 0, node = driver->playback_ports;
 		     node; node = jack_slist_next (node), chn++) {
-			port = (jack_port_t *) node->data;
+			port = (jack_port_t*)node->data;
 			alsa_driver_write_to_channel (driver, chn,
 						      buf[chn] + nwritten,
 						      contiguous);
@@ -613,8 +626,9 @@ usx2y_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
 					offset, nframes_)) < 0) {
 		jack_error ("ALSA/USX2Y: could not complete playback of %"
 			    PRIu32 " frames: error = %d", nframes_, err);
-		if (err != EPIPE && err != ESTRPIPE)
+		if (err != EPIPE && err != ESTRPIPE) {
 			return -1;
+		}
 	}
 
 	return 0;
@@ -623,12 +637,12 @@ usx2y_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
 static void
 usx2y_driver_setup (alsa_driver_t *driver)
 {
-	driver->nt_start = (JackDriverNTStartFunction) usx2y_driver_start;
-	driver->nt_stop = (JackDriverNTStopFunction) usx2y_driver_stop;
-	driver->read = (JackDriverReadFunction) usx2y_driver_read;
-	driver->write = (JackDriverReadFunction) usx2y_driver_write;
+	driver->nt_start = (JackDriverNTStartFunction)usx2y_driver_start;
+	driver->nt_stop = (JackDriverNTStopFunction)usx2y_driver_stop;
+	driver->read = (JackDriverReadFunction)usx2y_driver_read;
+	driver->write = (JackDriverReadFunction)usx2y_driver_write;
 	driver->null_cycle =
-		(JackDriverNullCycleFunction) usx2y_driver_null_cycle;
+		(JackDriverNullCycleFunction)usx2y_driver_null_cycle;
 }
 
 
@@ -638,13 +652,13 @@ jack_alsa_usx2y_hw_new (alsa_driver_t *driver)
 	jack_hardware_t *hw;
 	usx2y_t *h;
 
-	int   hwdep_cardno;
-    int   hwdep_devno;
+	int hwdep_cardno;
+	int hwdep_devno;
 	char *hwdep_colon;
-	char  hwdep_name[9];
+	char hwdep_name[9];
 	snd_hwdep_t *hwdep_handle;
 
-    hw = (jack_hardware_t *) malloc (sizeof (jack_hardware_t));
+	hw = (jack_hardware_t*)malloc (sizeof(jack_hardware_t));
 
 	hw->capabilities = 0;
 	hw->input_monitor_mask = 0;
@@ -661,22 +675,23 @@ jack_alsa_usx2y_hw_new (alsa_driver_t *driver)
 	 */
 	hwdep_handle = NULL;
 	hwdep_cardno = hwdep_devno = 0;
-	if ((hwdep_colon = strrchr(driver->alsa_name_playback, ':')) != NULL)
-		sscanf(hwdep_colon, ":%d,%d", &hwdep_cardno, &hwdep_devno);
+	if ((hwdep_colon = strrchr (driver->alsa_name_playback, ':')) != NULL) {
+		sscanf (hwdep_colon, ":%d,%d", &hwdep_cardno, &hwdep_devno);
+	}
 	if (hwdep_devno == 2) {
-		snprintf(hwdep_name, sizeof(hwdep_name), "hw:%d,1", hwdep_cardno);
+		snprintf (hwdep_name, sizeof(hwdep_name), "hw:%d,1", hwdep_cardno);
 		if (snd_hwdep_open (&hwdep_handle, hwdep_name, O_RDWR) < 0) {
 			jack_error ("ALSA/USX2Y: Cannot open hwdep device \"%s\"", hwdep_name);
 		} else {
 			/* Allocate specific USX2Y hwdep pcm struct. */
-			h = (usx2y_t *) malloc (sizeof (usx2y_t));
+			h = (usx2y_t*)malloc (sizeof(usx2y_t));
 			h->driver = driver;
 			h->hwdep_handle = hwdep_handle;
 			hw->private = h;
 			/* Set our own operational function pointers. */
-			usx2y_driver_setup(driver);
-			jack_info("ALSA/USX2Y: EXPERIMENTAL hwdep pcm device %s"
-				" (aka \"rawusb\")", driver->alsa_name_playback);
+			usx2y_driver_setup (driver);
+			jack_info ("ALSA/USX2Y: EXPERIMENTAL hwdep pcm device %s"
+				   " (aka \"rawusb\")", driver->alsa_name_playback);
 		}
 	}