[PATCH v2 60/60] staging: ced1401: usb1401.c fix checkpatch warnings

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Signed-off-by: Luca Ellero <luca.ellero@xxxxxxxxxxxxxxxx>
---
 drivers/staging/ced1401/usb1401.c |  263 +++++++++++++++++++++++--------------
 1 file changed, 167 insertions(+), 96 deletions(-)

diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c
index a3d1ed6..f362859 100644
--- a/drivers/staging/ced1401/usb1401.c
+++ b/drivers/staging/ced1401/usb1401.c
@@ -1,11 +1,12 @@
-/***********************************************************************************
- CED1401 usb driver. This basic loading is based on the usb-skeleton.c code that is:
+/*******************************************************************************
+ CED1401 usb driver. This basic loading is based on the usb-skeleton.c code
+ that is:
  Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@xxxxxxxxx)
  Copyright (C) 2012 Alois Schloegl <alois.schloegl@xxxxxxxxx>
  There is not a great deal of the skeleton left.
 
- All the remainder dealing specifically with the CED1401 is based on drivers written
- by CED for other systems (mainly Windows) and is:
+ All the remainder dealing specifically with the CED1401 is based on drivers
+ written by CED for other systems (mainly Windows) and is:
  Copyright (C) 2010 Cambridge Electronic Design Ltd
  Author Greg P Smith (greg@xxxxxxxxx)
 
@@ -125,8 +126,9 @@ static void ced_delete(struct kref *kref)
 {
 	struct ced_data *ced = to_ced_data(kref);
 
-	/*  Free up the output buffer, then free the output urb. Note that the interface member */
-	/*  of ced will probably be NULL, so cannot be used to get to dev. */
+	/* Free up the output buffer, then free the output urb. Note that  */
+	/* the interface member of ced will probably be NULL, so cannot be */
+	/* used to get to dev.						   */
 	usb_free_coherent(ced->udev, OUTBUF_SZ, ced->coher_char_out,
 			  ced->urb_char_out->transfer_dma);
 	usb_free_urb(ced->urb_char_out);
@@ -183,7 +185,7 @@ static int ced_open(struct inode *inode, struct file *file)
 			kref_put(&ced->kref, ced_delete);
 			goto exit;
 		}
-	} else {		/* uncomment this block if you want exclusive open */
+	} else {	/* uncomment this block if you want exclusive open */
 		dev_err(&interface->dev, "%s: fail: already open\n", __func__);
 		retval = -EBUSY;
 		ced->open_count--;
@@ -204,6 +206,7 @@ exit:
 static int ced_release(struct inode *inode, struct file *file)
 {
 	struct ced_data *ced = file->private_data;
+
 	if (ced == NULL)
 		return -ENODEV;
 
@@ -213,7 +216,8 @@ static int ced_release(struct inode *inode, struct file *file)
 		usb_autopm_put_interface(ced->interface);
 	mutex_unlock(&ced->io_mutex);
 
-	kref_put(&ced->kref, ced_delete);	/*  decrement the count on our device */
+	/* decrement the count on our device */
+	kref_put(&ced->kref, ced_delete);
 	return 0;
 }
 
@@ -221,6 +225,7 @@ static int ced_flush(struct file *file, fl_owner_t id)
 {
 	int res;
 	struct ced_data *ced = file->private_data;
+
 	if (ced == NULL)
 		return -ENODEV;
 
@@ -294,21 +299,27 @@ static void ced_writechar_callback(struct urb *urb)
 		spin_lock(&ced->char_out_lock);	/*  already at irq level */
 		ced->num_output -= got;	/*  Now adjust the char send buffer */
 		ced->out_buff_get += got;	/*  to match what we did */
-		if (ced->out_buff_get >= OUTBUF_SZ)	/*  Can't do this any earlier as data could be overwritten */
+
+		/* Can't do this any earlier as data could be overwritten */
+		if (ced->out_buff_get >= OUTBUF_SZ)
 			ced->out_buff_get = 0;
 
 		if (ced->num_output > 0) {	/*  if more to be done... */
 			int pipe = 0;	/*  The pipe number to use */
 			int ret;
 			char *pDat = &ced->output_buffer[ced->out_buff_get];
-			unsigned int dwCount = ced->num_output;	/*  maximum to send */
-			if ((ced->out_buff_get + dwCount) > OUTBUF_SZ)	/*  does it cross buffer end? */
+			/* maximum to send */
+			unsigned int dwCount = ced->num_output;
+
+			/* does it cross buffer end? */
+			if ((ced->out_buff_get + dwCount) > OUTBUF_SZ)
 				dwCount = OUTBUF_SZ - ced->out_buff_get;
 
 			/* we are done with stuff that changes */
 			spin_unlock(&ced->char_out_lock);
 
-			memcpy(ced->coher_char_out, pDat, dwCount);	/*  copy output data to the buffer */
+			/* copy output data to the buffer */
+			memcpy(ced->coher_char_out, pDat, dwCount);
 			usb_fill_bulk_urb(ced->urb_char_out, ced->udev,
 					  usb_sndbulkpipe(ced->udev,
 							  ced->ep_addr[0]),
@@ -316,14 +327,22 @@ static void ced_writechar_callback(struct urb *urb)
 					  ced_writechar_callback, ced);
 			ced->urb_char_out->transfer_flags |=
 			    URB_NO_TRANSFER_DMA_MAP;
-			usb_anchor_urb(ced->urb_char_out, &ced->submitted);	/*  in case we need to kill it */
+
+			/* in case we need to kill it */
+			usb_anchor_urb(ced->urb_char_out, &ced->submitted);
+
 			ret = usb_submit_urb(ced->urb_char_out, GFP_ATOMIC);
 			dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n",
 				__func__, dwCount, pDat);
-			spin_lock(&ced->char_out_lock);	/*  grab lock for errors */
+
+			/* grab lock for errors */
+			spin_lock(&ced->char_out_lock);
+
 			if (ret) {
-				ced->pipe_error[pipe] = 1;	/*  Flag an error to be handled later */
-				ced->send_chars_pending = false;	/*  Allow other threads again */
+				/* Flag an error to be handled later */
+				ced->pipe_error[pipe] = 1;
+				/* Allow other threads again */
+				ced->send_chars_pending = false;
 				usb_unanchor_urb(ced->urb_char_out);
 				dev_err(&ced->interface->dev,
 					"%s: usb_submit_urb() returned %d\n",
@@ -350,25 +369,32 @@ int ced_send_chars(struct ced_data *ced)
 
 	if ((!ced->send_chars_pending) &&	/*  Not currently sending */
 	    (ced->num_output > 0) &&	/*   has characters to output */
-	    (can_accept_io_requests(ced)))	{ /*   and current activity is OK */
+	    (can_accept_io_requests(ced))) { /* and current activity is OK */
 		unsigned int count = ced->num_output;	/* Get a copy of the */
 							/* character count   */
-		ced->send_chars_pending = true;	/*  Set flag to lock out other threads */
+		/* Set flag to lock out other threads */
+		ced->send_chars_pending = true;
 
 		dev_dbg(&ced->interface->dev,
 			"Send %d chars to 1401, EP0 flag %d\n",
 			count, ced->n_pipes == 3);
-		/*  If we have only 3 end points we must send the characters to the 1401 using EP0. */
+
+		/* If we have only 3 end points we must send the */
+		/* characters to the 1401 using EP0.		 */
 		if (ced->n_pipes == 3) {
-			/*  For EP0 character transmissions to the 1401, we have to hang about until they */
-			/*  are gone, as otherwise without more character IO activity they will never go. */
-			unsigned int i = count;	/*  Local char counter */
-			unsigned int index = 0;	/*  The index into the char buffer */
+			/* For EP0 character transmissions to the 1401, we */
+			/* have to hang about until they are gone, as	   */
+			/* otherwise without more character IO activity	   */
+			/* they will never go.				   */
+			unsigned int i = count;	/* Local char counter */
+			unsigned int index = 0;	/* Index into the char buffer */
 
-			spin_unlock_irq(&ced->char_out_lock);	/*  Free spinlock as we call USBD */
+			/* Free spinlock as we call USBD */
+			spin_unlock_irq(&ced->char_out_lock);
 
 			while ((i > 0) && (retval == U14ERR_NOERROR)) {
-				/*  We have to break the transfer up into 64-byte chunks because of a 2270 problem */
+				/* We have to break the transfer up into    */
+				/* 64-byte chunks because of a 2270 problem */
 				int n = i > 64 ? 64 : i;	/*  Chars for this xfer, max of 64 */
 				int sent = usb_control_msg(ced->udev,
 							    usb_sndctrlpipe(ced->udev, 0),	/*  use end point 0 */
@@ -379,10 +405,11 @@ int ced_send_chars(struct ced_data *ced)
 							    n,	/*  how much to send */
 							    1000);	/*  timeout in jiffies */
 				if (sent <= 0) {
-					retval = sent ? sent : -ETIMEDOUT;	/*  if 0 chars says we timed out */
+					/* if 0 chars says we timed out */
+					retval = sent ? sent : -ETIMEDOUT;
 					dev_err(&ced->interface->dev,
-						"Send %d chars by EP0 failed: %d\n",
-						n, retval);
+					  "Send %d chars by EP0 failed: %d\n",
+					  n, retval);
 				} else {
 					dev_dbg(&ced->interface->dev,
 						"Sent %d chars by EP0\n", n);
@@ -391,19 +418,26 @@ int ced_send_chars(struct ced_data *ced)
 				}
 			}
 
-			spin_lock_irq(&ced->char_out_lock);	/*  Protect ced changes, released by general code */
-			ced->out_buff_get = 0;	/*  so reset the output buffer */
+			/* Protect ced changes, released by general code */
+			spin_lock_irq(&ced->char_out_lock);
+			ced->out_buff_get = 0; /* so reset the output buffer */
 			ced->out_buff_put = 0;
-			ced->num_output = 0;	/*  and clear the buffer count */
-			ced->send_chars_pending = false;	/*  Allow other threads again */
-		} else {	/*  Here for sending chars normally - we hold the spin lock */
+			ced->num_output = 0;   /* and clear the buffer count */
+			 /* Allow other threads again */
+			ced->send_chars_pending = false;
+		} else { /* Here for sending chars normally, */
+			 /* we hold the spin lock            */
 			int pipe = 0;	/*  The pipe number to use */
 			char *pDat = &ced->output_buffer[ced->out_buff_get];
 
-			if ((ced->out_buff_get + count) > OUTBUF_SZ)	/*  does it cross buffer end? */
+			/* does it cross buffer end? */
+			if ((ced->out_buff_get + count) > OUTBUF_SZ)
 				count = OUTBUF_SZ - ced->out_buff_get;
-			spin_unlock_irq(&ced->char_out_lock);	/*  we are done with stuff that changes */
-			memcpy(ced->coher_char_out, pDat, count);	/*  copy output data to the buffer */
+			/* we are done with stuff that changes */
+			spin_unlock_irq(&ced->char_out_lock);
+
+			/* copy output data to the buffer */
+			memcpy(ced->coher_char_out, pDat, count);
 			usb_fill_bulk_urb(ced->urb_char_out, ced->udev,
 					  usb_sndbulkpipe(ced->udev,
 							  ced->ep_addr[0]),
@@ -418,9 +452,12 @@ int ced_send_chars(struct ced_data *ced)
 			spin_lock_irq(&ced->char_out_lock);
 
 			if (retval) {
-				ced->pipe_error[pipe] = 1;	/*  Flag an error to be handled later */
-				ced->send_chars_pending = false;	/*  Allow other threads again */
-				usb_unanchor_urb(ced->urb_char_out);	/*  remove from list of active urbs */
+				/* Flag an error to be handled later */
+				ced->pipe_error[pipe] = 1;
+				/* Allow other threads again */
+				ced->send_chars_pending = false;
+				/* remove from list of active urbs */
+				usb_unanchor_urb(ced->urb_char_out);
 			}
 		}
 	} else if (ced->send_chars_pending && (ced->num_output > 0))
@@ -449,12 +486,14 @@ int ced_send_chars(struct ced_data *ced)
 static void ced_copy_user_space(struct ced_data *ced, int n)
 {
 	unsigned int area = ced->staged_id;
+
 	if (area < MAX_TRANSAREAS) {
 		/*  area to be used */
 		struct transarea *ta = &ced->trans_def[area];
 		unsigned int offset =
 		    ced->staged_done + ced->staged_offset + ta->base_offset;
 		char *coher_buf = ced->coher_staged_io;	/*  coherent buffer */
+
 		if (!ta->used) {
 			dev_err(&ced->interface->dev, "%s: area %d unused\n",
 				__func__, area);
@@ -673,8 +712,11 @@ static void staged_callback(struct urb *urb)
 				/* transfer then set the event to notify the  */
 				/* user code to wake up anyone that is        */
 				/* waiting. */
-				if ((ta->circular) && /* Circular areas use a simpler test */
-				    (ta->circ_to_host)) {	/*  only in supported direction */
+
+				 /* Circular areas use a simpler test */
+				if ((ta->circular) &&
+				    /* only in supported direction */
+				    (ta->circ_to_host)) {
 					/* Is total data waiting up */
 					/* to size limit? */
 					unsigned int dwTotal =
@@ -711,6 +753,7 @@ static void staged_callback(struct urb *urb)
 			/*  If we have a transfer waiting, kick it off */
 			if (ced->xfer_waiting) {/*  Got a block xfer waiting? */
 				int retval;
+
 				dev_info(&ced->interface->dev,
 					 "*** RWM_Complete *** pending transfer"
 					 " will now be set up!!!\n");
@@ -722,9 +765,10 @@ static void staged_callback(struct urb *urb)
 						       ced->dma_info.size);
 
 				if (retval)
-					dev_err(&ced->interface->dev,
-						"RWM_Complete rw setup failed %d\n",
-						retval);
+					dev_err(
+					    &ced->interface->dev,
+					    "RWM_Complete rw setup failed %d\n",
+					    retval);
 			}
 		}
 
@@ -1065,39 +1109,42 @@ static bool ced_read_dma_info(volatile struct dmadesc *dma_desc,
 		/* Extended linear transfer modes (the only ones!) */
 		case TM_EXTTOHOST:
 		case TM_EXTTO1401:
-			{
-				retval =
-				    ced_read_huff(&(dma_desc->offset), buf,
-					     &n_done, count)
-				    && ced_read_huff(&(dma_desc->size), buf,
-						&n_done, count);
-				if (retval) {
-					dev_dbg(&ced->interface->dev,
-						"%s: xfer offset & size %d %d\n",
-						__func__, dma_desc->offset,
-						dma_desc->size);
-
-					if ((ident >= MAX_TRANSAREAS) ||	/*  Illegal area number, or... */
-					    (!ced->trans_def[ident].used) ||	/*  area not set up, or... */
-					    (dma_desc->offset > ced->trans_def[ident].length) ||	/*  range/size */
-					    ((dma_desc->offset +
-					      dma_desc->size) >
-					     (ced->trans_def[ident].
-					      length))) {
-						retval = false;	/*  bad parameter(s) */
-						dev_dbg(&ced->interface->dev,
-							"%s: bad param - id %d, bUsed %d, offset %d, size %d, area length %d\n",
-							__func__, ident,
-							ced->trans_def[ident].
-							used,
-							dma_desc->offset,
-							dma_desc->size,
-							ced->trans_def[ident].
-							length);
-					}
-				}
+			retval =
+			    ced_read_huff(&(dma_desc->offset), buf,
+				     &n_done, count)
+			    && ced_read_huff(&(dma_desc->size), buf,
+					&n_done, count);
+
+			if (!retval)
 				break;
+
+			dev_dbg(&ced->interface->dev,
+				"%s: xfer offset & size %d %d\n",
+				__func__, dma_desc->offset,
+				dma_desc->size);
+
+			/* Illegal area number, or... */
+			if ((ident >= MAX_TRANSAREAS) ||
+			    /* area not set up, or... */
+			    (!ced->trans_def[ident].used) ||
+			    /* range/size */
+			    (dma_desc->offset > ced->trans_def[ident].length) ||
+			    ((dma_desc->offset + dma_desc->size) >
+			     (ced->trans_def[ident].length))) {
+				retval = false;	/* bad parameter(s) */
+				dev_dbg(&ced->interface->dev,
+					"%s: bad param - id %d, bUsed %d, offset %d, size %d, area length %d\n",
+					__func__, ident,
+					ced->trans_def[ident].
+					used,
+					dma_desc->offset,
+					dma_desc->size,
+					ced->trans_def[ident].
+					length);
 			}
+
+			break;
+
 		default:
 			break;
 		}
@@ -1175,7 +1222,8 @@ static int ced_handle_esc(struct ced_data *ced, char *ch,
 						__func__, trans_type);
 			}
 		} else		/*  Failed to read parameters */
-			dev_err(&ced->interface->dev, "%s: ced_read_dma_info() fail\n",
+			dev_err(&ced->interface->dev,
+				"%s: ced_read_dma_info() fail\n",
 				__func__);
 
 		spin_unlock(&ced->staged_lock);	/*  OK here */
@@ -1231,6 +1279,7 @@ static void ced_readchar_callback(struct urb *urb)
 
 			if (got > 0) {
 				unsigned int i;
+
 				if (got < INBUF_SZ) {
 					/* tidy the string */
 					ced->coher_char_in[got] = 0;
@@ -1249,7 +1298,8 @@ static void ced_readchar_callback(struct urb *urb)
 				}
 
 				if ((ced->num_input + got) <= INBUF_SZ)
-				       /* Adjust the buffer count accordingly */
+					/* Adjust the buffer count */
+					/* accordingly		   */
 					ced->num_input += got;
 			} else
 				dev_dbg(&ced->interface->dev, "%s: read ZLP\n",
@@ -1339,6 +1389,7 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	int err = 0;
 	struct ced_data *ced = file->private_data;
+
 	if (!can_accept_io_requests(ced))	/*  check we still exist */
 		return -ENODEV;
 
@@ -1489,8 +1540,8 @@ static struct usb_class_driver ced_class = {
 	.minor_base = USB_CED_MINOR_BASE,
 };
 
-/*  Check that the device that matches a 1401 vendor and product ID is OK to use and */
-/*  initialise our struct ced_data. */
+/* Check that the device that matches a 1401 vendor and product ID is OK to */
+/* use and initialise our struct ced_data.				    */
 static int ced_probe(struct usb_interface *interface,
 		     const struct usb_device_id *id)
 {
@@ -1505,12 +1556,12 @@ static int ced_probe(struct usb_interface *interface,
 	if (!ced)
 		goto error;
 
-	for (i = 0; i < MAX_TRANSAREAS; ++i) {	/*  Initialise the wait queues */
+	for (i = 0; i < MAX_TRANSAREAS; ++i) { /* Initialise the wait queues */
 		init_waitqueue_head(&ced->trans_def[i].event);
 	}
 
-	/*  Put initialises for our stuff here. Note that all of *ced is zero, so */
-	/*  no need to explicitly zero it. */
+	/* Put initialises for our stuff here. Note that all of *ced is */
+	/* zero, so no need to explicitly zero it.			*/
 	spin_lock_init(&ced->char_out_lock);
 	spin_lock_init(&ced->char_in_lock);
 	spin_lock_init(&ced->staged_lock);
@@ -1532,12 +1583,14 @@ static int ced_probe(struct usb_interface *interface,
 	else if ((i >= 1) && (i <= 23))
 		ced->type = i + 2;
 	else {
-		dev_err(&interface->dev, "%s: Unknown device. bcdDevice = %d\n",
-			__func__, bcdDevice);
+		dev_err(&interface->dev,
+			"%s: Unknown device. bcdDevice = %d\n",
+			__func__,
+			bcdDevice);
 		goto error;
 	}
-	/*  set up the endpoint information. We only care about the number of EP as */
-	/*  we know that we are dealing with a 1401 device. */
+	/* set up the endpoint information. We only care about the number of */
+	/* EP as we know that we are dealing with a 1401 device.	     */
 	iface_desc = interface->cur_altsetting;
 	ced->n_pipes = iface_desc->desc.bNumEndpoints;
 	dev_info(&interface->dev, "1401Type=%d with %d End Points\n",
@@ -1546,9 +1599,14 @@ static int ced_probe(struct usb_interface *interface,
 		goto error;
 
 	/*  Allocate the URBs we hold for performing transfers */
-	ced->urb_char_out = usb_alloc_urb(0, GFP_KERNEL);	/*  character output URB */
-	ced->urb_char_in = usb_alloc_urb(0, GFP_KERNEL);	/*  character input URB */
-	ced->staged_urb = usb_alloc_urb(0, GFP_KERNEL);	/*  block transfer URB */
+
+	 /* character output URB */
+	ced->urb_char_out = usb_alloc_urb(0, GFP_KERNEL);
+	/* character input URB */
+	ced->urb_char_in = usb_alloc_urb(0, GFP_KERNEL);
+	/* block transfer URB */
+	ced->staged_urb = usb_alloc_urb(0, GFP_KERNEL);
+
 	if (!ced->urb_char_out || !ced->urb_char_in || !ced->staged_urb) {
 		dev_err(&interface->dev, "%s: URB alloc failed\n", __func__);
 		goto error;
@@ -1575,7 +1633,9 @@ static int ced_probe(struct usb_interface *interface,
 		ced->ep_addr[i] = endpoint->bEndpointAddress;
 		dev_info(&interface->dev, "Pipe %d, ep address %02x\n",
 			 i, ced->ep_addr[i]);
-		if (((ced->n_pipes == 3) && (i == 0)) ||	/*  if char input end point */
+
+		 /* if char input end point */
+		if (((ced->n_pipes == 3) && (i == 0)) ||
 		    ((ced->n_pipes == 4) && (i == 1))) {
 			/* save the endpoint interrupt interval */
 			ced->interval = endpoint->bInterval;
@@ -1583,7 +1643,7 @@ static int ced_probe(struct usb_interface *interface,
 				 i, ced->interval);
 		}
 		/*  Detect USB2 by checking last ep size (64 if USB1) */
-		if (i == ced->n_pipes - 1) {	/*  if this is the last ep (bulk) */
+		if (i == ced->n_pipes - 1) { /* if this is the last ep (bulk) */
 			ced->is_usb2 =
 			    le16_to_cpu(endpoint->wMaxPacketSize) > 64;
 			dev_info(&ced->interface->dev, "USB%d\n",
@@ -1612,7 +1672,7 @@ static int ced_probe(struct usb_interface *interface,
 
 error:
 	if (ced)
-		kref_put(&ced->kref, ced_delete);	/*  frees allocated memory */
+		kref_put(&ced->kref, ced_delete); /* frees allocated memory */
 	return retval;
 }
 
@@ -1622,15 +1682,21 @@ static void ced_disconnect(struct usb_interface *interface)
 	int minor = interface->minor;
 	int i;
 
-	usb_set_intfdata(interface, NULL);	/*  remove the ced from the interface */
-	usb_deregister_dev(interface, &ced_class);	/*  give back our minor device number */
+	 /* remove the ced from the interface */
+	usb_set_intfdata(interface, NULL);
+
+	 /* give back our minor device number */
+	usb_deregister_dev(interface, &ced_class);
 
 	mutex_lock(&ced->io_mutex);	/*  stop more I/O starting while... */
 	ced_draw_down(ced);	/*  ...wait for then kill any io */
 	for (i = 0; i < MAX_TRANSAREAS; ++i) {
-		int err = ced_clear_area(ced, i);	/*  ...release any used memory */
+		/* ...release any used memory */
+		int err = ced_clear_area(ced, i);
+
 		if (err == U14ERR_UNLOCKFAIL)
-			dev_err(&ced->interface->dev, "%s: Area %d was in used\n",
+			dev_err(&ced->interface->dev,
+				"%s: Area %d was in used\n",
 				__func__, i);
 	}
 	ced->interface = NULL;	/*  ...we kill off link to interface */
@@ -1650,6 +1716,7 @@ static void ced_disconnect(struct usb_interface *interface)
 void ced_draw_down(struct ced_data *ced)
 {
 	int time;
+
 	dev_dbg(&ced->interface->dev, "%s: called\n", __func__);
 
 	ced->in_draw_down = true;
@@ -1664,6 +1731,7 @@ void ced_draw_down(struct ced_data *ced)
 static int ced_suspend(struct usb_interface *intf, pm_message_t message)
 {
 	struct ced_data *ced = usb_get_intfdata(intf);
+
 	if (!ced)
 		return 0;
 	ced_draw_down(ced);
@@ -1675,6 +1743,7 @@ static int ced_suspend(struct usb_interface *intf, pm_message_t message)
 static int ced_resume(struct usb_interface *intf)
 {
 	struct ced_data *ced = usb_get_intfdata(intf);
+
 	if (!ced)
 		return 0;
 	dev_dbg(&ced->interface->dev, "%s: called\n", __func__);
@@ -1684,6 +1753,7 @@ static int ced_resume(struct usb_interface *intf)
 static int ced_pre_reset(struct usb_interface *intf)
 {
 	struct ced_data *ced = usb_get_intfdata(intf);
+
 	dev_dbg(&ced->interface->dev, "%s\n", __func__);
 	mutex_lock(&ced->io_mutex);
 	ced_draw_down(ced);
@@ -1693,6 +1763,7 @@ static int ced_pre_reset(struct usb_interface *intf)
 static int ced_post_reset(struct usb_interface *intf)
 {
 	struct ced_data *ced = usb_get_intfdata(intf);
+
 	dev_dbg(&ced->interface->dev, "%s\n", __func__);
 
 	/* we are sure no URBs are active - no locking needed */
-- 
1.7.10.4

_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel




[Index of Archives]     [Linux Driver Backports]     [DMA Engine]     [Linux GPIO]     [Linux SPI]     [Video for Linux]     [Linux USB Devel]     [Linux Coverity]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux