rb-blink1 0.0.6 → 0.0.7

data/ext/blink1/blink1.c

@@ -230,6 +230,20 @@ static VALUE rb_blink1_fadeToRGB(VALUE self, VALUE fadeMillis, VALUE r, VALUE g,
   return INT2NUM(blink1_fadeToRGB(ins->dev, FIX2UINT(fadeMillis), FIX2UINT(r), FIX2UINT(g), FIX2UINT(b)));
 }
 
+/**
+ * :call-seq:
+ *   <span class="name">fade_to_rgbn</span> <span class="arguments">(fade_millis, r, g, b, n) -> integer</span>
+ *
+ * Fade a specific (blink(1) mk2) LED LED color to RGB in +fade_millis+.
+ *
+ * Return the actual number of bytes written and -1 on error.
+ */
+static VALUE rb_blink1_fadeToRGBN(VALUE self, VALUE fadeMillis, VALUE r, VALUE g, VALUE b, VALUE n) {
+  struct Blink1Instance *ins;
+  Data_Get_Struct(self, struct Blink1Instance, ins);
+  return INT2NUM(blink1_fadeToRGBN(ins->dev, FIX2UINT(fadeMillis), FIX2UINT(r), FIX2UINT(g), FIX2UINT(b), FIX2UINT(n)));
+}
+
 /**
  * :call-seq:
  *   <span class="name">set_rgb</span> <span class="arguments">(r, g, b) -> integer</span>
@@ -404,6 +418,7 @@ void Init_blink1() {
   rb_define_method(klass, "close",              rb_blink1_close,            0);
   rb_define_method(klass, "version",            rb_blink1_getVersion,       0);
   rb_define_method(klass, "fade_to_rgb",        rb_blink1_fadeToRGB,        4);
+  rb_define_method(klass, "fade_to_rgbn",       rb_blink1_fadeToRGBN,       5);
   rb_define_method(klass, "set_rgb",            rb_blink1_setRGB,           3);
   rb_define_method(klass, "eeread",             rb_blink1_eeread,           1);
   rb_define_method(klass, "eewrite",            rb_blink1_eewrite,          2);

data/ext/blink1/hid.c.libusb

@@ -11,7 +11,7 @@
  FreeBSD Version - 11/1/2011
 
  Copyright 2009, All Rights Reserved.
- 
+
  At the discretion of the user of this library,
  this software may be licensed under the terms of the
  GNU Public License v3, a BSD-Style license, or the
@@ -23,7 +23,7 @@
         http://github.com/signal11/hidapi .
 ********************************************************/
 
-#define _GNU_SOURCE // needed for wcsdup() before glibc 2.10
+#define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */
 
 /* C */
 #include <stdio.h>
@@ -82,23 +82,23 @@ struct input_report {
 struct hid_device_ {
 	/* Handle to the actual device. */
 	libusb_device_handle *device_handle;
-	
+
 	/* Endpoint information */
 	int input_endpoint;
 	int output_endpoint;
 	int input_ep_max_packet_size;
 
-	/* The interface number of the HID */	
+	/* The interface number of the HID */
 	int interface;
-	
+
 	/* Indexes of Strings */
 	int manufacturer_index;
 	int product_index;
 	int serial_index;
-	
+
 	/* Whether blocking reads are used */
 	int blocking; /* boolean */
-	
+
 	/* Read thread objects */
 	pthread_t thread;
 	pthread_mutex_t mutex; /* Protects input_reports */
@@ -120,11 +120,11 @@ static hid_device *new_hid_device(void)
 {
 	hid_device *dev = calloc(1, sizeof(hid_device));
 	dev->blocking = 1;
-	
+
 	pthread_mutex_init(&dev->mutex, NULL);
 	pthread_cond_init(&dev->condition, NULL);
 	pthread_barrier_init(&dev->barrier, NULL, 2);
-	
+
 	return dev;
 }
 
@@ -140,7 +140,7 @@ static void free_hid_device(hid_device *dev)
 }
 
 #if 0
-//TODO: Implement this funciton on hidapi/libusb..
+/*TODO: Implement this funciton on hidapi/libusb.. */
 static void register_error(hid_device *device, const char *op)
 {
 
@@ -181,17 +181,17 @@ static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur
 static int get_usage(uint8_t *report_descriptor, size_t size,
                      unsigned short *usage_page, unsigned short *usage)
 {
-	int i = 0;
+	unsigned int i = 0;
 	int size_code;
 	int data_len, key_size;
 	int usage_found = 0, usage_page_found = 0;
-	
+
 	while (i < size) {
 		int key = report_descriptor[i];
 		int key_cmd = key & 0xfc;
 
 		//printf("key: %02hhx\n", key);
-		
+
 		if ((key & 0xf0) == 0xf0) {
 			/* This is a Long Item. The next byte contains the
 			   length of the data section (value) for this key.
@@ -226,7 +226,7 @@ static int get_usage(uint8_t *report_descriptor, size_t size,
 			};
 			key_size = 1;
 		}
-		
+
 		if (key_cmd == 0x4) {
 			*usage_page  = get_bytes(report_descriptor, size, data_len, i);
 			usage_page_found = 1;
@@ -240,14 +240,14 @@ static int get_usage(uint8_t *report_descriptor, size_t size,
 
 		if (usage_page_found && usage_found)
 			return 0; /* success */
-		
+
 		/* Skip over this key and it's associated data */
 		i += data_len + key_size;
 	}
-	
+
 	return -1; /* failure */
 }
-#endif // INVASIVE_GET_USAGE
+#endif /* INVASIVE_GET_USAGE */
 
 #ifdef __FreeBSD__
 /* The FreeBSD version of libusb doesn't have this funciton. In mainline
@@ -277,7 +277,7 @@ static uint16_t get_first_language(libusb_device_handle *dev)
 {
 	uint16_t buf[32];
 	int len;
-	
+
 	/* Get the string from libusb. */
 	len = libusb_get_string_descriptor(dev,
 			0x0, /* String ID */
@@ -286,8 +286,8 @@ static uint16_t get_first_language(libusb_device_handle *dev)
 			sizeof(buf));
 	if (len < 4)
 		return 0x0;
-	
-	return buf[1]; // First two bytes are len and descriptor type.
+
+	return buf[1]; /* First two bytes are len and descriptor type. */
 }
 
 static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
@@ -295,7 +295,7 @@ static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
 	uint16_t buf[32];
 	int len;
 	int i;
-	
+
 	/* Get the string from libusb. */
 	len = libusb_get_string_descriptor(dev,
 			0x0, /* String ID */
@@ -304,8 +304,8 @@ static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
 			sizeof(buf));
 	if (len < 4)
 		return 0x0;
-	
-	
+
+
 	len /= 2; /* language IDs are two-bytes each. */
 	/* Start at index 1 because there are two bytes of protocol data. */
 	for (i = 1; i < len; i++) {
@@ -344,7 +344,7 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 	lang = get_usb_code_for_current_locale();
 	if (!is_language_supported(dev, lang))
 		lang = get_first_language(dev);
-		
+
 	/* Get the string from libusb. */
 	len = libusb_get_string_descriptor(dev,
 			idx,
@@ -353,17 +353,17 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 			sizeof(buf));
 	if (len < 0)
 		return NULL;
-	
+
 	/* buf does not need to be explicitly NULL-terminated because
 	   it is only passed into iconv() which does not need it. */
-	
+
 	/* Initialize iconv. */
 	ic = iconv_open("WCHAR_T", "UTF-16LE");
 	if (ic == (iconv_t)-1) {
 		LOG("iconv_open() failed\n");
 		return NULL;
 	}
-	
+
 	/* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
 	   Skip the first character (2-bytes). */
 	inptr = buf+2;
@@ -380,13 +380,13 @@ static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
 	wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
 	if (outbytes >= sizeof(wbuf[0]))
 		*((wchar_t*)outptr) = 0x00000000;
-	
+
 	/* Allocate and copy the string. */
 	str = wcsdup(wbuf);
 
 err:
 	iconv_close(ic);
-	
+
 	return str;
 }
 
@@ -398,7 +398,7 @@ static char *make_path(libusb_device *dev, int interface_number)
 		libusb_get_device_address(dev),
 		interface_number);
 	str[sizeof(str)-1] = '\0';
-	
+
 	return strdup(str);
 }
 
@@ -438,11 +438,12 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 	libusb_device_handle *handle;
 	ssize_t num_devs;
 	int i = 0;
-	
-	struct hid_device_info *root = NULL; // return object
+
+	struct hid_device_info *root = NULL; /* return object */
 	struct hid_device_info *cur_dev = NULL;
-	
-	hid_init();
+
+	if(hid_init() < 0)
+		return NULL;
 
 	num_devs = libusb_get_device_list(usb_context, &devs);
 	if (num_devs < 0)
@@ -456,10 +457,6 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 		int res = libusb_get_device_descriptor(dev, &desc);
 		unsigned short dev_vid = desc.idVendor;
 		unsigned short dev_pid = desc.idProduct;
-		
-		/* HID's are defined at the interface level. */
-		if (desc.bDeviceClass != LIBUSB_CLASS_PER_INTERFACE)
-			continue;
 
 		res = libusb_get_active_config_descriptor(dev, &conf_desc);
 		if (res < 0)
@@ -474,8 +471,8 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 						interface_num = intf_desc->bInterfaceNumber;
 
 						/* Check the VID/PID against the arguments */
-						if ((vendor_id == 0x0 && product_id == 0x0) ||
-						    (vendor_id == dev_vid && product_id == dev_pid)) {
+						if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
+						    (product_id == 0x0 || product_id == dev_pid)) {
 							struct hid_device_info *tmp;
 
 							/* VID/PID match. Create the record. */
@@ -487,11 +484,11 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 								root = tmp;
 							}
 							cur_dev = tmp;
-							
+
 							/* Fill out the record */
 							cur_dev->next = NULL;
 							cur_dev->path = make_path(dev, interface_num);
-							
+
 							res = libusb_open(dev, &handle);
 
 							if (res >= 0) {
@@ -509,6 +506,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 										get_usb_string(handle, desc.iProduct);
 
 #ifdef INVASIVE_GET_USAGE
+{
 							/*
 							This section is removed because it is too
 							invasive on the system. Getting a Usage Page
@@ -567,8 +565,8 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 										LOG("Couldn't re-attach kernel driver.\n");
 								}
 #endif
-
-#endif // INVASIVE_GET_USAGE
+}
+#endif /* INVASIVE_GET_USAGE */
 
 								libusb_close(handle);
 							}
@@ -578,7 +576,7 @@ struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
 
 							/* Release Number */
 							cur_dev->release_number = desc.bcdDevice;
-							
+
 							/* Interface Number */
 							cur_dev->interface_number = interface_num;
 						}
@@ -613,7 +611,7 @@ hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const
 	struct hid_device_info *devs, *cur_dev;
 	const char *path_to_open = NULL;
 	hid_device *handle = NULL;
-	
+
 	devs = hid_enumerate(vendor_id, product_id);
 	cur_dev = devs;
 	while (cur_dev) {
@@ -639,7 +637,7 @@ hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const
 	}
 
 	hid_free_enumeration(devs);
-	
+
 	return handle;
 }
 
@@ -647,7 +645,7 @@ static void read_callback(struct libusb_transfer *transfer)
 {
 	hid_device *dev = transfer->user_data;
 	int res;
-	
+
 	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
 
 		struct input_report *rpt = malloc(sizeof(*rpt));
@@ -673,13 +671,13 @@ static void read_callback(struct libusb_transfer *transfer)
 				num_queued++;
 			}
 			cur->next = rpt;
-			
+
 			/* Pop one off if we've reached 30 in the queue. This
 			   way we don't grow forever if the user never reads
 			   anything from the device. */
 			if (num_queued > 30) {
 				return_data(dev, NULL, 0);
-			}			
+			}
 		}
 		pthread_mutex_unlock(&dev->mutex);
 	}
@@ -697,7 +695,7 @@ static void read_callback(struct libusb_transfer *transfer)
 	else {
 		LOG("Unknown transfer code: %d\n", transfer->status);
 	}
-	
+
 	/* Re-submit the transfer object. */
 	res = libusb_submit_transfer(transfer);
 	if (res != 0) {
@@ -724,14 +722,14 @@ static void *read_thread(void *param)
 		read_callback,
 		dev,
 		5000/*timeout*/);
-	
+
 	/* Make the first submission. Further submissions are made
 	   from inside read_callback() */
 	libusb_submit_transfer(dev->transfer);
 
-	// Notify the main thread that the read thread is up and running.
+	/* Notify the main thread that the read thread is up and running. */
 	pthread_barrier_wait(&dev->barrier);
-	
+
 	/* Handle all the events. */
 	while (!dev->shutdown_thread) {
 		int res;
@@ -749,14 +747,14 @@ static void *read_thread(void *param)
 			}
 		}
 	}
-	
+
 	/* Cancel any transfer that may be pending. This call will fail
 	   if no transfers are pending, but that's OK. */
 	if (libusb_cancel_transfer(dev->transfer) == 0) {
 		/* The transfer was cancelled, so wait for its completion. */
 		libusb_handle_events(usb_context);
 	}
-	
+
 	/* Now that the read thread is stopping, Wake any threads which are
 	   waiting on data (in hid_read_timeout()). Do this under a mutex to
 	   make sure that a thread which is about to go to sleep waiting on
@@ -773,7 +771,7 @@ static void *read_thread(void *param)
 	   cleaned up after the call to pthread_join() (in hid_close()), but
 	   since hid_close() calls libusb_cancel_transfer(), on these objects,
 	   they can not be cleaned up here. */
-	
+
 	return NULL;
 }
 
@@ -782,18 +780,18 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 {
 	hid_device *dev = NULL;
 
-	dev = new_hid_device();
-
 	libusb_device **devs;
 	libusb_device *usb_dev;
-	ssize_t num_devs;
 	int res;
 	int d = 0;
 	int good_open = 0;
-	
-	hid_init();
 
-	num_devs = libusb_get_device_list(usb_context, &devs);
+	dev = new_hid_device();
+
+	if(hid_init() < 0)
+		return NULL;
+
+	libusb_get_device_list(usb_context, &devs);
 	while ((usb_dev = devs[d++]) != NULL) {
 		struct libusb_device_descriptor desc;
 		struct libusb_config_descriptor *conf_desc = NULL;
@@ -812,12 +810,12 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 					if (!strcmp(dev_path, path)) {
 						/* Matched Paths. Open this device */
 
-						// OPEN HERE //
+						/* OPEN HERE */
 						res = libusb_open(usb_dev, &dev->device_handle);
 						if (res < 0) {
 							LOG("can't open device\n");
 							free(dev_path);
- 							break;
+							break;
 						}
 						good_open = 1;
 #ifdef DETACH_KERNEL_DRIVER
@@ -850,7 +848,7 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 
 						/* Store off the interface number */
 						dev->interface = intf_desc->bInterfaceNumber;
-												
+
 						/* Find the INPUT and OUTPUT endpoints. An
 						   OUTPUT endpoint is not required. */
 						for (i = 0; i < intf_desc->bNumEndpoints; i++) {
@@ -862,10 +860,10 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 							int is_interrupt =
 								(ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
 							      == LIBUSB_TRANSFER_TYPE_INTERRUPT;
-							int is_output = 
+							int is_output =
 								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
 							      == LIBUSB_ENDPOINT_OUT;
-							int is_input = 
+							int is_input =
 								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
 							      == LIBUSB_ENDPOINT_IN;
 
@@ -882,12 +880,12 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 								dev->output_endpoint = ep->bEndpointAddress;
 							}
 						}
-						
+
 						pthread_create(&dev->thread, NULL, read_thread, dev);
-						
-						// Wait here for the read thread to be initialized.
+
+						/* Wait here for the read thread to be initialized. */
 						pthread_barrier_wait(&dev->barrier);
-						
+
 					}
 					free(dev_path);
 				}
@@ -898,13 +896,13 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
 	}
 
 	libusb_free_device_list(devs, 1);
-	
-	// If we have a good handle, return it.
+
+	/* If we have a good handle, return it. */
 	if (good_open) {
 		return dev;
 	}
 	else {
-		// Unable to open any devices.
+		/* Unable to open any devices. */
 		free_hid_device(dev);
 		return NULL;
 	}
@@ -933,13 +931,13 @@ int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t
 			dev->interface,
 			(unsigned char *)data, length,
 			1000/*timeout millis*/);
-		
+
 		if (res < 0)
 			return -1;
-		
+
 		if (skipped_report_id)
 			length++;
-		
+
 		return length;
 	}
 	else {
@@ -950,13 +948,13 @@ int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t
 			(unsigned char*)data,
 			length,
 			&actual_length, 1000);
-		
+
 		if (res < 0)
 			return -1;
-		
+
 		if (skipped_report_id)
 			actual_length++;
-		
+
 		return actual_length;
 	}
 }
@@ -1004,14 +1002,14 @@ int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t
 		bytes_read = return_data(dev, data, length);
 		goto ret;
 	}
-	
+
 	if (dev->shutdown_thread) {
 		/* This means the device has been disconnected.
 		   An error code of -1 should be returned. */
 		bytes_read = -1;
 		goto ret;
 	}
-	
+
 	if (milliseconds == -1) {
 		/* Blocking */
 		while (!dev->input_reports && !dev->shutdown_thread) {
@@ -1032,7 +1030,7 @@ int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t
 			ts.tv_sec++;
 			ts.tv_nsec -= 1000000000L;
 		}
-		
+
 		while (!dev->input_reports && !dev->shutdown_thread) {
 			res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
 			if (res == 0) {
@@ -1040,7 +1038,7 @@ int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t
 					bytes_read = return_data(dev, data, length);
 					break;
 				}
-				
+
 				/* If we're here, there was a spurious wake up
 				   or the read thread was shutdown. Run the
 				   loop again (ie: don't break). */
@@ -1077,7 +1075,7 @@ int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
 int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
 {
 	dev->blocking = !nonblock;
-	
+
 	return 0;
 }
 
@@ -1101,14 +1099,14 @@ int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char
 		dev->interface,
 		(unsigned char *)data, length,
 		1000/*timeout millis*/);
-	
+
 	if (res < 0)
 		return -1;
-	
+
 	/* Account for the report ID */
 	if (skipped_report_id)
 		length++;
-	
+
 	return length;
 }
 
@@ -1132,13 +1130,13 @@ int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data,
 		dev->interface,
 		(unsigned char *)data, length,
 		1000/*timeout millis*/);
-	
+
 	if (res < 0)
 		return -1;
 
 	if (skipped_report_id)
 		res++;
-	
+
 	return res;
 }
 
@@ -1147,31 +1145,31 @@ void HID_API_EXPORT hid_close(hid_device *dev)
 {
 	if (!dev)
 		return;
-	
+
 	/* Cause read_thread() to stop. */
 	dev->shutdown_thread = 1;
 	libusb_cancel_transfer(dev->transfer);
 
 	/* Wait for read_thread() to end. */
 	pthread_join(dev->thread, NULL);
-	
+
 	/* Clean up the Transfer objects allocated in read_thread(). */
 	free(dev->transfer->buffer);
 	libusb_free_transfer(dev->transfer);
-	
+
 	/* release the interface */
 	libusb_release_interface(dev->device_handle, dev->interface);
-	
+
 	/* Close the handle */
 	libusb_close(dev->device_handle);
-	
+
 	/* Clear out the queue of received reports. */
 	pthread_mutex_lock(&dev->mutex);
 	while (dev->input_reports) {
 		return_data(dev, NULL, 0);
 	}
 	pthread_mutex_unlock(&dev->mutex);
-	
+
 	free_hid_device(dev);
 }
 
@@ -1354,7 +1352,7 @@ static struct lang_map_entry lang_map[] = {
 	LANG("Xhosa", "xh", 0x0434),
 	LANG("Yiddish", "yi", 0x043D),
 	LANG("Zulu", "zu", 0x0435),
-	LANG(NULL, NULL, 0x0),	
+	LANG(NULL, NULL, 0x0),
 };
 
 uint16_t get_usb_code_for_current_locale(void)
@@ -1362,16 +1360,17 @@ uint16_t get_usb_code_for_current_locale(void)
 	char *locale;
 	char search_string[64];
 	char *ptr;
-	
+	struct lang_map_entry *lang;
+
 	/* Get the current locale. */
 	locale = setlocale(0, NULL);
 	if (!locale)
 		return 0x0;
-	
+
 	/* Make a copy of the current locale string. */
 	strncpy(search_string, locale, sizeof(search_string));
 	search_string[sizeof(search_string)-1] = '\0';
-	
+
 	/* Chop off the encoding part, and make it lower case. */
 	ptr = search_string;
 	while (*ptr) {
@@ -1384,14 +1383,14 @@ uint16_t get_usb_code_for_current_locale(void)
 	}
 
 	/* Find the entry which matches the string code of our locale. */
-	struct lang_map_entry *lang = lang_map;
+	lang = lang_map;
 	while (lang->string_code) {
 		if (!strcmp(lang->string_code, search_string)) {
 			return lang->usb_code;
-		}	
+		}
 		lang++;
 	}
-	
+
 	/* There was no match. Find with just the language only. */
 	/* Chop off the variant. Chop it off at the '_'. */
 	ptr = search_string;
@@ -1403,22 +1402,22 @@ uint16_t get_usb_code_for_current_locale(void)
 		}
 		ptr++;
 	}
-	
-#if 0 // TODO: Do we need this?
+
+#if 0 /* TODO: Do we need this? */
 	/* Find the entry which matches the string code of our language. */
 	lang = lang_map;
 	while (lang->string_code) {
 		if (!strcmp(lang->string_code, search_string)) {
 			return lang->usb_code;
-		}	
+		}
 		lang++;
 	}
 #endif
-	
+
 	/* Found nothing. */
 	return 0x0;
 }
 
 #ifdef __cplusplus
 }
-#endif
+#endif