Staging: west bridge, removal of " " before ";"

This patch fixes removes all of the the " ;"'s in the west bridge driver
and instead replaces them with ";" only. Although this is a large patch,
this is the only thing that it does. I can break it up on a file basis
if needed.
Signed-off-by: David Cross <david.cross@cypress.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

drivers/staging/westbridge/astoria/api/src/cyasintr.c

@@ -24,80 +24,80 @@
 #include "../../include/linux/westbridge/cyasregs.h"
 #include "../../include/linux/westbridge/cyaserr.h"
 
-extern void cy_as_mail_box_interrupt_handler(cy_as_device *) ;
+extern void cy_as_mail_box_interrupt_handler(cy_as_device *);
 
 void
 cy_as_mcu_interrupt_handler(cy_as_device *dev_p)
 {
 	/* Read and clear the interrupt. */
-	uint16_t v ;
+	uint16_t v;
 
-	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_MCU_STAT) ;
-	v = v ;
+	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_MCU_STAT);
+	v = v;
 }
 
 void
 cy_as_power_management_interrupt_handler(cy_as_device *dev_p)
 {
-	uint16_t v ;
+	uint16_t v;
 
-	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PWR_MAGT_STAT) ;
-	v = v ;
+	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PWR_MAGT_STAT);
+	v = v;
 }
 
 void
 cy_as_pll_lock_loss_interrupt_handler(cy_as_device *dev_p)
 {
-	uint16_t v ;
+	uint16_t v;
 
-	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PLL_LOCK_LOSS_STAT) ;
-	v = v ;
+	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PLL_LOCK_LOSS_STAT);
+	v = v;
 }
 
 uint32_t cy_as_intr_start(cy_as_device *dev_p, cy_bool dmaintr)
 {
-	uint16_t v ;
+	uint16_t v;
 
-	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
 
 	if (cy_as_device_is_intr_running(dev_p) != 0)
-		return CY_AS_ERROR_ALREADY_RUNNING ;
+		return CY_AS_ERROR_ALREADY_RUNNING;
 
 	v = CY_AS_MEM_P0_INT_MASK_REG_MMCUINT |
 		CY_AS_MEM_P0_INT_MASK_REG_MMBINT |
-		CY_AS_MEM_P0_INT_MASK_REG_MPMINT ;
+		CY_AS_MEM_P0_INT_MASK_REG_MPMINT;
 
 	if (dmaintr)
-		v |= CY_AS_MEM_P0_INT_MASK_REG_MDRQINT ;
+		v |= CY_AS_MEM_P0_INT_MASK_REG_MDRQINT;
 
 	/* Enable the interrupts of interest */
-	cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, v) ;
+	cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, v);
 
 	/* Mark the interrupt module as initialized */
-	cy_as_device_set_intr_running(dev_p) ;
+	cy_as_device_set_intr_running(dev_p);
 
-	return CY_AS_ERROR_SUCCESS ;
+	return CY_AS_ERROR_SUCCESS;
 }
 
 uint32_t cy_as_intr_stop(cy_as_device *dev_p)
 {
-	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
 
 	if (cy_as_device_is_intr_running(dev_p) == 0)
-		return CY_AS_ERROR_NOT_RUNNING ;
+		return CY_AS_ERROR_NOT_RUNNING;
 
-	cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, 0) ;
-	cy_as_device_set_intr_stopped(dev_p) ;
+	cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, 0);
+	cy_as_device_set_intr_stopped(dev_p);
 
-	return CY_AS_ERROR_SUCCESS ;
+	return CY_AS_ERROR_SUCCESS;
 }
 
 void cy_as_intr_service_interrupt(cy_as_hal_device_tag tag)
 {
-	uint16_t v ;
-	cy_as_device *dev_p ;
+	uint16_t v;
+	cy_as_device *dev_p;
 
-	dev_p = cy_as_device_find_from_tag(tag) ;
+	dev_p = cy_as_device_find_from_tag(tag);
 
 	/*
 	 * only power management interrupts can occur before the
@@ -105,39 +105,39 @@ void cy_as_intr_service_interrupt(cy_as_hal_device_tag tag)
 	 *  handle it here; otherwise output a warning message.
 	 */
 	if (dev_p == 0) {
-		v = cy_as_hal_read_register(tag, CY_AS_MEM_P0_INTR_REG) ;
+		v = cy_as_hal_read_register(tag, CY_AS_MEM_P0_INTR_REG);
 		if (v == CY_AS_MEM_P0_INTR_REG_PMINT) {
 			/* Read the PWR_MAGT_STAT register
 			 * to clear this interrupt. */
 			v = cy_as_hal_read_register(tag,
-				CY_AS_MEM_PWR_MAGT_STAT) ;
+				CY_AS_MEM_PWR_MAGT_STAT);
 		} else
 			cy_as_hal_print_message("stray antioch "
 				"interrupt detected"
 				", tag not associated "
-				"with any created device.") ;
-		return ;
+				"with any created device.");
+		return;
 	}
 
 	/* Make sure we got a valid object from CyAsDeviceFindFromTag */
-	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+	cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
 
-	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_INTR_REG) ;
+	v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_INTR_REG);
 
 	if (v & CY_AS_MEM_P0_INTR_REG_MCUINT)
-		cy_as_mcu_interrupt_handler(dev_p) ;
+		cy_as_mcu_interrupt_handler(dev_p);
 
 	if (v & CY_AS_MEM_P0_INTR_REG_PMINT)
-		cy_as_power_management_interrupt_handler(dev_p) ;
+		cy_as_power_management_interrupt_handler(dev_p);
 
 	if (v & CY_AS_MEM_P0_INTR_REG_PLLLOCKINT)
-		cy_as_pll_lock_loss_interrupt_handler(dev_p) ;
+		cy_as_pll_lock_loss_interrupt_handler(dev_p);
 
 	/* If the interrupt module is not running, no mailbox
 	 * interrupts are expected from the west bridge. */
 	if (cy_as_device_is_intr_running(dev_p) == 0)
-		return ;
+		return;
 
 	if (v & CY_AS_MEM_P0_INTR_REG_MBINT)
-		cy_as_mail_box_interrupt_handler(dev_p) ;
+		cy_as_mail_box_interrupt_handler(dev_p);
 }

drivers/staging/westbridge/astoria/api/src/cyaslep2pep.c

@@ -40,7 +40,7 @@ typedef enum cy_as_physical_endpoint_state {
 * LEP register indexes into actual EP numbers.
 */
 static cy_as_end_point_number_t end_point_map[] = {
-	3, 5, 7, 9, 10, 11, 12, 13, 14, 15 } ;
+	3, 5, 7, 9, 10, 11, 12, 13, 14, 15 };
 
 #define CY_AS_EPCFG_1024			(1 << 3)
 #define CY_AS_EPCFG_DBL			 (0x02)
@@ -116,23 +116,23 @@ static uint8_t pep_register_values[12][4] = {
 		CY_AS_EPCFG_DBL,
 	},/* Config 12 - PEP1 (4 * 1024), PEP2 (N/A),
 	   * PEP3 (N/A), PEP4 (N/A) */
-} ;
+};
 
 static cy_as_return_status_t
 find_endpoint_directions(cy_as_device *dev_p,
 	cy_as_physical_endpoint_state epstate[4])
 {
-	int i ;
-	cy_as_physical_endpoint_state desired ;
+	int i;
+	cy_as_physical_endpoint_state desired;
 
 	/*
 	 * note, there is no error checking here becuase
 	 * ISO error checking happens when the API is called.
 	 */
-	for (i = 0 ; i < 10 ; i++) {
-		int epno = end_point_map[i] ;
+	for (i = 0; i < 10; i++) {
+		int epno = end_point_map[i];
 		if (dev_p->usb_config[epno].enabled) {
-			int pep = dev_p->usb_config[epno].physical ;
+			int pep = dev_p->usb_config[epno].physical;
 			if (dev_p->usb_config[epno].type == cy_as_usb_iso) {
 				/*
 				 * marking this as an ISO endpoint, removes the
@@ -140,14 +140,14 @@ find_endpoint_directions(cy_as_device *dev_p,
 				 * mapping the remaining E_ps.
 				 */
 				if (dev_p->usb_config[epno].dir == cy_as_usb_in)
-					desired = cy_as_e_p_iso_in ;
+					desired = cy_as_e_p_iso_in;
 				else
-					desired = cy_as_e_p_iso_out ;
+					desired = cy_as_e_p_iso_out;
 			} else {
 				if (dev_p->usb_config[epno].dir == cy_as_usb_in)
-					desired = cy_as_e_p_in ;
+					desired = cy_as_e_p_in;
 				else
-					desired = cy_as_e_p_out ;
+					desired = cy_as_e_p_out;
 			}
 
 			/*
@@ -157,9 +157,9 @@ find_endpoint_directions(cy_as_device *dev_p,
 			 */
 			if (epstate[pep - 1] !=
 				cy_as_e_p_free && epstate[pep - 1] != desired)
-				return CY_AS_ERROR_INVALID_CONFIGURATION ;
+				return CY_AS_ERROR_INVALID_CONFIGURATION;
 
-			epstate[pep - 1] = desired ;
+			epstate[pep - 1] = desired;
 		}
 	}
 
@@ -167,91 +167,91 @@ find_endpoint_directions(cy_as_device *dev_p,
 	 * create the EP1 config values directly.
 	 * both EP1OUT and EP1IN are invalid by default.
 	 */
-	dev_p->usb_ep1cfg[0] = 0 ;
-	dev_p->usb_ep1cfg[1] = 0 ;
+	dev_p->usb_ep1cfg[0] = 0;
+	dev_p->usb_ep1cfg[1] = 0;
 	if (dev_p->usb_config[1].enabled) {
 		if ((dev_p->usb_config[1].dir == cy_as_usb_out) ||
 			(dev_p->usb_config[1].dir == cy_as_usb_in_out)) {
 			/* Set the valid bit and type field. */
-			dev_p->usb_ep1cfg[0] = (1 << 7) ;
+			dev_p->usb_ep1cfg[0] = (1 << 7);
 			if (dev_p->usb_config[1].type == cy_as_usb_bulk)
-				dev_p->usb_ep1cfg[0] |= (2 << 4) ;
+				dev_p->usb_ep1cfg[0] |= (2 << 4);
 			else
-				dev_p->usb_ep1cfg[0] |= (3 << 4) ;
+				dev_p->usb_ep1cfg[0] |= (3 << 4);
 		}
 
 		if ((dev_p->usb_config[1].dir == cy_as_usb_in) ||
 		(dev_p->usb_config[1].dir == cy_as_usb_in_out)) {
 			/* Set the valid bit and type field. */
-			dev_p->usb_ep1cfg[1] = (1 << 7) ;
+			dev_p->usb_ep1cfg[1] = (1 << 7);
 			if (dev_p->usb_config[1].type == cy_as_usb_bulk)
-				dev_p->usb_ep1cfg[1] |= (2 << 4) ;
+				dev_p->usb_ep1cfg[1] |= (2 << 4);
 			else
-				dev_p->usb_ep1cfg[1] |= (3 << 4) ;
+				dev_p->usb_ep1cfg[1] |= (3 << 4);
 		}
 	}
 
-	return CY_AS_ERROR_SUCCESS ;
+	return CY_AS_ERROR_SUCCESS;
 }
 
 static void
 create_register_settings(cy_as_device *dev_p,
 	cy_as_physical_endpoint_state epstate[4])
 {
-	int i ;
-	uint8_t v ;
+	int i;
+	uint8_t v;
 
-	for (i = 0 ; i < 4 ; i++) {
+	for (i = 0; i < 4; i++) {
 		if (i == 0) {
 			/* Start with the values that specify size */
 			dev_p->usb_pepcfg[i] =
 				pep_register_values
-					[dev_p->usb_phy_config - 1][0] ;
+					[dev_p->usb_phy_config - 1][0];
 		} else if (i == 2) {
 			/* Start with the values that specify size */
 			dev_p->usb_pepcfg[i] =
 				pep_register_values
-					[dev_p->usb_phy_config - 1][1] ;
+					[dev_p->usb_phy_config - 1][1];
 		} else
-			dev_p->usb_pepcfg[i] = 0 ;
+			dev_p->usb_pepcfg[i] = 0;
 
 		/* Adjust direction if it is in */
 		if (epstate[i] == cy_as_e_p_iso_in ||
 			epstate[i] == cy_as_e_p_in)
-			dev_p->usb_pepcfg[i] |= (1 << 6) ;
+			dev_p->usb_pepcfg[i] |= (1 << 6);
 	}
 
 	/* Configure the logical EP registers */
-	for (i = 0 ; i < 10 ; i++) {
-		int val ;
-		int epnum = end_point_map[i] ;
+	for (i = 0; i < 10; i++) {
+		int val;
+		int epnum = end_point_map[i];
 
-		v = 0x10 ;	  /* PEP 1, Bulk Endpoint, EP not valid */
+		v = 0x10;	  /* PEP 1, Bulk Endpoint, EP not valid */
 		if (dev_p->usb_config[epnum].enabled) {
-			v |= (1 << 7) ;	 /* Enabled */
+			v |= (1 << 7);	 /* Enabled */
 
-			val = dev_p->usb_config[epnum].physical - 1 ;
-			cy_as_hal_assert(val >= 0 && val <= 3) ;
-			v |= (val << 5) ;
+			val = dev_p->usb_config[epnum].physical - 1;
+			cy_as_hal_assert(val >= 0 && val <= 3);
+			v |= (val << 5);
 
 			switch (dev_p->usb_config[epnum].type) {
 			case cy_as_usb_bulk:
-				val = 2 ;
-				break ;
+				val = 2;
+				break;
 			case cy_as_usb_int:
-				val = 3 ;
-				break ;
+				val = 3;
+				break;
 			case cy_as_usb_iso:
-				val = 1 ;
-				break ;
+				val = 1;
+				break;
 			default:
-				cy_as_hal_assert(cy_false) ;
-				break ;
+				cy_as_hal_assert(cy_false);
+				break;
 			}
-			v |= (val << 3) ;
+			v |= (val << 3);
 		}
 
-		dev_p->usb_lepcfg[i] = v ;
+		dev_p->usb_lepcfg[i] = v;
 	}
 }
 
@@ -259,100 +259,100 @@ create_register_settings(cy_as_device *dev_p,
 cy_as_return_status_t
 cy_as_usb_map_logical2_physical(cy_as_device *dev_p)
 {
-	cy_as_return_status_t ret ;
+	cy_as_return_status_t ret;
 
 	/* Physical EPs 3 5 7 9 respectively in the array */
 	cy_as_physical_endpoint_state epstate[4] = {
 		cy_as_e_p_free, cy_as_e_p_free,
-			cy_as_e_p_free, cy_as_e_p_free } ;
+			cy_as_e_p_free, cy_as_e_p_free };
 
 	/* Find the direction for the endpoints */
-	ret = find_endpoint_directions(dev_p, epstate) ;
+	ret = find_endpoint_directions(dev_p, epstate);
 	if (ret != CY_AS_ERROR_SUCCESS)
-		return ret ;
+		return ret;
 
 	/*
 	 * now create the register settings based on the given
 	 * assigned of logical E_ps to physical endpoints.
 	 */
-	create_register_settings(dev_p, epstate) ;
+	create_register_settings(dev_p, epstate);
 
-	return ret ;
+	return ret;
 }
 
 static uint16_t
 get_max_dma_size(cy_as_device *dev_p, cy_as_end_point_number_t ep)
 {
-	uint16_t size = dev_p->usb_config[ep].size ;
+	uint16_t size = dev_p->usb_config[ep].size;
 
 	if (size == 0) {
 		switch (dev_p->usb_config[ep].type) {
 		case cy_as_usb_control:
-			size = 64 ;
-			break ;
+			size = 64;
+			break;
 
 		case cy_as_usb_bulk:
 			size = cy_as_device_is_usb_high_speed(dev_p) ?
-				512 : 64 ;
-			break ;
+				512 : 64;
+			break;
 
 		case cy_as_usb_int:
 			size = cy_as_device_is_usb_high_speed(dev_p) ?
-				1024 : 64 ;
-			break ;
+				1024 : 64;
+			break;
 
 		case cy_as_usb_iso:
 			size = cy_as_device_is_usb_high_speed(dev_p) ?
-				1024 : 1023 ;
-			break ;
+				1024 : 1023;
+			break;
 		}
 	}
 
-	return size ;
+	return size;
 }
 
 cy_as_return_status_t
 cy_as_usb_set_dma_sizes(cy_as_device *dev_p)
 {
-	cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ;
-	uint32_t i ;
+	cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+	uint32_t i;
 
-	for (i = 0 ; i < 10 ; i++) {
+	for (i = 0; i < 10; i++) {
 		cy_as_usb_end_point_config *config_p =
-			&dev_p->usb_config[end_point_map[i]] ;
+			&dev_p->usb_config[end_point_map[i]];
 		if (config_p->enabled) {
 			ret = cy_as_dma_set_max_dma_size(dev_p,
 				end_point_map[i],
-				get_max_dma_size(dev_p, end_point_map[i])) ;
+				get_max_dma_size(dev_p, end_point_map[i]));
 			if (ret != CY_AS_ERROR_SUCCESS)
-				break ;
+				break;
 		}
 	}
 
-	return ret ;
+	return ret;
 }
 
 cy_as_return_status_t
 cy_as_usb_setup_dma(cy_as_device *dev_p)
 {
-	cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS ;
-	uint32_t i ;
+	cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+	uint32_t i;
 
-	for (i = 0 ; i < 10 ; i++) {
+	for (i = 0; i < 10; i++) {
 		cy_as_usb_end_point_config *config_p =
-			&dev_p->usb_config[end_point_map[i]] ;
+			&dev_p->usb_config[end_point_map[i]];
 		if (config_p->enabled) {
 			/* Map the endpoint direction to the DMA direction */
-			cy_as_dma_direction dir = cy_as_direction_out ;
+			cy_as_dma_direction dir = cy_as_direction_out;
 			if (config_p->dir == cy_as_usb_in)
-				dir = cy_as_direction_in ;
+				dir = cy_as_direction_in;
 
 			ret = cy_as_dma_enable_end_point(dev_p,
-				end_point_map[i], cy_true, dir) ;
+				end_point_map[i], cy_true, dir);
 			if (ret != CY_AS_ERROR_SUCCESS)
-				break ;
+				break;
 		}
 	}
 
-	return ret ;
+	return ret;
 }

drivers/staging/westbridge/astoria/arch/arm/plat-omap/include/mach/westbridge/cyashaldef.h

@@ -47,7 +47,7 @@
 
 
 #if !defined(__doxygen__)
-typedef int cy_bool ;
+typedef int cy_bool;
 #define cy_true				(1)
 #define cy_false				(0)
 #endif

drivers/staging/westbridge/astoria/arch/arm/plat-omap/include/mach/westbridge/westbridge-omap3-pnand-hal/cyashalomap_kernel.h

@@ -38,8 +38,8 @@
 */
 #include <linux/../../arch/arm/plat-omap/include/plat/gpmc.h>
 typedef struct cy_as_hal_sleep_channel_t {
-	wait_queue_head_t wq ;
-} cy_as_hal_sleep_channel ;
+	wait_queue_head_t wq;
+} cy_as_hal_sleep_channel;
 
 /* moved to staging location, eventual location
  * considered is here
@@ -61,7 +61,7 @@ typedef struct cy_as_hal_sleep_channel_t {
  * device in the system. In this case the tag is a void * which is
  * really an OMAP device pointer
  */
-typedef void *cy_as_hal_device_tag ;
+typedef void *cy_as_hal_device_tag;
 
 
 /* This must be included after the CyAsHalDeviceTag type is defined */
@@ -84,7 +84,7 @@ typedef void *cy_as_hal_device_tag ;
  */
 void
 cy_as_hal_write_register(cy_as_hal_device_tag tag,
-	uint16_t addr, uint16_t data) ;
+	uint16_t addr, uint16_t data);
 
 /*
  * This function must be defined to read a register from
@@ -93,7 +93,7 @@ cy_as_hal_write_register(cy_as_hal_device_tag tag,
  * of the west bridge device.
  */
 uint16_t
-cy_as_hal_read_register(cy_as_hal_device_tag tag, uint16_t addr) ;
+cy_as_hal_read_register(cy_as_hal_device_tag tag, uint16_t addr);
 
 /*
  * This function must be defined to transfer a block of data
@@ -103,7 +103,7 @@ cy_as_hal_read_register(cy_as_hal_device_tag tag, uint16_t addr) ;
  */
 void
 cy_as_hal_dma_setup_write(cy_as_hal_device_tag tag,
-	uint8_t ep, void *buf, uint32_t size, uint16_t maxsize) ;
+	uint8_t ep, void *buf, uint32_t size, uint16_t maxsize);
 
 /*
  * This function must be defined to transfer a block of data
@@ -113,13 +113,13 @@ cy_as_hal_dma_setup_write(cy_as_hal_device_tag tag,
  */
 void
 cy_as_hal_dma_setup_read(cy_as_hal_device_tag tag, uint8_t ep,
-	void *buf, uint32_t size, uint16_t maxsize) ;
+	void *buf, uint32_t size, uint16_t maxsize);
 
 /*
  * This function must be defined to cancel any pending DMA request.
  */
 void
-cy_as_hal_dma_cancel_request(cy_as_hal_device_tag tag, uint8_t ep) ;
+cy_as_hal_dma_cancel_request(cy_as_hal_device_tag tag, uint8_t ep);
 
 /*
  * This function must be defined to allow the Antioch API to
@@ -128,7 +128,7 @@ cy_as_hal_dma_cancel_request(cy_as_hal_device_tag tag, uint8_t ep) ;
  */
 void
 cy_as_hal_dma_register_callback(cy_as_hal_device_tag tag,
-	cy_as_hal_dma_complete_callback cb) ;
+	cy_as_hal_dma_complete_callback cb);
 
 /*
  * This function must be defined to return the maximum size of DMA
@@ -138,7 +138,7 @@ cy_as_hal_dma_register_callback(cy_as_hal_device_tag tag,
  */
 uint32_t
 cy_as_hal_dma_max_request_size(cy_as_hal_device_tag tag,
-	cy_as_end_point_number_t ep) ;
+	cy_as_end_point_number_t ep);
 
 /*
  * This function must be defined to set the state of the WAKEUP pin
@@ -146,14 +146,14 @@ cy_as_hal_dma_max_request_size(cy_as_hal_device_tag tag,
  * type.
  */
 cy_bool
-cy_as_hal_set_wakeup_pin(cy_as_hal_device_tag tag, cy_bool state) ;
+cy_as_hal_set_wakeup_pin(cy_as_hal_device_tag tag, cy_bool state);
 
 /*
  * This function is called when the Antioch PLL loses lock, because
  * of a problem in the supply voltage or the input clock.
  */
 void
-cy_as_hal_pll_lock_loss_handler(cy_as_hal_device_tag tag) ;
+cy_as_hal_pll_lock_loss_handler(cy_as_hal_device_tag tag);
 
 
 /**********************************************************************
@@ -168,14 +168,14 @@ cy_as_hal_pll_lock_loss_handler(cy_as_hal_device_tag tag) ;
  * is expected to work exactly like malloc().
  */
 void *
-cy_as_hal_alloc(uint32_t cnt) ;
+cy_as_hal_alloc(uint32_t cnt);
 
 /*
  * This function is required by the API to free memory allocated with
  * CyAsHalAlloc().  This function is expected to work exacly like free().
  */
 void
-cy_as_hal_free(void *mem_p) ;
+cy_as_hal_free(void *mem_p);
 
 /*
  * This function is required by the API to allocate memory during a
@@ -183,21 +183,21 @@ cy_as_hal_free(void *mem_p) ;
  * time.
  */
 void *
-cy_as_hal_c_b_alloc(uint32_t cnt) ;
+cy_as_hal_c_b_alloc(uint32_t cnt);
 
 /*
  * This function is required by the API to free memory allocated with
  * CyAsCBHalAlloc().
  */
 void
-cy_as_hal_c_b_free(void *ptr) ;
+cy_as_hal_c_b_free(void *ptr);
 
 /*
  * This function is required to set a block of memory to a specific
  * value.  This function is expected to work exactly like memset()
  */
 void
-cy_as_hal_mem_set(void *ptr, uint8_t value, uint32_t cnt) ;
+cy_as_hal_mem_set(void *ptr, uint8_t value, uint32_t cnt);
 
 /*
  * This function is expected to create a sleep channel.  The data
@@ -205,7 +205,7 @@ cy_as_hal_mem_set(void *ptr, uint8_t value, uint32_t cnt) ;
  * pointer in the argument.
  */
 cy_bool
-cy_as_hal_create_sleep_channel(cy_as_hal_sleep_channel *channel) ;
+cy_as_hal_create_sleep_channel(cy_as_hal_sleep_channel *channel);
 
 /*
  * This function is expected to destroy a sleep channel.  The data
@@ -215,16 +215,16 @@ cy_as_hal_create_sleep_channel(cy_as_hal_sleep_channel *channel) ;
 
 
 cy_bool
-cy_as_hal_destroy_sleep_channel(cy_as_hal_sleep_channel *channel) ;
+cy_as_hal_destroy_sleep_channel(cy_as_hal_sleep_channel *channel);
 
 cy_bool
-cy_as_hal_sleep_on(cy_as_hal_sleep_channel *channel, uint32_t ms) ;
+cy_as_hal_sleep_on(cy_as_hal_sleep_channel *channel, uint32_t ms);
 
 cy_bool
-cy_as_hal_wake(cy_as_hal_sleep_channel *channel) ;
+cy_as_hal_wake(cy_as_hal_sleep_channel *channel);
 
 uint32_t
-cy_as_hal_disable_interrupts(void) ;
+cy_as_hal_disable_interrupts(void);
 
 void
 cy_as_hal_enable_interrupts(uint32_t);
@@ -283,7 +283,7 @@ void cy_as_hal_read_regs_before_standby(cy_as_hal_device_tag tag);
 /*
 CyAsMiscSetLogLevel(uint8_t level)
 {
-	debug_level = level ;
+	debug_level = level;
 }
 
 #ifdef CY_AS_LOG_SUPPORT
@@ -292,7 +292,7 @@ void
 cy_as_log_debug_message(int level, const char *str)
 {
 	if (level <= debug_level)
-		cy_as_hal_print_message("log %d: %s\n", level, str) ;
+		cy_as_hal_print_message("log %d: %s\n", level, str);
 }
 */
 
@@ -307,9 +307,9 @@ void cyashal_prn_buf(void  *buf, uint16_t offset, int len);
  * but are required to be called for this HAL.
  */
 int start_o_m_a_p_kernel(const char *pgm,
-	cy_as_hal_device_tag *tag, cy_bool debug) ;
-int stop_o_m_a_p_kernel(const char *pgm, cy_as_hal_device_tag tag) ;
-int omap_start_intr(cy_as_hal_device_tag tag) ;
+	cy_as_hal_device_tag *tag, cy_bool debug);
+int stop_o_m_a_p_kernel(const char *pgm, cy_as_hal_device_tag tag);
+int omap_start_intr(cy_as_hal_device_tag tag);
 void cy_as_hal_set_ep_dma_mode(uint8_t ep, bool sg_xfer_enabled);
 
 /* moved to staging location

drivers/staging/westbridge/astoria/arch/arm/plat-omap/include/mach/westbridge/westbridge-omap3-pnand-hal/cyasomapdev_kernel.h

@@ -44,7 +44,7 @@
  */
 typedef struct cy_as_omap_dev_kernel {
 	/* This is the signature for this data structure */
-	unsigned int m_sig ;
+	unsigned int m_sig;
 
 	/* Address base of Antioch Device */
 	void *m_addr_base;

drivers/staging/westbridge/astoria/block/cyasblkdev_queue.c

@@ -98,7 +98,7 @@ static int cyasblkdev_prep_request(
 	if (req->cmd_type != REQ_TYPE_FS && !(req->cmd_flags & REQ_DISCARD)) {
 		#ifndef WESTBRIDGE_NDEBUG
 		cy_as_hal_print_message("%s:%x bad request received\n",
-			__func__, current->pid) ;
+			__func__, current->pid);
 		#endif
 
 		blk_dump_rq_flags(req, "cyasblkdev bad request");
@@ -136,7 +136,7 @@ static int cyasblkdev_queue_thread(void *d)
 
 	#ifndef WESTBRIDGE_NDEBUG
 	cy_as_hal_print_message(
-		"%s:%x started, bq:%p, q:%p\n", __func__, qth_pid, bq, q) ;
+		"%s:%x started, bq:%p, q:%p\n", __func__, qth_pid, bq, q);
 	#endif
 
 	do {
@@ -249,7 +249,7 @@ static int cyasblkdev_queue_thread(void *d)
 	complete_and_exit(&bq->thread_complete, 0);
 
 	#ifndef WESTBRIDGE_NDEBUG
-	cy_as_hal_print_message("%s: is finished\n", __func__) ;
+	cy_as_hal_print_message("%s: is finished\n", __func__);
 	#endif
 
 	return 0;

drivers/staging/westbridge/astoria/block/cyasblkdev_queue.h

@@ -55,7 +55,7 @@ extern void cyasblkdev_cleanup_queue(struct cyasblkdev_queue *);
 extern void cyasblkdev_queue_suspend(struct cyasblkdev_queue *);
 extern void cyasblkdev_queue_resume(struct cyasblkdev_queue *);
 
-extern cy_as_device_handle cyasdevice_getdevhandle(void) ;
+extern cy_as_device_handle cyasdevice_getdevhandle(void);
 #define MOD_LOGS 1
 void verbose_rq_flags(int flags);
 

drivers/staging/westbridge/astoria/device/cyandevice_export.h

@@ -26,77 +26,77 @@
  * The APIs to create a device handle and download firmware are not exported
  * because they are expected to be used only by this kernel module.
  */
-EXPORT_SYMBOL(cy_as_misc_get_firmware_version) ;
-EXPORT_SYMBOL(cy_as_misc_read_m_c_u_register) ;
-EXPORT_SYMBOL(cy_as_misc_reset) ;
-EXPORT_SYMBOL(cy_as_misc_acquire_resource) ;
-EXPORT_SYMBOL(cy_as_misc_release_resource) ;
-EXPORT_SYMBOL(cy_as_misc_enter_standby) ;
-EXPORT_SYMBOL(cy_as_misc_leave_standby) ;
-EXPORT_SYMBOL(cy_as_misc_enter_suspend) ;
-EXPORT_SYMBOL(cy_as_misc_leave_suspend) ;
-EXPORT_SYMBOL(cy_as_misc_storage_changed) ;
-EXPORT_SYMBOL(cy_as_misc_heart_beat_control) ;
-EXPORT_SYMBOL(cy_as_misc_get_gpio_value) ;
-EXPORT_SYMBOL(cy_as_misc_set_gpio_value) ;
-EXPORT_SYMBOL(cy_as_misc_set_low_speed_sd_freq) ;
-EXPORT_SYMBOL(cy_as_misc_set_high_speed_sd_freq) ;
+EXPORT_SYMBOL(cy_as_misc_get_firmware_version);
+EXPORT_SYMBOL(cy_as_misc_read_m_c_u_register);
+EXPORT_SYMBOL(cy_as_misc_reset);
+EXPORT_SYMBOL(cy_as_misc_acquire_resource);
+EXPORT_SYMBOL(cy_as_misc_release_resource);
+EXPORT_SYMBOL(cy_as_misc_enter_standby);
+EXPORT_SYMBOL(cy_as_misc_leave_standby);
+EXPORT_SYMBOL(cy_as_misc_enter_suspend);
+EXPORT_SYMBOL(cy_as_misc_leave_suspend);
+EXPORT_SYMBOL(cy_as_misc_storage_changed);
+EXPORT_SYMBOL(cy_as_misc_heart_beat_control);
+EXPORT_SYMBOL(cy_as_misc_get_gpio_value);
+EXPORT_SYMBOL(cy_as_misc_set_gpio_value);
+EXPORT_SYMBOL(cy_as_misc_set_low_speed_sd_freq);
+EXPORT_SYMBOL(cy_as_misc_set_high_speed_sd_freq);
 
 /*
  * Export the USB APIs that can be used by the dependent kernel modules.
  */
-EXPORT_SYMBOL(cy_as_usb_set_end_point_config) ;
-EXPORT_SYMBOL(cy_as_usb_read_data_async) ;
-EXPORT_SYMBOL(cy_as_usb_write_data_async) ;
-EXPORT_SYMBOL(cy_as_usb_cancel_async) ;
-EXPORT_SYMBOL(cy_as_usb_set_stall) ;
-EXPORT_SYMBOL(cy_as_usb_clear_stall) ;
-EXPORT_SYMBOL(cy_as_usb_connect) ;
-EXPORT_SYMBOL(cy_as_usb_disconnect) ;
-EXPORT_SYMBOL(cy_as_usb_start) ;
-EXPORT_SYMBOL(cy_as_usb_stop) ;
-EXPORT_SYMBOL(cy_as_usb_set_enum_config) ;
-EXPORT_SYMBOL(cy_as_usb_get_enum_config) ;
-EXPORT_SYMBOL(cy_as_usb_set_physical_configuration) ;
-EXPORT_SYMBOL(cy_as_usb_register_callback) ;
-EXPORT_SYMBOL(cy_as_usb_commit_config) ;
-EXPORT_SYMBOL(cy_as_usb_set_descriptor) ;
-EXPORT_SYMBOL(cy_as_usb_clear_descriptors) ;
-EXPORT_SYMBOL(cy_as_usb_get_descriptor) ;
-EXPORT_SYMBOL(cy_as_usb_get_end_point_config) ;
-EXPORT_SYMBOL(cy_as_usb_read_data) ;
-EXPORT_SYMBOL(cy_as_usb_write_data) ;
-EXPORT_SYMBOL(cy_as_usb_get_stall) ;
-EXPORT_SYMBOL(cy_as_usb_set_nak) ;
-EXPORT_SYMBOL(cy_as_usb_clear_nak) ;
-EXPORT_SYMBOL(cy_as_usb_get_nak) ;
-EXPORT_SYMBOL(cy_as_usb_signal_remote_wakeup) ;
-EXPORT_SYMBOL(cy_as_usb_set_m_s_report_threshold) ;
-EXPORT_SYMBOL(cy_as_usb_select_m_s_partitions) ;
+EXPORT_SYMBOL(cy_as_usb_set_end_point_config);
+EXPORT_SYMBOL(cy_as_usb_read_data_async);
+EXPORT_SYMBOL(cy_as_usb_write_data_async);
+EXPORT_SYMBOL(cy_as_usb_cancel_async);
+EXPORT_SYMBOL(cy_as_usb_set_stall);
+EXPORT_SYMBOL(cy_as_usb_clear_stall);
+EXPORT_SYMBOL(cy_as_usb_connect);
+EXPORT_SYMBOL(cy_as_usb_disconnect);
+EXPORT_SYMBOL(cy_as_usb_start);
+EXPORT_SYMBOL(cy_as_usb_stop);
+EXPORT_SYMBOL(cy_as_usb_set_enum_config);
+EXPORT_SYMBOL(cy_as_usb_get_enum_config);
+EXPORT_SYMBOL(cy_as_usb_set_physical_configuration);
+EXPORT_SYMBOL(cy_as_usb_register_callback);
+EXPORT_SYMBOL(cy_as_usb_commit_config);
+EXPORT_SYMBOL(cy_as_usb_set_descriptor);
+EXPORT_SYMBOL(cy_as_usb_clear_descriptors);
+EXPORT_SYMBOL(cy_as_usb_get_descriptor);
+EXPORT_SYMBOL(cy_as_usb_get_end_point_config);
+EXPORT_SYMBOL(cy_as_usb_read_data);
+EXPORT_SYMBOL(cy_as_usb_write_data);
+EXPORT_SYMBOL(cy_as_usb_get_stall);
+EXPORT_SYMBOL(cy_as_usb_set_nak);
+EXPORT_SYMBOL(cy_as_usb_clear_nak);
+EXPORT_SYMBOL(cy_as_usb_get_nak);
+EXPORT_SYMBOL(cy_as_usb_signal_remote_wakeup);
+EXPORT_SYMBOL(cy_as_usb_set_m_s_report_threshold);
+EXPORT_SYMBOL(cy_as_usb_select_m_s_partitions);
 
 /*
  * Export all Storage APIs that can be used by dependent kernel modules.
  */
-EXPORT_SYMBOL(cy_as_storage_start) ;
-EXPORT_SYMBOL(cy_as_storage_stop) ;
-EXPORT_SYMBOL(cy_as_storage_register_callback) ;
-EXPORT_SYMBOL(cy_as_storage_query_bus) ;
-EXPORT_SYMBOL(cy_as_storage_query_media) ;
-EXPORT_SYMBOL(cy_as_storage_query_device) ;
-EXPORT_SYMBOL(cy_as_storage_query_unit) ;
-EXPORT_SYMBOL(cy_as_storage_device_control) ;
-EXPORT_SYMBOL(cy_as_storage_claim) ;
-EXPORT_SYMBOL(cy_as_storage_release) ;
-EXPORT_SYMBOL(cy_as_storage_read) ;
-EXPORT_SYMBOL(cy_as_storage_write) ;
-EXPORT_SYMBOL(cy_as_storage_read_async) ;
-EXPORT_SYMBOL(cy_as_storage_write_async) ;
-EXPORT_SYMBOL(cy_as_storage_cancel_async) ;
-EXPORT_SYMBOL(cy_as_storage_sd_register_read) ;
-EXPORT_SYMBOL(cy_as_storage_create_p_partition) ;
-EXPORT_SYMBOL(cy_as_storage_remove_p_partition) ;
-EXPORT_SYMBOL(cy_as_storage_get_transfer_amount) ;
-EXPORT_SYMBOL(cy_as_storage_erase) ;
+EXPORT_SYMBOL(cy_as_storage_start);
+EXPORT_SYMBOL(cy_as_storage_stop);
+EXPORT_SYMBOL(cy_as_storage_register_callback);
+EXPORT_SYMBOL(cy_as_storage_query_bus);
+EXPORT_SYMBOL(cy_as_storage_query_media);
+EXPORT_SYMBOL(cy_as_storage_query_device);
+EXPORT_SYMBOL(cy_as_storage_query_unit);
+EXPORT_SYMBOL(cy_as_storage_device_control);
+EXPORT_SYMBOL(cy_as_storage_claim);
+EXPORT_SYMBOL(cy_as_storage_release);
+EXPORT_SYMBOL(cy_as_storage_read);
+EXPORT_SYMBOL(cy_as_storage_write);
+EXPORT_SYMBOL(cy_as_storage_read_async);
+EXPORT_SYMBOL(cy_as_storage_write_async);
+EXPORT_SYMBOL(cy_as_storage_cancel_async);
+EXPORT_SYMBOL(cy_as_storage_sd_register_read);
+EXPORT_SYMBOL(cy_as_storage_create_p_partition);
+EXPORT_SYMBOL(cy_as_storage_remove_p_partition);
+EXPORT_SYMBOL(cy_as_storage_get_transfer_amount);
+EXPORT_SYMBOL(cy_as_storage_erase);
 
 EXPORT_SYMBOL(cy_as_sdio_query_card);
 EXPORT_SYMBOL(cy_as_sdio_init_function);
@@ -106,13 +106,13 @@ EXPORT_SYMBOL(cy_as_sdio_direct_write);
 EXPORT_SYMBOL(cy_as_sdio_extended_read);
 EXPORT_SYMBOL(cy_as_sdio_extended_write);
 
-EXPORT_SYMBOL(cy_as_hal_alloc) ;
-EXPORT_SYMBOL(cy_as_hal_free) ;
-EXPORT_SYMBOL(cy_as_hal_sleep) ;
-EXPORT_SYMBOL(cy_as_hal_create_sleep_channel) ;
-EXPORT_SYMBOL(cy_as_hal_destroy_sleep_channel) ;
-EXPORT_SYMBOL(cy_as_hal_sleep_on) ;
-EXPORT_SYMBOL(cy_as_hal_wake) ;
+EXPORT_SYMBOL(cy_as_hal_alloc);
+EXPORT_SYMBOL(cy_as_hal_free);
+EXPORT_SYMBOL(cy_as_hal_sleep);
+EXPORT_SYMBOL(cy_as_hal_create_sleep_channel);
+EXPORT_SYMBOL(cy_as_hal_destroy_sleep_channel);
+EXPORT_SYMBOL(cy_as_hal_sleep_on);
+EXPORT_SYMBOL(cy_as_hal_wake);
 EXPORT_SYMBOL(cy_as_hal_mem_set);
 
 EXPORT_SYMBOL(cy_as_mtp_storage_only_start);
@@ -125,8 +125,8 @@ EXPORT_SYMBOL(cy_as_mtp_cancel_get_object);
 
 #ifdef __CY_ASTORIA_SCM_KERNEL_HAL__
 /* Functions in the SCM kernel HAL implementation only. */
-EXPORT_SYMBOL(cy_as_hal_enable_scatter_list) ;
-EXPORT_SYMBOL(cy_as_hal_disable_scatter_list) ;
+EXPORT_SYMBOL(cy_as_hal_enable_scatter_list);
+EXPORT_SYMBOL(cy_as_hal_disable_scatter_list);
 #endif
 
 /*[]*/

drivers/staging/westbridge/astoria/gadget/cyasgadget.h

@@ -84,7 +84,7 @@
 
 extern int mpage_cleardirty(struct address_space *mapping, int num_pages);
 extern int fat_get_block(struct inode *, sector_t , struct buffer_head *, int);
-extern cy_as_device_handle *cyasdevice_getdevhandle(void) ;
+extern cy_as_device_handle *cyasdevice_getdevhandle(void);
 
 /* Driver data structures and utilities */
 typedef struct cyasgadget_ep {
@@ -102,7 +102,7 @@ typedef struct cyasgadget_ep {
 						is_in:1,
 						is_iso:1;
 	cy_as_usb_end_point_config cyepconfig;
-} cyasgadget_ep ;
+} cyasgadget_ep;
 
 typedef struct cyasgadget_req {
 	struct usb_request		req;
@@ -112,7 +112,7 @@ typedef struct cyasgadget_req {
 						valid:1,
 						complete:1,
 						ep_stopped:1;
-} cyasgadget_req ;
+} cyasgadget_req;
 
 typedef struct cyasgadget {
 	/* each device provides one gadget, several endpoints */
@@ -139,16 +139,16 @@ typedef struct cyasgadget {
 	/* Data member used to store the GetObjectComplete event data */
 	cy_as_mtp_get_object_complete_data tmtp_get_complete_data;
 
-} cyasgadget ;
+} cyasgadget;
 
 static inline void set_halt(cyasgadget_ep *ep)
 {
-	return ;
+	return;
 }
 
 static inline void clear_halt(cyasgadget_ep *ep)
 {
-	return ;
+	return;
 }
 
 #define xprintk(dev, level, fmt, args...) \
@@ -182,12 +182,12 @@ static inline void clear_halt(cyasgadget_ep *ep)
 
 static inline void start_out_naking(struct cyasgadget_ep *ep)
 {
-	return ;
+	return;
 }
 
 static inline void stop_out_naking(struct cyasgadget_ep *ep)
 {
-	return ;
+	return;
 }
 
 #endif	/* _INCLUDED_CYANGADGET_H_ */

drivers/staging/westbridge/astoria/include/linux/westbridge/cyantypes.h

@@ -25,7 +25,7 @@
 #define _INCLUDED_CYANTYPES_H_
 
 #include "cyastypes.h"
-typedef cy_as_end_point_number_t cy_an_end_point_number_t ;
-typedef cy_as_return_status_t cy_an_return_status_t ;
-typedef cy_as_bus_number_t cy_an_bus_number_t ;
+typedef cy_as_end_point_number_t cy_an_end_point_number_t;
+typedef cy_as_return_status_t cy_an_return_status_t;
+typedef cy_as_bus_number_t cy_an_bus_number_t;
 #endif