Re-indent and style up serial ftdi

Signed-off-by: Anton Lundin <glance@acc.umu.se>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>

1 files changed, 329 insertions, 365 deletions

diff --git a/serial_ftdi.c b/serial_ftdi.c
index 6019bfe84..065cc88cc 100644
--- a/serial_ftdi.c
+++ b/serial_ftdi.c
@@ -46,31 +46,30 @@
 #define MAX_BACKOFF 500 // Max milliseconds to wait before timing out.
 
 struct serial_t {
-        /* Library ftdi_ctx. */
-        dc_context_t *context;
-        /*
-         * The file descriptor corresponding to the serial port.
-         * Also a libftdi_ftdi_ctx could be used?
-         */
-        struct ftdi_context *ftdi_ctx;
-        long timeout;
-        /*
-         * Serial port settings are saved into this variable immediately
-         * after the port is opened. These settings are restored when the
-         * serial port is closed.
+	/* Library ftdi_ctx. */
+	dc_context_t *context;
+	/*
+	 * The file descriptor corresponding to the serial port.
+	 * Also a libftdi_ftdi_ctx could be used?
+	 */
+	struct ftdi_context *ftdi_ctx;
+	long timeout;
+	/*
+	 * Serial port settings are saved into this variable immediately
+	 * after the port is opened. These settings are restored when the
+	 * serial port is closed.
 	 * Saving this using libftdi context or libusb. Search further.
 	 * Custom implementation using libftdi functions could be done.
-         */
+	 */
 
 	/* Half-duplex settings */
-        int halfduplex;
-        unsigned int baudrate;
-        unsigned int nbits;
+	int halfduplex;
+	unsigned int baudrate;
+	unsigned int nbits;
 };
 
 // Used internally for opening ftdi devices
-int
-open_ftdi_device (struct ftdi_context *ftdi_ctx)
+int open_ftdi_device (struct ftdi_context *ftdi_ctx)
 {
 	int accepted_pids[] = { 0x6001, 0x6010, 0x6011, // Suunto (Smart Interface), Heinrichs Weikamp
 		0xF460, // Oceanic
@@ -91,11 +90,10 @@ open_ftdi_device (struct ftdi_context *ftdi_ctx)
 	return ret;
 }
 
-int
-serial_enumerate (serial_callback_t callback, void *userdata)
+int serial_enumerate (serial_callback_t callback, void *userdata)
 {
 	// Unimplemented.
-        return -1;
+	return -1;
 }
 
 
@@ -103,21 +101,19 @@ serial_enumerate (serial_callback_t callback, void *userdata)
 // Open the serial port.
 // Initialise ftdi_context and use it to open the device
 //
-
-int
-serial_open (serial_t **out, dc_context_t *context, const char* name)
+int serial_open (serial_t **out, dc_context_t *context, const char* name)
 {
 	if (out == NULL)
 		return -1; // EINVAL (Invalid argument)
 
-        INFO (context, "Open: name=%s", name ? name : "");
+	INFO (context, "Open: name=%s", name ? name : "");
 
-        // Allocate memory.
-        serial_t *device = (serial_t *) malloc (sizeof (serial_t));
-        if (device == NULL) {
-                SYSERROR (context, errno);
-                return -1; // ENOMEM (Not enough space)
-        }
+	// Allocate memory.
+	serial_t *device = (serial_t *) malloc (sizeof (serial_t));
+	if (device == NULL) {
+		SYSERROR (context, errno);
+		return -1; // ENOMEM (Not enough space)
+	}
 
 	struct ftdi_context *ftdi_ctx = ftdi_new();
 	if (ftdi_ctx == NULL) {
@@ -125,223 +121,212 @@ serial_open (serial_t **out, dc_context_t *context, const char* name)
 		return -1; // ENOMEM (Not enough space)
 	}
 
-        // Library context.
-        device->context = context;
+	// Library context.
+	device->context = context;
 
-        // Default to blocking reads.
-        device->timeout = -1;
+	// Default to blocking reads.
+	device->timeout = -1;
 
-        // Default to full-duplex.
-        device->halfduplex = 0;
-        device->baudrate = 0;
-        device->nbits = 0;
+	// Default to full-duplex.
+	device->halfduplex = 0;
+	device->baudrate = 0;
+	device->nbits = 0;
 
 	// Initialize device ftdi context
-        ftdi_init(ftdi_ctx);
+	ftdi_init(ftdi_ctx);
 
-        if (ftdi_set_interface(ftdi_ctx,INTERFACE_ANY)) {
-                ERROR (context, ftdi_get_error_string(ftdi_ctx));
+	if (ftdi_set_interface(ftdi_ctx,INTERFACE_ANY)) {
+		ERROR (context, ftdi_get_error_string(ftdi_ctx));
 		return -1;
 	}
 
-        if (open_ftdi_device(ftdi_ctx) < 0) {
-                ERROR (context, ftdi_get_error_string(ftdi_ctx));
-                return -1;
-        }
+	if (open_ftdi_device(ftdi_ctx) < 0) {
+		ERROR (context, ftdi_get_error_string(ftdi_ctx));
+		return -1;
+	}
 
-        if (ftdi_usb_reset(ftdi_ctx)) {
-                ERROR (context, ftdi_get_error_string(ftdi_ctx));
+	if (ftdi_usb_reset(ftdi_ctx)) {
+		ERROR (context, ftdi_get_error_string(ftdi_ctx));
 		return -1;
 	}
 
-        if (ftdi_usb_purge_buffers(ftdi_ctx)) {
-                ERROR (context, ftdi_get_error_string(ftdi_ctx));
+	if (ftdi_usb_purge_buffers(ftdi_ctx)) {
+		ERROR (context, ftdi_get_error_string(ftdi_ctx));
 		return -1;
 	}
 
 	device->ftdi_ctx = ftdi_ctx;
-        *out = device;
+	*out = device;
 
-        return 0;
+	return 0;
 }
 
 //
 // Close the serial port.
 //
-
-int
-serial_close (serial_t *device)
+int serial_close (serial_t *device)
 {
 	if (device == NULL)
-                return 0;
+		return 0;
 
-        // Restore the initial terminal attributes.
+	// Restore the initial terminal attributes.
 	// See if it is possible using libusb or libftdi
 
 	int ret = ftdi_usb_close(device->ftdi_ctx);
 	if (ret < 0) {
 		ERROR (device->context, "Unable to close the ftdi device : %d (%s)\n",
-				ret, ftdi_get_error_string(device->ftdi_ctx));
+		       ret, ftdi_get_error_string(device->ftdi_ctx));
 		return ret;
 	}
 
 	ftdi_free(device->ftdi_ctx);
 
-        // Free memory.
-        free (device);
+	// Free memory.
+	free (device);
 
-        return 0;
+	return 0;
 }
 
 //
 // Configure the serial port (baudrate, databits, parity, stopbits and flowcontrol).
 //
-
-int
-serial_configure (serial_t *device, int baudrate, int databits, int parity, int stopbits, int flowcontrol)
+int serial_configure (serial_t *device, int baudrate, int databits, int parity, int stopbits, int flowcontrol)
 {
 	if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "Configure: baudrate=%i, databits=%i, parity=%i, stopbits=%i, flowcontrol=%i",
-                baudrate, databits, parity, stopbits, flowcontrol);
+	INFO (device->context, "Configure: baudrate=%i, databits=%i, parity=%i, stopbits=%i, flowcontrol=%i",
+	      baudrate, databits, parity, stopbits, flowcontrol);
 
-        enum ftdi_bits_type ft_bits;
-        enum ftdi_stopbits_type ft_stopbits;
-        enum ftdi_parity_type ft_parity;
+	enum ftdi_bits_type ft_bits;
+	enum ftdi_stopbits_type ft_stopbits;
+	enum ftdi_parity_type ft_parity;
 
-        if (ftdi_set_baudrate(device->ftdi_ctx, baudrate) < 0) {
-                ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+	if (ftdi_set_baudrate(device->ftdi_ctx, baudrate) < 0) {
+		ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 		return -1;
 	}
 
-        // Set the character size.
-        switch (databits) {
-        case 7:
-                ft_bits = BITS_7;
-                break;
-        case 8:
-                ft_bits = BITS_8;
-                break;
-        default:
-                return -1;
-        }
-
-        // Set the parity type.
-        switch (parity) {
-        case SERIAL_PARITY_NONE: // No parity
-                ft_parity = NONE;
-                break;
-        case SERIAL_PARITY_EVEN: // Even parity
-                ft_parity = EVEN;
-                break;
-        case SERIAL_PARITY_ODD: // Odd parity
-                ft_parity = ODD;
-                break;
-        default:
-
-                return -1;
-        }
-
-        // Set the number of stop bits.
-        switch (stopbits) {
-        case 1: // One stopbit
-                ft_stopbits = STOP_BIT_1;
-                break;
-        case 2: // Two stopbits
-                ft_stopbits = STOP_BIT_2;
-                break;
-        default:
-                return -1;
-        }
+	// Set the character size.
+	switch (databits) {
+	case 7:
+		ft_bits = BITS_7;
+		break;
+	case 8:
+		ft_bits = BITS_8;
+		break;
+	default:
+		return -1;
+	}
+
+	// Set the parity type.
+	switch (parity) {
+	case SERIAL_PARITY_NONE: // No parity
+		ft_parity = NONE;
+		break;
+	case SERIAL_PARITY_EVEN: // Even parity
+		ft_parity = EVEN;
+		break;
+	case SERIAL_PARITY_ODD: // Odd parity
+		ft_parity = ODD;
+		break;
+	default:
+
+		return -1;
+	}
+
+	// Set the number of stop bits.
+	switch (stopbits) {
+	case 1: // One stopbit
+		ft_stopbits = STOP_BIT_1;
+		break;
+	case 2: // Two stopbits
+		ft_stopbits = STOP_BIT_2;
+		break;
+	default:
+		return -1;
+	}
 
 	// Set the attributes
-        if (ftdi_set_line_property(device->ftdi_ctx, ft_bits, ft_stopbits, ft_parity)) {
-                ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+	if (ftdi_set_line_property(device->ftdi_ctx, ft_bits, ft_stopbits, ft_parity)) {
+		ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 		return -1;
 	}
 
-        // Set the flow control.
-        switch (flowcontrol) {
-        case SERIAL_FLOWCONTROL_NONE: // No flow control.
-                if (ftdi_setflowctrl(device->ftdi_ctx, SIO_DISABLE_FLOW_CTRL) < 0) {
-                        ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+	// Set the flow control.
+	switch (flowcontrol) {
+	case SERIAL_FLOWCONTROL_NONE: // No flow control.
+		if (ftdi_setflowctrl(device->ftdi_ctx, SIO_DISABLE_FLOW_CTRL) < 0) {
+			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
-                break;
-        case SERIAL_FLOWCONTROL_HARDWARE: // Hardware (RTS/CTS) flow control.
-               if (ftdi_setflowctrl(device->ftdi_ctx, SIO_RTS_CTS_HS) < 0) {
+		break;
+	case SERIAL_FLOWCONTROL_HARDWARE: // Hardware (RTS/CTS) flow control.
+		if (ftdi_setflowctrl(device->ftdi_ctx, SIO_RTS_CTS_HS) < 0) {
 			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
 		break;
-        case SERIAL_FLOWCONTROL_SOFTWARE: // Software (XON/XOFF) flow control.
-                if (ftdi_setflowctrl(device->ftdi_ctx, SIO_XON_XOFF_HS) < 0) {
-                        ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+	case SERIAL_FLOWCONTROL_SOFTWARE: // Software (XON/XOFF) flow control.
+		if (ftdi_setflowctrl(device->ftdi_ctx, SIO_XON_XOFF_HS) < 0) {
+			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
-                break;
-        default:
-                return -1;
-        }
+		break;
+	default:
+		return -1;
+	}
 
-        device->baudrate = baudrate;
-        device->nbits = 1 + databits + stopbits + (parity ? 1 : 0);
+	device->baudrate = baudrate;
+	device->nbits = 1 + databits + stopbits + (parity ? 1 : 0);
 
-        return 0;
+	return 0;
 }
 
 //
 // Configure the serial port (timeouts).
 //
-
-int
-serial_set_timeout (serial_t *device, long timeout)
+int serial_set_timeout (serial_t *device, long timeout)
 {
 	if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "Timeout: value=%li", timeout);
+	INFO (device->context, "Timeout: value=%li", timeout);
 
-        device->timeout = timeout;
+	device->timeout = timeout;
 
-        return 0;
+	return 0;
 }
 
 
 //
 // Configure the serial port (recommended size of the input/output buffers).
 //
-
-int
-serial_set_queue_size (serial_t *device, unsigned int input, unsigned int output)
+int serial_set_queue_size (serial_t *device, unsigned int input, unsigned int output)
 {
 	if (device == NULL)
-                return -1; // ERROR_INVALID_PARAMETER (The parameter is incorrect)
+		return -1; // ERROR_INVALID_PARAMETER (The parameter is incorrect)
 
 	ftdi_read_data_set_chunksize(device->ftdi_ctx, output);
-        ftdi_write_data_set_chunksize(device->ftdi_ctx, input);
+	ftdi_write_data_set_chunksize(device->ftdi_ctx, input);
 
 	return 0;
 }
 
-
-int
-serial_set_halfduplex (serial_t *device, int value)
+int serial_set_halfduplex (serial_t *device, int value)
 {
 	if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+		return -1; // EINVAL (Invalid argument)
 
 	// Most ftdi chips support full duplex operation. ft232rl does.
 	// Crosscheck other chips.
 
 	device->halfduplex = value;
 
-        return 0;
+	return 0;
 }
 
-int
-serial_set_latency (serial_t *device, unsigned int milliseconds)
+int serial_set_latency (serial_t *device, unsigned int milliseconds)
 {
 	if (device == NULL)
 		return -1; // EINVAL (Invalid argument)
@@ -351,60 +336,59 @@ serial_set_latency (serial_t *device, unsigned int milliseconds)
 
 	if (milliseconds < 1 || milliseconds > 255)
 		return -1;
-        ftdi_set_latency_timer(device->ftdi_ctx, milliseconds);
+	ftdi_set_latency_timer(device->ftdi_ctx, milliseconds);
 
-        return 0;
+	return 0;
 }
 
-int
-serial_read (serial_t *device, void *data, unsigned int size)
+int serial_read (serial_t *device, void *data, unsigned int size)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        // The total timeout.
-        long timeout = device->timeout;
+	// The total timeout.
+	long timeout = device->timeout;
 
-        // The absolute target time.
-        struct timeval tve;
+	// The absolute target time.
+	struct timeval tve;
 
 	static int backoff = 1;
-        int init = 1;
-        unsigned int nbytes = 0;
-        while (nbytes < size) {
-                struct timeval tvt;
-                if (timeout > 0) {
-                        struct timeval now;
-                        if (gettimeofday (&now, NULL) != 0) {
-                                SYSERROR (device->context, errno);
-                                return -1;
-                        }
-
-                        if (init) {
-                                // Calculate the initial timeout.
-                                tvt.tv_sec  = (timeout / 1000);
-                                tvt.tv_usec = (timeout % 1000) * 1000;
-                                // Calculate the target time.
-                                timeradd (&now, &tvt, &tve);
-                        } else {
-                                // Calculate the remaining timeout.
-                                if (timercmp (&now, &tve, <))
-                                        timersub (&tve, &now, &tvt);
-                                else
-                                        timerclear (&tvt);
-                        }
-                        init = 0;
-                } else if (timeout == 0) {
-                        timerclear (&tvt);
-                }
-
-                int n = ftdi_read_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
+	int init = 1;
+	unsigned int nbytes = 0;
+	while (nbytes < size) {
+		struct timeval tvt;
+		if (timeout > 0) {
+			struct timeval now;
+			if (gettimeofday (&now, NULL) != 0) {
+				SYSERROR (device->context, errno);
+				return -1;
+			}
+
+			if (init) {
+				// Calculate the initial timeout.
+				tvt.tv_sec  = (timeout / 1000);
+				tvt.tv_usec = (timeout % 1000) * 1000;
+				// Calculate the target time.
+				timeradd (&now, &tvt, &tve);
+			} else {
+				// Calculate the remaining timeout.
+				if (timercmp (&now, &tve, <))
+					timersub (&tve, &now, &tvt);
+				else
+					timerclear (&tvt);
+			}
+			init = 0;
+		} else if (timeout == 0) {
+			timerclear (&tvt);
+		}
+
+		int n = ftdi_read_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
 		if (n < 0) {
-                        if (n == LIBUSB_ERROR_INTERRUPTED)
-                                continue; //Retry.
-                        ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
-                        return -1; //Error during read call.
-                } else if (n == 0) {
+			if (n == LIBUSB_ERROR_INTERRUPTED)
+				continue; //Retry.
+			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+			return -1; //Error during read call.
+		} else if (n == 0) {
 			// Exponential backoff.
 			if (backoff > MAX_BACKOFF) {
 				ERROR(device->context, "FTDI read timed out.");
@@ -417,119 +401,113 @@ serial_read (serial_t *device, void *data, unsigned int size)
 			backoff = 1;
 		}
 
-                nbytes += n;
-        }
+		nbytes += n;
+	}
 
-        HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Read", (unsigned char *) data, nbytes);
+	HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Read", (unsigned char *) data, nbytes);
 
-        return nbytes;
+	return nbytes;
 }
 
-
-int
-serial_write (serial_t *device, const void *data, unsigned int size)
+int serial_write (serial_t *device, const void *data, unsigned int size)
 {
 	if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
-
-        struct timeval tve, tvb;
-        if (device->halfduplex) {
-                // Get the current time.
-                if (gettimeofday (&tvb, NULL) != 0) {
-                        SYSERROR (device->context, errno);
-                        return -1;
-                }
-        }
-
-        unsigned int nbytes = 0;
-        while (nbytes < size) {
-
-                int n = ftdi_write_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
-                if (n < 0) {
-                        if (n == LIBUSB_ERROR_INTERRUPTED)
-                                continue; // Retry.
-                        ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
-                        return -1; // Error during write call.
-                } else if (n == 0) {
-                         break; // EOF.
-                }
-
-                nbytes += n;
-        }
-
-        if (device->halfduplex) {
-                // Get the current time.
-                if (gettimeofday (&tve, NULL) != 0) {
-                        SYSERROR (device->context, errno);
-                        return -1;
-                }
-
-                // Calculate the elapsed time (microseconds).
-                struct timeval tvt;
-                timersub (&tve, &tvb, &tvt);
-                unsigned long elapsed = tvt.tv_sec * 1000000 + tvt.tv_usec;
-
-                // Calculate the expected duration (microseconds). A 2 millisecond fudge
-                // factor is added because it improves the success rate significantly.
-                unsigned long expected = 1000000.0 * device->nbits / device->baudrate * size + 0.5 + 2000;
-
-                // Wait for the remaining time.
-                if (elapsed < expected) {
-                        unsigned long remaining = expected - elapsed;
-
-                        // The remaining time is rounded up to the nearest millisecond to
-                        // match the Windows implementation. The higher resolution is
-                        // pointless anyway, since we already added a fudge factor above.
-                        serial_sleep (device, (remaining + 999) / 1000);
-                }
-        }
-
-        HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Write", (unsigned char *) data, nbytes);
-
-        return nbytes;
-}
+		return -1; // EINVAL (Invalid argument)
+
+	struct timeval tve, tvb;
+	if (device->halfduplex) {
+		// Get the current time.
+		if (gettimeofday (&tvb, NULL) != 0) {
+			SYSERROR (device->context, errno);
+			return -1;
+		}
+	}
+
+	unsigned int nbytes = 0;
+	while (nbytes < size) {
 
+		int n = ftdi_write_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
+		if (n < 0) {
+			if (n == LIBUSB_ERROR_INTERRUPTED)
+				continue; // Retry.
+			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+			return -1; // Error during write call.
+		} else if (n == 0) {
+			break; // EOF.
+		}
+
+		nbytes += n;
+	}
+
+	if (device->halfduplex) {
+		// Get the current time.
+		if (gettimeofday (&tve, NULL) != 0) {
+			SYSERROR (device->context, errno);
+			return -1;
+		}
 
-int
-serial_flush (serial_t *device, int queue)
+		// Calculate the elapsed time (microseconds).
+		struct timeval tvt;
+		timersub (&tve, &tvb, &tvt);
+		unsigned long elapsed = tvt.tv_sec * 1000000 + tvt.tv_usec;
+
+		// Calculate the expected duration (microseconds). A 2 millisecond fudge
+		// factor is added because it improves the success rate significantly.
+		unsigned long expected = 1000000.0 * device->nbits / device->baudrate * size + 0.5 + 2000;
+
+		// Wait for the remaining time.
+		if (elapsed < expected) {
+			unsigned long remaining = expected - elapsed;
+
+			// The remaining time is rounded up to the nearest millisecond to
+			// match the Windows implementation. The higher resolution is
+			// pointless anyway, since we already added a fudge factor above.
+			serial_sleep (device, (remaining + 999) / 1000);
+		}
+	}
+
+	HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Write", (unsigned char *) data, nbytes);
+
+	return nbytes;
+}
+
+int serial_flush (serial_t *device, int queue)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "Flush: queue=%u, input=%i, output=%i", queue,
-                serial_get_received (device),
-                serial_get_transmitted (device));
+	INFO (device->context, "Flush: queue=%u, input=%i, output=%i", queue,
+	      serial_get_received (device),
+	      serial_get_transmitted (device));
 
-        switch (queue) {
-        case SERIAL_QUEUE_INPUT:
-                if (ftdi_usb_purge_tx_buffer(device->ftdi_ctx)) {
+	switch (queue) {
+	case SERIAL_QUEUE_INPUT:
+		if (ftdi_usb_purge_tx_buffer(device->ftdi_ctx)) {
 			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
-                break;
-        case SERIAL_QUEUE_OUTPUT:
-                if (ftdi_usb_purge_rx_buffer(device->ftdi_ctx)) {
+		break;
+	case SERIAL_QUEUE_OUTPUT:
+		if (ftdi_usb_purge_rx_buffer(device->ftdi_ctx)) {
 			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
-                break;
-        default:
-                if (ftdi_usb_purge_buffers(device->ftdi_ctx)) {
+		break;
+	default:
+		if (ftdi_usb_purge_buffers(device->ftdi_ctx)) {
 			ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 			return -1;
 		}
-                break;
-        }
+		break;
+	}
 
-        return 0;
+	return 0;
 }
 
-
-int
-serial_send_break (serial_t *device)
+int serial_send_break (serial_t *device)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)a
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)a
 
 	INFO (device->context, "Break : One time period.");
 
@@ -538,133 +516,119 @@ serial_send_break (serial_t *device)
 	// and resetting the baudrate up again. But it has flaws.
 	// Not implementing it before researching more.
 
-        return -1;
+	return -1;
 }
 
-
-int
-serial_set_break (serial_t *device, int level)
+int serial_set_break (serial_t *device, int level)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "Break: value=%i", level);
+	INFO (device->context, "Break: value=%i", level);
 
 	// Not implemented in libftdi yet. Research it further.
 
-        return -1;
+	return -1;
 }
 
-
-int
-serial_set_dtr (serial_t *device, int level)
+int serial_set_dtr (serial_t *device, int level)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "DTR: value=%i", level);
+	INFO (device->context, "DTR: value=%i", level);
 
-        if (ftdi_setdtr(device->ftdi_ctx, level)) {
-                ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
-                return -1;
-        }
+	if (ftdi_setdtr(device->ftdi_ctx, level)) {
+		ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+		return -1;
+	}
 
-        return 0;
+	return 0;
 }
 
-
-int
-serial_set_rts (serial_t *device, int level)
+int serial_set_rts (serial_t *device, int level)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        INFO (device->context, "RTS: value=%i", level);
+	INFO (device->context, "RTS: value=%i", level);
 
-        if (ftdi_setrts(device->ftdi_ctx, level)) {
-                ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
-                return -1;
-        }
+	if (ftdi_setrts(device->ftdi_ctx, level)) {
+		ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+		return -1;
+	}
 
-        return 0;
+	return 0;
 }
 
-
-int
-serial_get_received (serial_t *device)
+int serial_get_received (serial_t *device)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        // Direct access is not encouraged. But function implementation
-        // is not available. The return quantity might be anything.
-        // Find out further about its possible values and correct way of
-        // access.
-        int bytes = device->ftdi_ctx->readbuffer_remaining;
+	// Direct access is not encouraged. But function implementation
+	// is not available. The return quantity might be anything.
+	// Find out further about its possible values and correct way of
+	// access.
+	int bytes = device->ftdi_ctx->readbuffer_remaining;
 
 	return bytes;
 }
 
-
-int
-serial_get_transmitted (serial_t *device)
+int serial_get_transmitted (serial_t *device)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
 	// This is not possible using libftdi. Look further into it.
-        return -1;
+	return -1;
 }
 
-
-int
-serial_get_line (serial_t *device, int line)
+int serial_get_line (serial_t *device, int line)
 {
-        if (device == NULL)
-                return -1; // EINVAL (Invalid argument)
+	if (device == NULL)
+		return -1; // EINVAL (Invalid argument)
 
-        unsigned short int status[2] = {0};
+	unsigned short int status[2] = {0};
 
 	if(ftdi_poll_modem_status(device->ftdi_ctx, status)) {
 		ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
 		return -1;
 	}
 
-        switch (line) {
-        case SERIAL_LINE_DCD:
-                return (status[0] & MODEM_DCD) == MODEM_DCD;
-        case SERIAL_LINE_CTS:
-                return (status[0] & MODEM_CTS) == MODEM_CTS;
-        case SERIAL_LINE_DSR:
-                return (status[0] & MODEM_DSR) == MODEM_DSR;
-        case SERIAL_LINE_RNG:
-                return (status[0] & MODEM_RNG) == MODEM_RNG;
-        default:
-                return -1;
-        }
-
-        return 0;
-}
+	switch (line) {
+	case SERIAL_LINE_DCD:
+		return (status[0] & MODEM_DCD) == MODEM_DCD;
+	case SERIAL_LINE_CTS:
+		return (status[0] & MODEM_CTS) == MODEM_CTS;
+	case SERIAL_LINE_DSR:
+		return (status[0] & MODEM_DSR) == MODEM_DSR;
+	case SERIAL_LINE_RNG:
+		return (status[0] & MODEM_RNG) == MODEM_RNG;
+	default:
+		return -1;
+	}
 
+	return 0;
+}
 
-int
-serial_sleep (serial_t *device, unsigned long timeout)
+int serial_sleep (serial_t *device, unsigned long timeout)
 {
-        if (device == NULL)
-                return -1;
+	if (device == NULL)
+		return -1;
 
-        INFO (device->context, "Sleep: value=%lu", timeout);
+	INFO (device->context, "Sleep: value=%lu", timeout);
 
-        struct timespec ts;
-        ts.tv_sec  = (timeout / 1000);
-        ts.tv_nsec = (timeout % 1000) * 1000000;
+	struct timespec ts;
+	ts.tv_sec  = (timeout / 1000);
+	ts.tv_nsec = (timeout % 1000) * 1000000;
 
-        while (nanosleep (&ts, &ts) != 0) {
-                if (errno != EINTR ) {
-                        SYSERROR (device->context, errno);
-                        return -1;
-                }
-        }
+	while (nanosleep (&ts, &ts) != 0) {
+		if (errno != EINTR ) {
+			SYSERROR (device->context, errno);
+			return -1;
+		}
+	}
 
 
 	return 0;