[3/5] staging: vchiq_core: Reflow long lines to 80 columns

Commit Message

Umang Jain Oct. 10, 2024, 10:22 a.m. UTC

In order to respect the coding style, wrap long lines in vchiq_core.c
to fit in 80 columns.

No functional changes intended in this patch.

Signed-off-by: Umang Jain <[e-mail]>
---
 .../interface/vchiq_arm/vchiq_core.c          | 267 +++++++++++-------
 1 file changed, 168 insertions(+), 99 deletions(-)

Comments

Greg KH Oct. 11, 2024, 4:36 a.m. UTC | #1

On Thu, Oct 10, 2024 at 03:52:47PM +0530, Umang Jain wrote:
> In order to respect the coding style, wrap long lines in vchiq_core.c
> to fit in 80 columns.

We can go longer than 80 if you want.

Patch

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
index 1e4b2978c186..8be2dcf3658c 100644
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -227,7 +227,8 @@  set_service_state(struct vchiq_service *service, int newstate)
 	service->srvstate = newstate;
 }
 
-struct vchiq_service *handle_to_service(struct vchiq_instance *instance, unsigned int handle)
+struct vchiq_service *handle_to_service(struct vchiq_instance *instance,
+					unsigned int handle)
 {
 	int idx = handle & (VCHIQ_MAX_SERVICES - 1);
 
@@ -249,7 +250,8 @@  find_service_by_handle(struct vchiq_instance *instance, unsigned int handle)
 		return service;
 	}
 	rcu_read_unlock();
-	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n", handle);
+	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n",
+		handle);
 	return NULL;
 }
 
@@ -289,12 +291,15 @@  find_service_for_instance(struct vchiq_instance *instance, unsigned int handle)
 		return service;
 	}
 	rcu_read_unlock();
-	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n", handle);
+	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n",
+		handle);
+
 	return NULL;
 }
 
 struct vchiq_service *
-find_closed_service_for_instance(struct vchiq_instance *instance, unsigned int handle)
+find_closed_service_for_instance(struct vchiq_instance *instance,
+				 unsigned int handle)
 {
 	struct vchiq_service *service;
 
@@ -311,7 +316,9 @@  find_closed_service_for_instance(struct vchiq_instance *instance, unsigned int h
 		return service;
 	}
 	rcu_read_unlock();
-	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n", handle);
+	dev_dbg(instance->state->dev, "core: Invalid service handle 0x%x\n",
+		handle);
+
 	return service;
 }
 
@@ -462,8 +469,8 @@  make_service_callback(struct vchiq_service *service, enum vchiq_reason reason,
 	dev_dbg(service->state->dev, "core: %d: callback:%d (%s, %pK, %pK)\n",
 		service->state->id, service->localport, reason_names[reason],
 		header, bulk_userdata);
-	status = service->base.callback(service->instance, reason, header, service->handle,
-					bulk_userdata);
+	status = service->base.callback(service->instance, reason, header,
+					service->handle, bulk_userdata);
 	if (status && (status != -EAGAIN)) {
 		dev_warn(service->state->dev,
 			 "core: %d: ignoring ERROR from callback to service %x\n",
@@ -483,7 +490,9 @@  vchiq_set_conn_state(struct vchiq_state *state, enum vchiq_connstate newstate)
 	enum vchiq_connstate oldstate = state->conn_state;
 
 	dev_dbg(state->dev, "core: %d: %s->%s\n",
-		state->id, conn_state_names[oldstate], conn_state_names[newstate]);
+		state->id, conn_state_names[oldstate],
+		conn_state_names[newstate]);
+
 	state->conn_state = newstate;
 	vchiq_platform_conn_state_changed(state, oldstate, newstate);
 }
@@ -524,7 +533,10 @@  remote_event_wait(wait_queue_head_t *wq, struct remote_event *event)
 			return ret;
 		}
 		event->armed = 0;
-		/* Ensure that the peer sees that we are not waiting (armed == 0). */
+		/*
+		 * Ensure that the peer sees that we are not waiting
+		 * (armed == 0).
+		 */
 		wmb();
 	}
 
@@ -578,8 +590,10 @@  remote_event_poll(wait_queue_head_t *wq, struct remote_event *event)
 void
 remote_event_pollall(struct vchiq_state *state)
 {
-	remote_event_poll(&state->sync_trigger_event, &state->local->sync_trigger);
-	remote_event_poll(&state->sync_release_event, &state->local->sync_release);
+	remote_event_poll(&state->sync_trigger_event,
+			  &state->local->sync_trigger);
+	remote_event_poll(&state->sync_release_event,
+			  &state->local->sync_release);
 	remote_event_poll(&state->trigger_event, &state->local->trigger);
 	remote_event_poll(&state->recycle_event, &state->local->recycle);
 }
@@ -614,8 +628,7 @@  get_listening_service(struct vchiq_state *state, int fourcc)
 		struct vchiq_service *service;
 
 		service = rcu_dereference(state->services[i]);
-		if (service &&
-		    service->public_fourcc == fourcc &&
+		if (service && service->public_fourcc == fourcc &&
 		    (service->srvstate == VCHIQ_SRVSTATE_LISTENING ||
 		     (service->srvstate == VCHIQ_SRVSTATE_OPEN &&
 		      service->remoteport == VCHIQ_PORT_FREE)) &&
@@ -679,7 +692,8 @@  request_poll(struct vchiq_state *state, struct vchiq_service *service,
 	wmb();
 
 	/* ... and ensure the slot handler runs. */
-	remote_event_signal_local(&state->trigger_event, &state->local->trigger);
+	remote_event_signal_local(&state->trigger_event,
+				  &state->local->trigger);
 }
 
 /*
@@ -789,11 +803,13 @@  process_free_data_message(struct vchiq_state *state, u32 *service_found,
 			 */
 			complete(&quota->quota_event);
 			dev_dbg(state->dev, "core: %d: pfq:%d %x@%pK - slot_use->%d\n",
-				state->id, port, header->size, header, count - 1);
+				state->id, port, header->size,
+				header, count - 1);
 		} else {
 			dev_err(state->dev,
 				"core: service %d slot_use_count=%d (header %pK, msgid %x, header->msgid %x, header->size %x)\n",
-				port, count, header, msgid, header->msgid, header->size);
+				port, count, header, msgid,
+				header->msgid, header->size);
 			WARN(1, "bad slot use count\n");
 		}
 	}
@@ -858,7 +874,8 @@  process_free_queue(struct vchiq_state *state, u32 *service_found,
 			if (pos > VCHIQ_SLOT_SIZE) {
 				dev_err(state->dev,
 					"core: pfq - pos %x: header %pK, msgid %x, header->msgid %x, header->size %x\n",
-					pos, header, msgid, header->msgid, header->size);
+					pos, header, msgid,
+					header->msgid, header->size);
 				WARN(1, "invalid slot position\n");
 			}
 		}
@@ -894,8 +911,8 @@  memcpy_copy_callback(void *context, void *dest, size_t offset, size_t maxsize)
 }
 
 static ssize_t
-copy_message_data(ssize_t (*copy_callback)(void *context, void *dest, size_t offset,
-					   size_t maxsize),
+copy_message_data(ssize_t (*copy_callback)(void *context, void *dest,
+					   size_t offset, size_t maxsize),
 	void *context,
 	void *dest,
 	size_t size)
@@ -1049,8 +1066,8 @@  queue_message(struct vchiq_state *state, struct vchiq_service *service,
 		int slot_use_count;
 
 		dev_dbg(state->dev, "core: %d: qm %s@%pK,%zx (%d->%d)\n",
-			state->id, msg_type_str(VCHIQ_MSG_TYPE(msgid)), header, size,
-			VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid));
+			state->id, msg_type_str(VCHIQ_MSG_TYPE(msgid)), header,
+			size, VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid));
 
 		WARN_ON(flags & (QMFLAGS_NO_MUTEX_LOCK |
 				 QMFLAGS_NO_MUTEX_UNLOCK));
@@ -1099,15 +1116,16 @@  queue_message(struct vchiq_state *state, struct vchiq_service *service,
 
 		if (slot_use_count)
 			dev_dbg(state->dev, "core: %d: qm:%d %s,%zx - slot_use->%d (hdr %p)\n",
-				state->id, service->localport, msg_type_str(VCHIQ_MSG_TYPE(msgid)),
-				size, slot_use_count, header);
+				state->id, service->localport,
+				msg_type_str(VCHIQ_MSG_TYPE(msgid)), size,
+				slot_use_count, header);
 
 		VCHIQ_SERVICE_STATS_INC(service, ctrl_tx_count);
 		VCHIQ_SERVICE_STATS_ADD(service, ctrl_tx_bytes, size);
 	} else {
 		dev_dbg(state->dev, "core: %d: qm %s@%pK,%zx (%d->%d)\n",
-			state->id, msg_type_str(VCHIQ_MSG_TYPE(msgid)), header, size,
-			VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid));
+			state->id, msg_type_str(VCHIQ_MSG_TYPE(msgid)), header,
+			size, VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid));
 		if (size != 0) {
 			/*
 			 * It is assumed for now that this code path
@@ -1136,8 +1154,10 @@  queue_message(struct vchiq_state *state, struct vchiq_service *service,
 			: VCHIQ_MAKE_FOURCC('?', '?', '?', '?');
 
 		dev_dbg(state->dev, "core_msg: Sent Msg %s(%u) to %p4cc s:%u d:%d len:%zu\n",
-			msg_type_str(VCHIQ_MSG_TYPE(msgid)), VCHIQ_MSG_TYPE(msgid),
-			&svc_fourcc, VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid), size);
+			msg_type_str(VCHIQ_MSG_TYPE(msgid)),
+			VCHIQ_MSG_TYPE(msgid), &svc_fourcc,
+			VCHIQ_MSG_SRCPORT(msgid), VCHIQ_MSG_DSTPORT(msgid),
+			size);
 	}
 
 	/* Make sure the new header is visible to the peer. */
@@ -1256,7 +1276,8 @@  release_slot(struct vchiq_state *state, struct vchiq_slot_info *slot_info,
 	if (header) {
 		int msgid = header->msgid;
 
-		if (((msgid & VCHIQ_MSGID_CLAIMED) == 0) || (service && service->closing)) {
+		if (((msgid & VCHIQ_MSGID_CLAIMED) == 0) ||
+		    (service && service->closing)) {
 			mutex_unlock(&state->recycle_mutex);
 			return;
 		}
@@ -1377,8 +1398,9 @@  notify_bulks(struct vchiq_service *service, struct vchiq_bulk_queue *queue,
 		status = 0;
 
 	if (status == -EAGAIN)
-		request_poll(service->state, service, (queue == &service->bulk_tx) ?
-			     VCHIQ_POLL_TXNOTIFY : VCHIQ_POLL_RXNOTIFY);
+		request_poll(service->state, service,
+			     (queue == &service->bulk_tx) ? VCHIQ_POLL_TXNOTIFY
+							  : VCHIQ_POLL_RXNOTIFY);
 
 	return status;
 }
@@ -1405,7 +1427,8 @@  poll_services_of_group(struct vchiq_state *state, int group)
 		service_flags = atomic_xchg(&service->poll_flags, 0);
 		if (service_flags & BIT(VCHIQ_POLL_REMOVE)) {
 			dev_dbg(state->dev, "core: %d: ps - remove %d<->%d\n",
-				state->id, service->localport, service->remoteport);
+				state->id, service->localport,
+				service->remoteport);
 
 			/*
 			 * Make it look like a client, because
@@ -1441,7 +1464,8 @@  poll_services(struct vchiq_state *state)
 }
 
 static void
-cleanup_pagelistinfo(struct vchiq_instance *instance, struct vchiq_pagelist_info *pagelistinfo)
+cleanup_pagelistinfo(struct vchiq_instance *instance,
+		     struct vchiq_pagelist_info *pagelistinfo)
 {
 	if (pagelistinfo->scatterlist_mapped) {
 		dma_unmap_sg(instance->state->dev, pagelistinfo->scatterlist,
@@ -1451,7 +1475,8 @@  cleanup_pagelistinfo(struct vchiq_instance *instance, struct vchiq_pagelist_info
 	if (pagelistinfo->pages_need_release)
 		unpin_user_pages(pagelistinfo->pages, pagelistinfo->num_pages);
 
-	dma_free_coherent(instance->state->dev, pagelistinfo->pagelist_buffer_size,
+	dma_free_coherent(instance->state->dev,
+			  pagelistinfo->pagelist_buffer_size,
 			  pagelistinfo->pagelist, pagelistinfo->dma_addr);
 }
 
@@ -1518,8 +1543,8 @@  create_pagelist(struct vchiq_instance *instance, char *buf, char __user *ubuf,
 	/* Allocate enough storage to hold the page pointers and the page
 	 * list
 	 */
-	pagelist = dma_alloc_coherent(instance->state->dev, pagelist_size, &dma_addr,
-				      GFP_KERNEL);
+	pagelist = dma_alloc_coherent(instance->state->dev, pagelist_size,
+				      &dma_addr, GFP_KERNEL);
 
 	dev_dbg(instance->state->dev, "arm: %pK\n", pagelist);
 
@@ -1572,8 +1597,10 @@  create_pagelist(struct vchiq_instance *instance, char *buf, char __user *ubuf,
 		}
 		/* do not try and release vmalloc pages */
 	} else {
-		actual_pages = pin_user_pages_fast((unsigned long)ubuf & PAGE_MASK, num_pages,
-						   type == PAGELIST_READ, pages);
+		actual_pages =
+			pin_user_pages_fast((unsigned long)ubuf & PAGE_MASK,
+					    num_pages, type == PAGELIST_READ,
+					    pages);
 
 		if (actual_pages != num_pages) {
 			dev_dbg(instance->state->dev, "arm: Only %d/%d pages locked\n",
@@ -1664,15 +1691,16 @@  create_pagelist(struct vchiq_instance *instance, char *buf, char __user *ubuf,
 }
 
 static void
-free_pagelist(struct vchiq_instance *instance, struct vchiq_pagelist_info *pagelistinfo,
-	      int actual)
+free_pagelist(struct vchiq_instance *instance,
+	      struct vchiq_pagelist_info *pagelistinfo, int actual)
 {
 	struct vchiq_drv_mgmt *drv_mgmt;
 	struct pagelist *pagelist = pagelistinfo->pagelist;
 	struct page **pages = pagelistinfo->pages;
 	unsigned int num_pages = pagelistinfo->num_pages;
 
-	dev_dbg(instance->state->dev, "arm: %pK, %d\n", pagelistinfo->pagelist, actual);
+	dev_dbg(instance->state->dev, "arm: %pK, %d\n",
+		pagelistinfo->pagelist, actual);
 
 	drv_mgmt = dev_get_drvdata(instance->state->dev);
 
@@ -1685,16 +1713,17 @@  free_pagelist(struct vchiq_instance *instance, struct vchiq_pagelist_info *pagel
 	pagelistinfo->scatterlist_mapped = 0;
 
 	/* Deal with any partial cache lines (fragments) */
-	if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS && drv_mgmt->fragments_base) {
+	if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS &&
+	    drv_mgmt->fragments_base) {
 		char *fragments = drv_mgmt->fragments_base +
 			(pagelist->type - PAGELIST_READ_WITH_FRAGMENTS) *
 			drv_mgmt->fragments_size;
 		int head_bytes, tail_bytes;
 
 		head_bytes = (drv_mgmt->info->cache_line_size - pagelist->offset) &
-			(drv_mgmt->info->cache_line_size - 1);
+			     (drv_mgmt->info->cache_line_size - 1);
 		tail_bytes = (pagelist->offset + actual) &
-			(drv_mgmt->info->cache_line_size - 1);
+			     (drv_mgmt->info->cache_line_size - 1);
 
 		if ((actual >= 0) && (head_bytes != 0)) {
 			if (head_bytes > actual)
@@ -1731,8 +1760,8 @@  free_pagelist(struct vchiq_instance *instance, struct vchiq_pagelist_info *pagel
 }
 
 static int
-vchiq_prepare_bulk_data(struct vchiq_instance *instance, struct vchiq_bulk *bulk, void *offset,
-			void __user *uoffset, int size, int dir)
+vchiq_prepare_bulk_data(struct vchiq_instance *instance, struct vchiq_bulk *bulk,
+			void *offset, void __user *uoffset, int size, int dir)
 {
 	struct vchiq_pagelist_info *pagelistinfo;
 
@@ -1759,7 +1788,8 @@  static void
 vchiq_complete_bulk(struct vchiq_instance *instance, struct vchiq_bulk *bulk)
 {
 	if (bulk && bulk->remote_data && bulk->actual)
-		free_pagelist(instance, (struct vchiq_pagelist_info *)bulk->remote_data,
+		free_pagelist(instance,
+			      (struct vchiq_pagelist_info *)bulk->remote_data,
 			      bulk->actual);
 }
 
@@ -1796,8 +1826,8 @@  abort_outstanding_bulks(struct vchiq_service *service,
 			dev_dbg(service->state->dev,
 				"core_msg: %s %p4cc d:%d ABORTED - tx len:%d, rx len:%d\n",
 				is_tx ? "Send Bulk to" : "Recv Bulk from",
-				&service->base.fourcc,
-				service->remoteport, bulk->size, bulk->remote_size);
+				&service->base.fourcc, service->remoteport,
+				bulk->size, bulk->remote_size);
 		} else {
 			/* fabricate a matching dummy bulk */
 			bulk->data = 0;
@@ -1845,7 +1875,8 @@  parse_open(struct vchiq_state *state, struct vchiq_header *header)
 		/* Version mismatch */
 		dev_err(state->dev, "%d: service %d (%p4cc) version mismatch - local (%d, min %d) vs. remote (%d, min %d)",
 			state->id, service->localport, &fourcc,
-			service->version, service->version_min, version, version_min);
+			service->version, service->version_min,
+			version, version_min);
 		vchiq_service_put(service);
 		service = NULL;
 		goto fail_open;
@@ -1864,15 +1895,18 @@  parse_open(struct vchiq_state *state, struct vchiq_header *header)
 
 		/* Acknowledge the OPEN */
 		if (service->sync) {
-			if (queue_message_sync(state, NULL, openack_id, memcpy_copy_callback,
-					       &ack_payload, sizeof(ack_payload)) == -EAGAIN)
+			if (queue_message_sync(state, NULL, openack_id,
+					       memcpy_copy_callback,
+					       &ack_payload,
+					       sizeof(ack_payload)) == -EAGAIN)
 				goto bail_not_ready;
 
 			/* The service is now open */
 			set_service_state(service, VCHIQ_SRVSTATE_OPENSYNC);
 		} else {
-			if (queue_message(state, NULL, openack_id, memcpy_copy_callback,
-					  &ack_payload, sizeof(ack_payload), 0) == -EINTR)
+			if (queue_message(state, NULL, openack_id,
+					  memcpy_copy_callback, &ack_payload,
+					  sizeof(ack_payload), 0) == -EINTR)
 				goto bail_not_ready;
 
 			/* The service is now open */
@@ -1957,14 +1991,15 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 				dev_warn(state->dev,
 					 "core: %d: prs %s@%pK (%d->%d) - found connected service %d\n",
 					 state->id, msg_type_str(type), header,
-					 remoteport, localport, service->localport);
+					 remoteport, localport,
+					 service->localport);
 		}
 
 		if (!service) {
 			dev_err(state->dev,
 				"core: %d: prs %s@%pK (%d->%d) - invalid/closed service %d\n",
-				state->id, msg_type_str(type), header, remoteport,
-				localport, localport);
+				state->id, msg_type_str(type), header,
+				remoteport, localport, localport);
 			goto skip_message;
 		}
 		break;
@@ -1976,9 +2011,11 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 			     : VCHIQ_MAKE_FOURCC('?', '?', '?', '?');
 
 	dev_dbg(state->dev, "core_msg: Rcvd Msg %s(%u) from %p4cc s:%d d:%d len:%d\n",
-		msg_type_str(type), type, &svc_fourcc, remoteport, localport, size);
+		msg_type_str(type), type, &svc_fourcc,
+		remoteport, localport, size);
 	if (size > 0)
-		vchiq_log_dump_mem(state->dev, "Rcvd", 0, header->data, min(16, size));
+		vchiq_log_dump_mem(state->dev, "Rcvd", 0, header->data,
+				   min(16, size));
 
 	if (((unsigned long)header & VCHIQ_SLOT_MASK) +
 	    calc_stride(size) > VCHIQ_SLOT_SIZE) {
@@ -2025,7 +2062,8 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 			goto bail_not_ready;
 
 		dev_dbg(state->dev, "core: Close Service %p4cc s:%u d:%d\n",
-			&service->base.fourcc, service->localport, service->remoteport);
+			&service->base.fourcc, service->localport,
+			service->remoteport);
 		break;
 	case VCHIQ_MSG_DATA:
 		dev_dbg(state->dev, "core: %d: prs DATA@%pK,%x (%d->%d)\n",
@@ -2036,8 +2074,9 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 			header->msgid = msgid | VCHIQ_MSGID_CLAIMED;
 			claim_slot(state->rx_info);
 			DEBUG_TRACE(PARSE_LINE);
-			if (make_service_callback(service, VCHIQ_MESSAGE_AVAILABLE, header,
-						  NULL) == -EAGAIN) {
+			if (make_service_callback(service,
+						  VCHIQ_MESSAGE_AVAILABLE,
+						  header, NULL) == -EAGAIN) {
 				DEBUG_TRACE(PARSE_LINE);
 				goto bail_not_ready;
 			}
@@ -2082,8 +2121,10 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 				queue->local_insert) >= 0) {
 				dev_err(state->dev,
 					"core: %d: prs %s@%pK (%d->%d) unexpected (ri=%d,li=%d)\n",
-					state->id, msg_type_str(type), header, remoteport,
-					localport, queue->remote_insert, queue->local_insert);
+					state->id, msg_type_str(type), header,
+					remoteport, localport,
+					queue->remote_insert,
+					queue->local_insert);
 				mutex_unlock(&service->bulk_mutex);
 				break;
 			}
@@ -2100,13 +2141,15 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 			queue->remote_insert++;
 
 			dev_dbg(state->dev, "core: %d: prs %s@%pK (%d->%d) %x@%pad\n",
-				state->id, msg_type_str(type), header, remoteport,
-				localport, bulk->actual, &bulk->data);
+				state->id, msg_type_str(type), header,
+				remoteport, localport,
+				bulk->actual, &bulk->data);
 
 			dev_dbg(state->dev, "core: %d: prs:%d %cx li=%x ri=%x p=%x\n",
 				state->id, localport,
 				(type == VCHIQ_MSG_BULK_RX_DONE) ? 'r' : 't',
-				queue->local_insert, queue->remote_insert, queue->process);
+				queue->local_insert, queue->remote_insert,
+				queue->process);
 
 			DEBUG_TRACE(PARSE_LINE);
 			WARN_ON(queue->process == queue->local_insert);
@@ -2133,8 +2176,8 @@  parse_message(struct vchiq_state *state, struct vchiq_header *header)
 		}
 		if (state->conn_state != VCHIQ_CONNSTATE_PAUSE_SENT) {
 			/* Send a PAUSE in response */
-			if (queue_message(state, NULL, MAKE_PAUSE, NULL, NULL, 0,
-					  QMFLAGS_NO_MUTEX_UNLOCK) == -EINTR)
+			if (queue_message(state, NULL, MAKE_PAUSE, NULL, NULL,
+					  0, QMFLAGS_NO_MUTEX_UNLOCK) == -EINTR)
 				goto bail_not_ready;
 		}
 		/* At this point slot_mutex is held */
@@ -2362,7 +2405,8 @@  sync_func(void *v)
 		int type;
 		unsigned int localport, remoteport;
 
-		ret = remote_event_wait(&state->sync_trigger_event, &local->sync_trigger);
+		ret = remote_event_wait(&state->sync_trigger_event,
+					&local->sync_trigger);
 		if (ret)
 			return ret;
 
@@ -2380,8 +2424,8 @@  sync_func(void *v)
 		if (!service) {
 			dev_err(state->dev,
 				"sync: %d: sf %s@%pK (%d->%d) - invalid/closed service %d\n",
-				state->id, msg_type_str(type), header, remoteport,
-				localport, localport);
+				state->id, msg_type_str(type), header,
+				remoteport, localport, localport);
 			release_message_sync(state, header);
 			continue;
 		}
@@ -2389,9 +2433,11 @@  sync_func(void *v)
 		svc_fourcc = service->base.fourcc;
 
 		dev_dbg(state->dev, "sync: Rcvd Msg %s from %p4cc s:%d d:%d len:%d\n",
-			msg_type_str(type), &svc_fourcc, remoteport, localport, size);
+			msg_type_str(type), &svc_fourcc, remoteport, localport,
+			size);
 		if (size > 0)
-			vchiq_log_dump_mem(state->dev, "Rcvd", 0, header->data, min(16, size));
+			vchiq_log_dump_mem(state->dev, "Rcvd", 0, header->data,
+					   min(16, size));
 
 		switch (type) {
 		case VCHIQ_MSG_OPENACK:
@@ -2406,7 +2452,8 @@  sync_func(void *v)
 				service->peer_version);
 			if (service->srvstate == VCHIQ_SRVSTATE_OPENING) {
 				service->remoteport = remoteport;
-				set_service_state(service, VCHIQ_SRVSTATE_OPENSYNC);
+				set_service_state(service,
+						  VCHIQ_SRVSTATE_OPENSYNC);
 				service->sync = 1;
 				complete(&service->remove_event);
 			}
@@ -2419,7 +2466,9 @@  sync_func(void *v)
 
 			if ((service->remoteport == remoteport) &&
 			    (service->srvstate == VCHIQ_SRVSTATE_OPENSYNC)) {
-				if (make_service_callback(service, VCHIQ_MESSAGE_AVAILABLE, header,
+				if (make_service_callback(service,
+							  VCHIQ_MESSAGE_AVAILABLE,
+							  header,
 							  NULL) == -EAGAIN)
 					dev_err(state->dev,
 						"sync: error: synchronous callback to service %d returns -EAGAIN\n",
@@ -2488,7 +2537,8 @@  vchiq_init_slots(struct device *dev, void *mem_base, int mem_size)
 }
 
 int
-vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, struct device *dev)
+vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero,
+		 struct device *dev)
 {
 	struct vchiq_shared_state *local;
 	struct vchiq_shared_state *remote;
@@ -2569,7 +2619,8 @@  vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, s
 	((struct vchiq_header *)
 		SLOT_DATA_FROM_INDEX(state, local->slot_sync))->msgid =
 							VCHIQ_MSGID_PADDING;
-	remote_event_signal_local(&state->sync_release_event, &local->sync_release);
+	remote_event_signal_local(&state->sync_release_event,
+				  &local->sync_release);
 
 	local->debug[DEBUG_ENTRIES] = DEBUG_MAX;
 
@@ -2581,7 +2632,8 @@  vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, s
 	 * bring up slot handler thread
 	 */
 	snprintf(threadname, sizeof(threadname), "vchiq-slot/%d", state->id);
-	state->slot_handler_thread = kthread_create(&slot_handler_func, (void *)state, threadname);
+	state->slot_handler_thread = kthread_create(&slot_handler_func,
+						    (void *)state, threadname);
 
 	if (IS_ERR(state->slot_handler_thread)) {
 		dev_err(state->dev, "couldn't create thread %s\n", threadname);
@@ -2590,7 +2642,8 @@  vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, s
 	set_user_nice(state->slot_handler_thread, -19);
 
 	snprintf(threadname, sizeof(threadname), "vchiq-recy/%d", state->id);
-	state->recycle_thread = kthread_create(&recycle_func, (void *)state, threadname);
+	state->recycle_thread = kthread_create(&recycle_func, (void *)state,
+					       threadname);
 	if (IS_ERR(state->recycle_thread)) {
 		dev_err(state->dev, "couldn't create thread %s\n", threadname);
 		ret = PTR_ERR(state->recycle_thread);
@@ -2599,7 +2652,8 @@  vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, s
 	set_user_nice(state->recycle_thread, -19);
 
 	snprintf(threadname, sizeof(threadname), "vchiq-sync/%d", state->id);
-	state->sync_thread = kthread_create(&sync_func, (void *)state, threadname);
+	state->sync_thread = kthread_create(&sync_func, (void *)state,
+					    threadname);
 	if (IS_ERR(state->sync_thread)) {
 		dev_err(state->dev, "couldn't create thread %s\n", threadname);
 		ret = PTR_ERR(state->sync_thread);
@@ -2647,7 +2701,8 @@  void vchiq_msg_queue_push(struct vchiq_instance *instance, unsigned int handle,
 }
 EXPORT_SYMBOL(vchiq_msg_queue_push);
 
-struct vchiq_header *vchiq_msg_hold(struct vchiq_instance *instance, unsigned int handle)
+struct vchiq_header *vchiq_msg_hold(struct vchiq_instance *instance,
+				    unsigned int handle)
 {
 	struct vchiq_service *service = find_service_by_handle(instance, handle);
 	struct vchiq_header *header;
@@ -2849,7 +2904,8 @@  vchiq_open_service_internal(struct vchiq_service *service, int client_id)
 		if (service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT)
 			dev_err(service->state->dev,
 				"core: %d: osi - srvstate = %s (ref %u)\n",
-				service->state->id, srvstate_names[service->srvstate],
+				service->state->id,
+				srvstate_names[service->srvstate],
 				kref_read(&service->ref_count));
 		status = -EINVAL;
 		VCHIQ_SERVICE_STATS_INC(service, error_count);
@@ -2904,15 +2960,18 @@  release_service_messages(struct vchiq_service *service)
 			int msgid = header->msgid;
 			int port = VCHIQ_MSG_DSTPORT(msgid);
 
-			if ((port == service->localport) && (msgid & VCHIQ_MSGID_CLAIMED)) {
-				dev_dbg(state->dev, "core:  fsi - hdr %pK\n", header);
+			if ((port == service->localport) &&
+			    (msgid & VCHIQ_MSGID_CLAIMED)) {
+				dev_dbg(state->dev, "core:  fsi - hdr %pK\n",
+					header);
 				release_slot(state, slot_info, header, NULL);
 			}
 			pos += calc_stride(header->size);
 			if (pos > VCHIQ_SLOT_SIZE) {
 				dev_err(state->dev,
 					"core: fsi - pos %x: header %pK, msgid %x, header->msgid %x, header->size %x\n",
-					pos, header, msgid, header->msgid, header->size);
+					pos, header, msgid,
+					header->msgid, header->size);
 				WARN(1, "invalid slot position\n");
 			}
 		}
@@ -2972,7 +3031,8 @@  close_service_complete(struct vchiq_service *service, int failstate)
 		return -EINVAL;
 	}
 
-	status = make_service_callback(service, VCHIQ_SERVICE_CLOSED, NULL, NULL);
+	status = make_service_callback(service, VCHIQ_SERVICE_CLOSED,
+				       NULL, NULL);
 
 	if (status != -EAGAIN) {
 		int uc = service->service_use_count;
@@ -3059,7 +3119,8 @@  vchiq_bulk_xfer_queue_msg_killable(struct vchiq_service *service,
 	bulk->size = size;
 	bulk->actual = VCHIQ_BULK_ACTUAL_ABORTED;
 
-	if (vchiq_prepare_bulk_data(service->instance, bulk, offset, uoffset, size, dir))
+	if (vchiq_prepare_bulk_data(service->instance, bulk,
+				    offset, uoffset, size, dir))
 		goto unlock_error_exit;
 
 	/*
@@ -3266,7 +3327,8 @@  vchiq_free_service_internal(struct vchiq_service *service)
 {
 	struct vchiq_state *state = service->state;
 
-	dev_dbg(state->dev, "core: %d: fsi - (%d)\n", state->id, service->localport);
+	dev_dbg(state->dev, "core: %d: fsi - (%d)\n",
+		state->id, service->localport);
 
 	switch (service->srvstate) {
 	case VCHIQ_SRVSTATE_OPENING:
@@ -3277,7 +3339,8 @@  vchiq_free_service_internal(struct vchiq_service *service)
 		break;
 	default:
 		dev_err(state->dev, "core: %d: fsi - (%d) in state %s\n",
-			state->id, service->localport, srvstate_names[service->srvstate]);
+			state->id, service->localport,
+			srvstate_names[service->srvstate]);
 		return;
 	}
 
@@ -3290,7 +3353,8 @@  vchiq_free_service_internal(struct vchiq_service *service)
 }
 
 int
-vchiq_connect_internal(struct vchiq_state *state, struct vchiq_instance *instance)
+vchiq_connect_internal(struct vchiq_state *state,
+		       struct vchiq_instance *instance)
 {
 	struct vchiq_service *service;
 	int status = 0;
@@ -3342,7 +3406,8 @@  int
 vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
 {
 	/* Unregister the service */
-	struct vchiq_service *service = find_service_by_handle(instance, handle);
+	struct vchiq_service *service = find_service_by_handle(instance,
+							       handle);
 	int status = 0;
 
 	if (!service)
@@ -3476,8 +3541,8 @@  vchiq_bulk_xfer_blocking(struct vchiq_instance *instance, unsigned int handle,
 		goto error_exit;
 
 
-	status = vchiq_bulk_xfer_queue_msg_killable(service, offset, uoffset, size,
-						    userdata, mode, dir);
+	status = vchiq_bulk_xfer_queue_msg_killable(service, offset, uoffset,
+						    size, userdata, mode, dir);
 
 error_exit:
 	vchiq_service_put(service);
@@ -3614,7 +3679,8 @@  vchiq_queue_message(struct vchiq_instance *instance, unsigned int handle,
 	return status;
 }
 
-int vchiq_queue_kernel_message(struct vchiq_instance *instance, unsigned int handle, void *data,
+int vchiq_queue_kernel_message(struct vchiq_instance *instance,
+			       unsigned int handle, void *data,
 			       unsigned int size)
 {
 
@@ -3666,7 +3732,8 @@  release_message_sync(struct vchiq_state *state, struct vchiq_header *header)
 }
 
 int
-vchiq_get_peer_version(struct vchiq_instance *instance, unsigned int handle, short *peer_version)
+vchiq_get_peer_version(struct vchiq_instance *instance, unsigned int handle,
+		       short *peer_version)
 {
 	int status = -EINVAL;
 	struct vchiq_service *service = find_service_by_handle(instance, handle);
@@ -3803,8 +3870,8 @@  vchiq_dump_shared_state(struct seq_file *f, struct vchiq_state *state,
 		struct vchiq_slot_info slot_info =
 						*SLOT_INFO_FROM_INDEX(state, i);
 		if (slot_info.use_count != slot_info.release_count) {
-			seq_printf(f, "      %d: %d/%d\n", i, slot_info.use_count,
-				   slot_info.release_count);
+			seq_printf(f, "      %d: %d/%d\n", i,
+				   slot_info.use_count, slot_info.release_count);
 		}
 	}
 
@@ -3836,7 +3903,8 @@  vchiq_dump_service_state(struct seq_file *f, struct vchiq_service *service)
 				"%u", service->remoteport);
 
 			if (service->public_fourcc != VCHIQ_FOURCC_INVALID)
-				scnprintf(remoteport + len2, sizeof(remoteport) - len2,
+				scnprintf(remoteport + len2,
+					  sizeof(remoteport) - len2,
 					  " (client 0x%x)", service->client_id);
 		} else {
 			strscpy(remoteport, "n/a", sizeof(remoteport));
@@ -3909,7 +3977,8 @@  void vchiq_dump_state(struct seq_file *f, struct vchiq_state *state)
 
 	if (VCHIQ_ENABLE_STATS) {
 		seq_printf(f, "  Stats: ctrl_tx_count=%d, ctrl_rx_count=%d, error_count=%d\n",
-			   state->stats.ctrl_tx_count, state->stats.ctrl_rx_count,
+			   state->stats.ctrl_tx_count,
+			   state->stats.ctrl_rx_count,
 			   state->stats.error_count);
 	}