Re: [PATCH] usb: image: mdc800: fixed various style issues

[Varka Bhadram <varkabhadram@gmail.com>]

On 04/24/2015 05:29 AM, Jason Eastman wrote:
> Fixed several style issues with: comments, function perenthesis,
> indentation, and conditional braces
>
> Signed-off-by: Jason Eastman <eastman.jason.linux@gmail.com>
> ---
>  drivers/usb/image/mdc800.c |  769 +++++++++++++++++++-------------------------
>  1 file changed, 336 insertions(+), 433 deletions(-)
>
> diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
> index 5cf2633..c9b9ec0 100644
> --- a/drivers/usb/image/mdc800.c
> +++ b/drivers/usb/image/mdc800.c
> @@ -29,19 +29,19 @@
>   * mknod /dev/mustek c 180 32
>   *
>   * The driver supports only one camera.
> - * 
> + *
>   * Fix: mdc800 used sleep_on and slept with io_lock held.
>   * Converted sleep_on to waitqueues with schedule_timeout and made io_lock
>   * a semaphore from a spinlock.
>   * by Oliver Neukum <oliver@neukum.name>
>   * (02/12/2001)
> - * 
> + *
>   * Identify version on module load.
>   * (08/04/2001) gb
>   *
>   * version 0.7.5
>   * Fixed potential SMP races with Spinlocks.
> - * Thanks to Oliver Neukum <oliver@neukum.name> who 
> + * Thanks to Oliver Neukum <oliver@neukum.name> who
>   * noticed the race conditions.
>   * (30/10/2000)
>   *
> @@ -108,7 +108,7 @@
>  #define DRIVER_DESC "USB Driver for Mustek MDC800 Digital Camera"
>  
>  /* Vendor and Product Information */
> -#define MDC800_VENDOR_ID 	0x055f
> +#define MDC800_VENDOR_ID	0x055f
>  #define MDC800_PRODUCT_ID	0xa800
>  
>  /* Timeouts (msec) */
> @@ -116,7 +116,7 @@
>  #define TO_DOWNLOAD_GET_BUSY		1500
>  #define TO_WRITE_GET_READY		1000
>  #define TO_DEFAULT_COMMAND		5000
> -#define TO_READ_FROM_IRQ 		TO_DEFAULT_COMMAND
> +#define TO_READ_FROM_IRQ		TO_DEFAULT_COMMAND
>  #define TO_GET_READY			TO_DEFAULT_COMMAND
>  
>  /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
> @@ -134,124 +134,119 @@ typedef enum {
>  
>  
>  /* Data for the driver */
> -struct mdc800_data
> -{
> -	struct usb_device *	dev;			// Device Data
> -	mdc800_state 		state;
> +struct mdc800_data {
> +	struct usb_device	*dev;			/* Device Data */
> +	mdc800_state		state;
>  
>  	unsigned int		endpoint [4];
>  
> -	struct urb *		irq_urb;
> +	struct urb		*irq_urb;
>  	wait_queue_head_t	irq_wait;
>  	int			irq_woken;
> -	char*			irq_urb_buffer;
> +	char			*irq_urb_buffer;
>  
> -	int			camera_busy;          // is camera busy ?
> -	int 			camera_request_ready; // Status to synchronize with irq
> -	char 			camera_response [8];  // last Bytes send after busy
> +	int			camera_busy;          /* is camera busy ? */
> +	int			camera_request_ready; /* Status to synchronize with irq */
> +	char			camera_response[8];  /* last Bytes send after busy */
>  
> -	struct urb *   		write_urb;
> -	char*			write_urb_buffer;
> +	struct urb		*write_urb;
> +	char			*write_urb_buffer;
>  	wait_queue_head_t	write_wait;
>  	int			written;
>  
>  
> -	struct urb *   		download_urb;
> -	char*			download_urb_buffer;
> +	struct urb		*download_urb;
> +	char			*download_urb_buffer;
>  	wait_queue_head_t	download_wait;
>  	int			downloaded;
> -	int			download_left;		// Bytes left to download ?
> +	int			download_left;		/* Bytes left to download ? */
>  
>  
>  	/* Device Data */
> -	char			out [64];	// Answer Buffer
> -	int 			out_ptr;	// Index to the first not readen byte
> -	int			out_count;	// Bytes in the buffer
> +	char			out[64];	/* Answer Buffer */
> +	int			out_ptr;	/* Index to the first not readen byte */
> +	int			out_count;	/* Bytes in the buffer */
>  
> -	int			open;		// Camera device open ?
> -	struct mutex		io_lock;	// IO -lock
> +	int			open;		/* Camera device open ? */
> +	struct mutex		io_lock;	/* IO -lock */
>  
> -	char 			in [8];		// Command Input Buffer
> -	int  			in_count;
> +	char			in[8];		/* Command Input Buffer */
> +	int			in_count;
>  
> -	int			pic_index;	// Cache for the Imagesize (-1 for nothing cached )
> +	int			pic_index;	/* Cache for the Imagesize (-1 for nothing cached ) */
>  	int			pic_len;
>  	int			minor;
>  };
>  
>  
>  /* Specification of the Endpoints */
> -static struct usb_endpoint_descriptor mdc800_ed [4] =
> -{
> -	{ 
> -		.bLength = 		0,
> +static struct usb_endpoint_descriptor mdc800_ed[4] = {
> +	{
> +		.bLength =		0,
>  		.bDescriptorType =	0,
>  		.bEndpointAddress =	0x01,
> -		.bmAttributes = 	0x02,
> +		.bmAttributes =		0x02,
>  		.wMaxPacketSize =	cpu_to_le16(8),
> -		.bInterval = 		0,
> -		.bRefresh = 		0,
> -		.bSynchAddress = 	0,
> +		.bInterval =		0,
> +		.bRefresh =		0,
> +		.bSynchAddress =	0,
>  	},
>  	{
> -		.bLength = 		0,
> -		.bDescriptorType = 	0,
> -		.bEndpointAddress = 	0x82,
> -		.bmAttributes = 	0x03,
> -		.wMaxPacketSize = 	cpu_to_le16(8),
> -		.bInterval = 		0,
> -		.bRefresh = 		0,
> -		.bSynchAddress = 	0,
> +		.bLength =		0,
> +		.bDescriptorType =	0,
> +		.bEndpointAddress =	0x82,
> +		.bmAttributes =		0x03,
> +		.wMaxPacketSize =	cpu_to_le16(8),
> +		.bInterval =		0,
> +		.bRefresh =		0,
> +		.bSynchAddress =	0,
>  	},
>  	{
> -		.bLength = 		0,
> -		.bDescriptorType = 	0,
> -		.bEndpointAddress = 	0x03,
> -		.bmAttributes = 	0x02,
> -		.wMaxPacketSize = 	cpu_to_le16(64),
> -		.bInterval = 		0,
> -		.bRefresh = 		0,
> -		.bSynchAddress = 	0,
> +		.bLength =		0,
> +		.bDescriptorType =	0,
> +		.bEndpointAddress =	0x03,
> +		.bmAttributes =		0x02,
> +		.wMaxPacketSize =	cpu_to_le16(64),
> +		.bInterval =		0,
> +		.bRefresh =		0,
> +		.bSynchAddress =	0,
>  	},
>  	{
> -		.bLength = 		0,
> -		.bDescriptorType = 	0,
> -		.bEndpointAddress = 	0x84,
> -		.bmAttributes = 	0x02,
> -		.wMaxPacketSize = 	cpu_to_le16(64),
> -		.bInterval = 		0,
> -		.bRefresh = 		0,
> -		.bSynchAddress = 	0,
> +		.bLength =		0,
> +		.bDescriptorType =	0,
> +		.bEndpointAddress =	0x84,
> +		.bmAttributes =		0x02,
> +		.wMaxPacketSize =	cpu_to_le16(64),
> +		.bInterval =		0,
> +		.bRefresh =		0,
> +		.bSynchAddress =	0,
>  	},
>  };
>  
>  /* The Variable used by the driver */
> -static struct mdc800_data* mdc800;
> +static struct mdc800_data *mdc800;
>  
>  
>  /***************************************************************************
>  	The USB Part of the driver
>  ****************************************************************************/
>  
> -static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
> +static int mdc800_endpoint_equals(struct usb_endpoint_descriptor *a, struct usb_endpoint_descriptor *b)
>  {
>  	return (
> -		   ( a->bEndpointAddress == b->bEndpointAddress )
> -		&& ( a->bmAttributes     == b->bmAttributes     )
> -		&& ( a->wMaxPacketSize   == b->wMaxPacketSize   )
> +		   (a->bEndpointAddress == b->bEndpointAddress)
> +		&& (a->bmAttributes     == b->bmAttributes)
> +		&& (a->wMaxPacketSize   == b->wMaxPacketSize)
>  	);
>  }
>  
> -
> -/*
> - * Checks whether the camera responds busy
> - */
> -static int mdc800_isBusy (char* ch)
> +/* Checks whether the camera responds busy */
> +static int mdc800_isBusy(char *ch)
>  {
> -	int i=0;
> -	while (i<8)
> -	{
> -		if (ch [i] != (char)0x99)
> +	int i = 0;
> +
> +	while (i < 8) {
> +		if (ch[i] != (char)0x99)
>  			return 0;
>  		i++;
>  	}
> @@ -259,15 +254,13 @@ static int mdc800_isBusy (char* ch)
>  }
>  
>  
> -/*
> - * Checks whether the Camera is ready
> - */
> -static int mdc800_isReady (char *ch)
> +/* Checks whether the Camera is ready */
> +static int mdc800_isReady(char *ch)
>  {
> -	int i=0;
> -	while (i<8)
> -	{
> -		if (ch [i] != (char)0xbb)
> +	int i = 0;
> +
> +	while (i < 8) {
> +		if (ch[i] != (char)0xbb)
>  			return 0;
>  		i++;
>  	}
> @@ -276,44 +269,36 @@ static int mdc800_isReady (char *ch)
>  
>  
>  
> -/*
> - * USB IRQ Handler for InputLine
> - */
> -static void mdc800_usb_irq (struct urb *urb)
> +/* USB IRQ Handler for InputLine */
> +static void mdc800_usb_irq(struct urb *urb)
>  {
> -	int data_received=0, wake_up;
> -	unsigned char* b=urb->transfer_buffer;
> -	struct mdc800_data* mdc800=urb->context;
> +	int data_received = 0, wake_up;
> +	unsigned char *b = urb->transfer_buffer;
> +	struct mdc800_data *mdc800 = urb->context;
>  	struct device *dev = &mdc800->dev->dev;
>  	int status = urb->status;
>  
>  	if (status >= 0) {
> -		if (mdc800_isBusy (b))
> -		{
> -			if (!mdc800->camera_busy)
> -			{
> -				mdc800->camera_busy=1;
> +		if (mdc800_isBusy(b)) {
> +			if (!mdc800->camera_busy) {
> +				mdc800->camera_busy = 1;
>  				dev_dbg(dev, "gets busy\n");
>  			}
> -		}
> -		else
> -		{
> -			if (mdc800->camera_busy && mdc800_isReady (b))
> -			{
> -				mdc800->camera_busy=0;
> +		} else {
> +			if (mdc800->camera_busy && mdc800_isReady(b)) {
> +				mdc800->camera_busy = 0;
>  				dev_dbg(dev, "gets ready\n");
>  			}
>  		}
> -		if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
> -		{
> +		if (!(mdc800_isBusy(b) || mdc800_isReady(b))) {
>  			/* Store Data in camera_answer field */
> -			dev_dbg(dev, "%i %i %i %i %i %i %i %i \n",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7]);
> +			dev_dbg(dev, "%i %i %i %i %i %i %i %i\n", b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
>  
> -			memcpy (mdc800->camera_response,b,8);
> -			data_received=1;
> +			memcpy(mdc800->camera_response, b, 8);
> +			data_received = 1;
>  		}
>  	}
> -	wake_up= ( mdc800->camera_request_ready > 0 )
> +	wake_up = (mdc800->camera_request_ready > 0)
>  		&&
>  		(
>  			((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
> @@ -325,93 +310,82 @@ static void mdc800_usb_irq (struct urb *urb)
>  			(status < 0)
>  		);
>  
> -	if (wake_up)
> -	{
> -		mdc800->camera_request_ready=0;
> -		mdc800->irq_woken=1;
> -		wake_up (&mdc800->irq_wait);
> +	if (wake_up) {
> +		mdc800->camera_request_ready = 0;
> +		mdc800->irq_woken = 1;
> +		wake_up(&mdc800->irq_wait);
>  	}
>  }
>  
>  
> -/*
> - * Waits a while until the irq responds that camera is ready
> - *
> - *  mode : 0: Wait for camera gets ready
> - *         1: Wait for receiving data
> - *         2: Wait for camera gets busy
> - *
> - * msec: Time to wait
> - */
> -static int mdc800_usb_waitForIRQ (int mode, int msec)
> +/* Waits a while until the irq responds that camera is ready
> +
> +	mode : 0: Wait for camera gets ready
> +		1: Wait for receiving data
> +		2: Wait for camera gets busy
> +
> +	msec: Time to wait   */
> +
> +static int mdc800_usb_waitForIRQ(int mode, int msec)
>  {
> -	mdc800->camera_request_ready=1+mode;
> +	mdc800->camera_request_ready = 1+mode;
>  
>  	wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken,
>  			   msecs_to_jiffies(msec));
>  	mdc800->irq_woken = 0;
>  
> -	if (mdc800->camera_request_ready>0)
> -	{
> -		mdc800->camera_request_ready=0;
> +	if (mdc800->camera_request_ready > 0) {
> +		mdc800->camera_request_ready = 0;
>  		dev_err(&mdc800->dev->dev, "timeout waiting for camera.\n");
>  		return -1;
>  	}
> -	
> -	if (mdc800->state == NOT_CONNECTED)
> -	{
> -		printk(KERN_WARNING "mdc800: Camera gets disconnected "
> -		       "during waiting for irq.\n");
> -		mdc800->camera_request_ready=0;
> +
> +	if (mdc800->state == NOT_CONNECTED) {
> +		printk(KERN_WARNING "mdc800: Camera gets disconnected during waiting for irq.\n");
> +		mdc800->camera_request_ready = 0;
>  		return -2;
>  	}
> -	
> +
>  	return 0;
>  }
>  
>  
> -/*
> - * The write_urb callback function
> - */
> -static void mdc800_usb_write_notify (struct urb *urb)
> +/* The write_urb callback function */
> +static void mdc800_usb_write_notify(struct urb *urb)
>  {
> -	struct mdc800_data* mdc800=urb->context;
> +	struct mdc800_data *mdc800 = urb->context;
>  	int status = urb->status;
>  
>  	if (status != 0)
>  		dev_err(&mdc800->dev->dev,
>  			"writing command fails (status=%i)\n", status);
>  	else
> -		mdc800->state=READY;
> +		mdc800->state = READY;
>  	mdc800->written = 1;
> -	wake_up (&mdc800->write_wait);
> +	wake_up(&mdc800->write_wait);
>  }
>  
>  
> -/*
> - * The download_urb callback function
> - */
> -static void mdc800_usb_download_notify (struct urb *urb)
> +/* The download_urb callback function */
> +static void mdc800_usb_download_notify(struct urb *urb)
>  {
> -	struct mdc800_data* mdc800=urb->context;
> +	struct mdc800_data *mdc800 = urb->context;
>  	int status = urb->status;
>  
>  	if (status == 0) {
>  		/* Fill output buffer with these data */
> -		memcpy (mdc800->out,  urb->transfer_buffer, 64);
> -		mdc800->out_count=64;
> -		mdc800->out_ptr=0;
> -		mdc800->download_left-=64;
> +		memcpy(mdc800->out,  urb->transfer_buffer, 64);
> +		mdc800->out_count = 64;
> +		mdc800->out_ptr = 0;
> +		mdc800->download_left -= 64;
>  		if (mdc800->download_left == 0)
> -		{
> -			mdc800->state=READY;
> -		}
> +			mdc800->state = READY;
>  	} else {
>  		dev_err(&mdc800->dev->dev,
>  			"request bytes fails (status:%i)\n", status);
>  	}
>  	mdc800->downloaded = 1;
> -	wake_up (&mdc800->download_wait);
> +	wake_up(&mdc800->download_wait);
>  }
>  
>  
> @@ -428,29 +402,25 @@ static struct usb_class_driver mdc800_class = {
>  };
>  
>  
> -/*
> - * Callback to search the Mustek MDC800 on the USB Bus
> - */
> -static int mdc800_usb_probe (struct usb_interface *intf,
> +/* Callback to search the Mustek MDC800 on the USB Bus */
> +static int mdc800_usb_probe(struct usb_interface *intf,
>  			       const struct usb_device_id *id)
>  {
> -	int i,j;
> +	int i, j;
>  	struct usb_host_interface *intf_desc;
> -	struct usb_device *dev = interface_to_usbdev (intf);
> -	int irq_interval=0;
> +	struct usb_device *dev = interface_to_usbdev(intf);
> +	int irq_interval = 0;
>  	int retval;
>  
>  	dev_dbg(&intf->dev, "(%s) called.\n", __func__);
>  
>  
> -	if (mdc800->dev != NULL)
> -	{
> +	if (mdc800->dev != NULL) {
>  		dev_warn(&intf->dev, "only one Mustek MDC800 is supported.\n");
>  		return -ENODEV;
>  	}
>  
> -	if (dev->descriptor.bNumConfigurations != 1)
> -	{
> +	if (dev->descriptor.bNumConfigurations != 1) {
>  		dev_err(&intf->dev,
>  			"probe fails -> wrong Number of Configuration\n");
>  		return -ENODEV;
> @@ -458,33 +428,26 @@ static int mdc800_usb_probe (struct usb_interface *intf,
>  	intf_desc = intf->cur_altsetting;
>  
>  	if (
> -			( intf_desc->desc.bInterfaceClass != 0xff )
> -		||	( intf_desc->desc.bInterfaceSubClass != 0 )
> -		|| ( intf_desc->desc.bInterfaceProtocol != 0 )
> -		|| ( intf_desc->desc.bNumEndpoints != 4)
> -	)
> -	{
> +			(intf_desc->desc.bInterfaceClass != 0xff)
> +		||	(intf_desc->desc.bInterfaceSubClass != 0)
> +		|| (intf_desc->desc.bInterfaceProtocol != 0)
> +		|| (intf_desc->desc.bNumEndpoints != 4)
> +	) {
>  		dev_err(&intf->dev, "probe fails -> wrong Interface\n");
>  		return -ENODEV;
>  	}
>  
>  	/* Check the Endpoints */
> -	for (i=0; i<4; i++)
> -	{
> -		mdc800->endpoint[i]=-1;
> -		for (j=0; j<4; j++)
> -		{
> -			if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
> -			{
> -				mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
> -				if (i==1)
> -				{
> -					irq_interval=intf_desc->endpoint [j].desc.bInterval;
> -				}
> +	for (i = 0; i < 4; i++)	{
> +		mdc800->endpoint[i] = -1;
> +		for (j = 0; j < 4; j++)	{
> +			if (mdc800_endpoint_equals(&intf_desc->endpoint[j].desc, &mdc800_ed[i])) {
> +				mdc800->endpoint[i] = intf_desc->endpoint[j].desc.bEndpointAddress;
> +				if (i == 1)
> +					irq_interval = intf_desc->endpoint [j].desc.bInterval;
>  			}
>  		}
> -		if (mdc800->endpoint[i] == -1)
> -		{
> +		if (mdc800->endpoint[i] == -1) {
>  			dev_err(&intf->dev, "probe fails -> Wrong Endpoints.\n");
>  			return -ENODEV;
>  		}
> @@ -502,14 +465,14 @@ static int mdc800_usb_probe (struct usb_interface *intf,
>  		return -ENODEV;
>  	}
>  
> -	mdc800->dev=dev;
> -	mdc800->open=0;
> +	mdc800->dev = dev;
> +	mdc800->open = 0;
>  
>  	/* Setup URB Structs */
> -	usb_fill_int_urb (
> +	usb_fill_int_urb(
>  		mdc800->irq_urb,
>  		mdc800->dev,
> -		usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
> +		usb_rcvintpipe(mdc800->dev, mdc800->endpoint[1]),
>  		mdc800->irq_urb_buffer,
>  		8,
>  		mdc800_usb_irq,
> @@ -517,41 +480,39 @@ static int mdc800_usb_probe (struct usb_interface *intf,
>  		irq_interval
>  	);
>  
> -	usb_fill_bulk_urb (
> +	usb_fill_bulk_urb(
>  		mdc800->write_urb,
>  		mdc800->dev,
> -		usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
> +		usb_sndbulkpipe(mdc800->dev, mdc800->endpoint[0]),
>  		mdc800->write_urb_buffer,
>  		8,
>  		mdc800_usb_write_notify,
>  		mdc800
>  	);
>  
> -	usb_fill_bulk_urb (
> +	usb_fill_bulk_urb(
>  		mdc800->download_urb,
>  		mdc800->dev,
> -		usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
> +		usb_rcvbulkpipe(mdc800->dev, mdc800->endpoint[3]),
>  		mdc800->download_urb_buffer,
>  		64,
>  		mdc800_usb_download_notify,
>  		mdc800
>  	);
>  
> -	mdc800->state=READY;
> +	mdc800->state = READY;
>  
>  	mutex_unlock(&mdc800->io_lock);
> -	
> +
>  	usb_set_intfdata(intf, mdc800);
>  	return 0;
>  }
>  
>  
> -/*
> - * Disconnect USB device (maybe the MDC800)
> - */
> -static void mdc800_usb_disconnect (struct usb_interface *intf)
> +/* Disconnect USB device (maybe the MDC800) */
> +static void mdc800_usb_disconnect(struct usb_interface *intf)
>  {
> -	struct mdc800_data* mdc800 = usb_get_intfdata(intf);
> +	struct mdc800_data *mdc800 = usb_get_intfdata(intf);
>  
>  	dev_dbg(&intf->dev, "(%s) called\n", __func__);
>  
> @@ -564,7 +525,7 @@ static void mdc800_usb_disconnect (struct usb_interface *intf)
>  		/* must be under lock to make sure no URB
>  		   is submitted after usb_kill_urb() */
>  		mutex_lock(&mdc800->io_lock);
> -		mdc800->state=NOT_CONNECTED;
> +		mdc800->state = NOT_CONNECTED;
>  
>  		usb_kill_urb(mdc800->irq_urb);
>  		usb_kill_urb(mdc800->write_urb);
> @@ -582,71 +543,64 @@ static void mdc800_usb_disconnect (struct usb_interface *intf)
>  	The Misc device Part (file_operations)
>  ****************************************************************************/
>  
> -/*
> - * This Function calc the Answersize for a command.
> - */
> -static int mdc800_getAnswerSize (char command)
> +/* This Function calc the Answersize for a command. */
> +static int mdc800_getAnswerSize(char command)
>  {
> -	switch ((unsigned char) command)
> -	{
> -		case 0x2a:
> -		case 0x49:
> -		case 0x51:
> -		case 0x0d:
> -		case 0x20:
> -		case 0x07:
> -		case 0x01:
> -		case 0x25:
> -		case 0x00:
> -			return 8;
> -
> -		case 0x05:
> -		case 0x3e:
> -			return mdc800->pic_len;
> -
> -		case 0x09:
> -			return 4096;
> -
> -		default:
> -			return 0;
> +	switch ((unsigned char) command) {
> +	case 0x2a:
> +	case 0x49:
> +	case 0x51:
> +	case 0x0d:
> +	case 0x20:
> +	case 0x07:
> +	case 0x01:
> +	case 0x25:
> +	case 0x00:
> +		return 8;
> +
> +	case 0x05:
> +	case 0x3e:
> +		return mdc800->pic_len;
> +
> +	case 0x09:
> +		return 4096;
> +
> +	default:
> +		return 0;
>  	}
>  }
>  
>  
> -/*
> - * Init the device: (1) alloc mem (2) Increase MOD Count ..
> - */
> -static int mdc800_device_open (struct inode* inode, struct file *file)
> +/* Init the device: (1) alloc mem (2) Increase MOD Count .. */
> +static int mdc800_device_open(struct inode *inode, struct file *file)
>  {
> -	int retval=0;
> -	int errn=0;
> +	int retval = 0;
> +	int errn = 0;
>  
>  	mutex_lock(&mdc800->io_lock);
> -	
> -	if (mdc800->state == NOT_CONNECTED)
> -	{
> -		errn=-EBUSY;
> +
> +	if (mdc800->state == NOT_CONNECTED) {
> +		errn = -EBUSY;
>  		goto error_out;
>  	}
> -	if (mdc800->open)
> -	{
> -		errn=-EBUSY;
> +	if (mdc800->open) {
> +		errn = -EBUSY;
>  		goto error_out;
>  	}
>  
> -	mdc800->in_count=0;
> -	mdc800->out_count=0;
> -	mdc800->out_ptr=0;
> -	mdc800->pic_index=0;
> -	mdc800->pic_len=-1;
> -	mdc800->download_left=0;
> +	mdc800->in_count = 0;
> +	mdc800->out_count = 0;
> +	mdc800->out_ptr = 0;
> +	mdc800->pic_index = 0;
> +	mdc800->pic_len = -1;
> +	mdc800->download_left = 0;
>  
> -	mdc800->camera_busy=0;
> -	mdc800->camera_request_ready=0;
> +	mdc800->camera_busy = 0;
> +	mdc800->camera_request_ready = 0;
>  
> -	retval=0;
> +	retval = 0;
>  	mdc800->irq_urb->dev = mdc800->dev;
> -	retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
> +	retval = usb_submit_urb(mdc800->irq_urb, GFP_KERNEL);
>  	if (retval) {
>  		dev_err(&mdc800->dev->dev,
>  			"request USB irq fails (submit_retval=%i).\n", retval);
> @@ -654,7 +608,7 @@ static int mdc800_device_open (struct inode* inode, struct file *file)
>  		goto error_out;
>  	}
>  
> -	mdc800->open=1;
> +	mdc800->open = 1;
>  	dev_dbg(&mdc800->dev->dev, "Mustek MDC800 device opened.\n");
>  
>  error_out:
> @@ -663,24 +617,19 @@ error_out:
>  }
>  
>  
> -/*
> - * Close the Camera and release Memory
> - */
> -static int mdc800_device_release (struct inode* inode, struct file *file)
> +/* Close the Camera and release Memory */
> +static int mdc800_device_release(struct inode *inode, struct file *file)
>  {
> -	int retval=0;
> +	int retval = 0;
>  
>  	mutex_lock(&mdc800->io_lock);
> -	if (mdc800->open && (mdc800->state != NOT_CONNECTED))
> -	{
> +	if (mdc800->open && (mdc800->state != NOT_CONNECTED)) {
>  		usb_kill_urb(mdc800->irq_urb);
>  		usb_kill_urb(mdc800->write_urb);
>  		usb_kill_urb(mdc800->download_urb);
> -		mdc800->open=0;
> -	}
> -	else
> -	{
> -		retval=-EIO;
> +		mdc800->open = 0;
> +	} else {
> +		retval = -EIO;
>  	}
>  
>  	mutex_unlock(&mdc800->io_lock);
> @@ -688,59 +637,48 @@ static int mdc800_device_release (struct inode* inode, struct file *file)
>  }
>  
>  
> -/*
> - * The Device read callback Function
> - */
> -static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
> +/* The Device read callback Function */
> +static ssize_t mdc800_device_read(struct file *file, char __user *buf, size_t len, loff_t *pos)
>  {
> -	size_t left=len, sts=len; /* single transfer size */
> +	size_t left = len, sts = len; /* single transfer size */
>  	char __user *ptr = buf;
>  	int retval;
>  
>  	mutex_lock(&mdc800->io_lock);
> -	if (mdc800->state == NOT_CONNECTED)
> -	{
> +	if (mdc800->state == NOT_CONNECTED) {
>  		mutex_unlock(&mdc800->io_lock);
>  		return -EBUSY;
>  	}
> -	if (mdc800->state == WORKING)
> -	{
> -		printk(KERN_WARNING "mdc800: Illegal State \"working\""
> -		       "reached during read ?!\n");
> +	if (mdc800->state == WORKING) {
> +		printk(KERN_WARNING "mdc800: Illegal State \"working\" reached during read ?!\n");
>  		mutex_unlock(&mdc800->io_lock);
>  		return -EBUSY;
>  	}
> -	if (!mdc800->open)
> -	{
> +	if (!mdc800->open) {
>  		mutex_unlock(&mdc800->io_lock);
>  		return -EBUSY;
>  	}
>  
> -	while (left)
> -	{
> -		if (signal_pending (current)) 
> -		{
> +	while (left) {
> +		if (signal_pending(current)) {
>  			mutex_unlock(&mdc800->io_lock);
>  			return -EINTR;
>  		}
>  
> -		sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
> +		sts = left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
>  
> -		if (sts <= 0)
> -		{
> +		if (sts <= 0) {
>  			/* Too less Data in buffer */
> -			if (mdc800->state == DOWNLOAD)
> -			{
> -				mdc800->out_count=0;
> -				mdc800->out_ptr=0;
> +			if (mdc800->state == DOWNLOAD) {
> +				mdc800->out_count = 0;
> +				mdc800->out_ptr = 0;
>  
>  				/* Download -> Request new bytes */
>  				mdc800->download_urb->dev = mdc800->dev;
> -				retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
> +				retval = usb_submit_urb(mdc800->download_urb, GFP_KERNEL);
>  				if (retval) {
>  					dev_err(&mdc800->dev->dev,
> -						"Can't submit download urb "
> -						"(retval=%i)\n", retval);
> +						"Can't submit download urb (retval=%i)\n", retval);
>  					mutex_unlock(&mdc800->io_lock);
>  					return len-left;
>  				}
> @@ -748,34 +686,28 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
>  				     mdc800->downloaded,
>  				     msecs_to_jiffies(TO_DOWNLOAD_GET_READY));
>  				mdc800->downloaded = 0;
> -				if (mdc800->download_urb->status != 0)
> -				{
> +				if (mdc800->download_urb->status != 0) {
>  					dev_err(&mdc800->dev->dev,
> -						"request download-bytes fails "
> -						"(status=%i)\n",
> +						"request download-bytes fails (status=%i)\n",
>  						mdc800->download_urb->status);
>  					mutex_unlock(&mdc800->io_lock);
>  					return len-left;
>  				}
> -			}
> -			else
> -			{
> +			} else {
>  				/* No more bytes -> that's an error*/
>  				mutex_unlock(&mdc800->io_lock);
>  				return -EIO;
>  			}
> -		}
> -		else
> -		{
> +		} else {
>  			/* Copy Bytes */
> -			if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
> +			if (copy_to_user(ptr, &mdc800->out[mdc800->out_ptr],
>  						sts)) {
>  				mutex_unlock(&mdc800->io_lock);
>  				return -EFAULT;
>  			}
> -			ptr+=sts;
> -			left-=sts;
> -			mdc800->out_ptr+=sts;
> +			ptr += sts;
> +			left -= sts;
> +			mdc800->out_ptr += sts;
>  		}
>  	}
>  
> @@ -784,164 +716,141 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
>  }
>  
>  
> -/*
> - * The Device write callback Function
> - * If a 8Byte Command is received, it will be send to the camera.
> - * After this the driver initiates the request for the answer or
> - * just waits until the camera becomes ready.
> - */
> -static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
> +/* The Device write callback Function
> +   If a 8Byte Command is received, it will be send to the camera.
> +   After this the driver initiates the request for the answer or
> +   just waits until the camera becomes ready. */
> +static ssize_t mdc800_device_write(struct file *file, const char __user *buf, size_t len, loff_t *pos)
>  {
> -	size_t i=0;
> +	size_t i = 0;
>  	int retval;
>  
>  	mutex_lock(&mdc800->io_lock);
> -	if (mdc800->state != READY)
> -	{
> +	if (mdc800->state != READY) {
>  		mutex_unlock(&mdc800->io_lock);
>  		return -EBUSY;
>  	}
> -	if (!mdc800->open )
> -	{
> +	if (!mdc800->open) {
>  		mutex_unlock(&mdc800->io_lock);
>  		return -EBUSY;
>  	}
>  
> -	while (i<len)
> -	{
> +	while (i < len) {
>  		unsigned char c;
> -		if (signal_pending (current)) 
> -		{
> +
> +		if (signal_pending(current)) {
>  			mutex_unlock(&mdc800->io_lock);
>  			return -EINTR;
>  		}
> -		
> -		if(get_user(c, buf+i))
> -		{
> +
> +		if (get_user(c, buf+i)) {
>  			mutex_unlock(&mdc800->io_lock);
>  			return -EFAULT;
>  		}
>  
>  		/* check for command start */
> -		if (c == 0x55)
> -		{
> -			mdc800->in_count=0;
> -			mdc800->out_count=0;
> -			mdc800->out_ptr=0;
> -			mdc800->download_left=0;
> +		if (c == 0x55) {
> +			mdc800->in_count = 0;
> +			mdc800->out_count = 0;
> +			mdc800->out_ptr = 0;
> +			mdc800->download_left = 0;
>  		}
>  
>  		/* save command byte */
> -		if (mdc800->in_count < 8)
> -		{
> +		if (mdc800->in_count < 8) {
>  			mdc800->in[mdc800->in_count] = c;
>  			mdc800->in_count++;
> -		}
> -		else
> -		{
> +		} else {
>  			mutex_unlock(&mdc800->io_lock);
>  			return -EIO;
>  		}
>  
>  		/* Command Buffer full ? -> send it to camera */
> -		if (mdc800->in_count == 8)
> -		{
> +		if (mdc800->in_count == 8) {
>  			int answersize;
>  
> -			if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
> -			{
> +			if (mdc800_usb_waitForIRQ(0, TO_GET_READY)) {
>  				dev_err(&mdc800->dev->dev,
>  					"Camera didn't get ready.\n");
>  				mutex_unlock(&mdc800->io_lock);
>  				return -EIO;
>  			}
>  
> -			answersize=mdc800_getAnswerSize (mdc800->in[1]);
> +			answersize = mdc800_getAnswerSize(mdc800->in[1]);
>  
> -			mdc800->state=WORKING;
> -			memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
> +			mdc800->state = WORKING;
> +			memcpy(mdc800->write_urb->transfer_buffer, mdc800->in, 8);
>  			mdc800->write_urb->dev = mdc800->dev;
> -			retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
> +			retval = usb_submit_urb(mdc800->write_urb, GFP_KERNEL);
>  			if (retval) {
>  				dev_err(&mdc800->dev->dev,
> -					"submitting write urb fails "
> -					"(retval=%i)\n", retval);
> +					"submitting write urb fails (retval=%i)\n", retval);
>  				mutex_unlock(&mdc800->io_lock);
>  				return -EIO;
>  			}
>  			wait_event_timeout(mdc800->write_wait, mdc800->written,
>  					msecs_to_jiffies(TO_WRITE_GET_READY));
>  			mdc800->written = 0;
> -			if (mdc800->state == WORKING)
> -			{
> +			if (mdc800->state == WORKING) {
>  				usb_kill_urb(mdc800->write_urb);
>  				mutex_unlock(&mdc800->io_lock);
>  				return -EIO;
>  			}
>  
> -			switch ((unsigned char) mdc800->in[1])
> -			{
> -				case 0x05: /* Download Image */
> -				case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
> -					if (mdc800->pic_len < 0)
> -					{
> -						dev_err(&mdc800->dev->dev,
> -							"call 0x07 before "
> -							"0x05,0x3e\n");
> -						mdc800->state=READY;
> -						mutex_unlock(&mdc800->io_lock);
> -						return -EIO;
> -					}
> -					mdc800->pic_len=-1;
> -
> -				case 0x09: /* Download Thumbnail */
> -					mdc800->download_left=answersize+64;
> -					mdc800->state=DOWNLOAD;
> -					mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
> -					break;
> +			switch ((unsigned char) mdc800->in[1]) {
> +			case 0x05: /* Download Image */
> +			case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
> +				if (mdc800->pic_len < 0) {
> +					dev_err(&mdc800->dev->dev,
> +						"call 0x07 before 0x05,0x3e\n");
> +					mdc800->state = READY;
> +					mutex_unlock(&mdc800->io_lock);
> +					return -EIO;
> +				}
> +				mdc800->pic_len = -1;
>  
> +			case 0x09: /* Download Thumbnail */
> +				mdc800->download_left = answersize+64;
> +				mdc800->state = DOWNLOAD;
> +				mdc800_usb_waitForIRQ(0, TO_DOWNLOAD_GET_BUSY);
> +				break;
>  
> -				default:
> -					if (answersize)
> -					{
>  
> -						if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
> -						{
> -							dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
> -							mutex_unlock(&mdc800->io_lock);
> -							return -EIO;
> -						}
> +			default:
> +				if (answersize) {
>  
> -						/* Write dummy data, (this is ugly but part of the USB Protocol */
> -						/* if you use endpoint 1 as bulk and not as irq) */
> -						memcpy (mdc800->out, mdc800->camera_response,8);
> +					if (mdc800_usb_waitForIRQ(1, TO_READ_FROM_IRQ)) {
> +						dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
> +						mutex_unlock(&mdc800->io_lock);
> +						return -EIO;
> +					}
>  
> -						/* This is the interpreted answer */
> -						memcpy (&mdc800->out[8], mdc800->camera_response,8);
> +					/* Write dummy data, (this is ugly but part of the USB Protocol */
> +					/* if you use endpoint 1 as bulk and not as irq) */
> +					memcpy(mdc800->out, mdc800->camera_response, 8);
>  
> -						mdc800->out_ptr=0;
> -						mdc800->out_count=16;
> +					/* This is the interpreted answer */
> +					memcpy(&mdc800->out[8], mdc800->camera_response, 8);
>  
> -						/* Cache the Imagesize, if command was getImageSize */
> -						if (mdc800->in [1] == (char) 0x07)
> -						{
> -							mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
> +					mdc800->out_ptr = 0;
> +					mdc800->out_count = 16;
>  
> -							dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
> -						}
> +					/* Cache the Imagesize, if command was getImageSize */
> +					if (mdc800->in[1] == (char) 0x07) {
> +						mdc800->pic_len = (int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
>  
> +						dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
>  					}
> -					else
> -					{
> -						if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
> -						{
> -							dev_err(&mdc800->dev->dev, "Command Timeout.\n");
> -							mutex_unlock(&mdc800->io_lock);
> -							return -EIO;
> -						}
> +
> +				} else {
> +					if (mdc800_usb_waitForIRQ(0, TO_DEFAULT_COMMAND)) {
> +						dev_err(&mdc800->dev->dev, "Command Timeout.\n");
> +						mutex_unlock(&mdc800->io_lock);
> +						return -EIO;
>  					}
> -					mdc800->state=READY;
> -					break;
> +				}
> +				mdc800->state = READY;
> +				break;
>  			}
>  		}
>  		i++;
> @@ -956,8 +865,7 @@ static ssize_t mdc800_device_write (struct file *file, const char __user *buf, s
>  ****************************************************************************/
>  
>  /* File Operations of this drivers */
> -static const struct file_operations mdc800_device_ops =
> -{
> +static const struct file_operations mdc800_device_ops = {
>  	.owner =	THIS_MODULE,
>  	.read =		mdc800_device_read,
>  	.write =	mdc800_device_write,
> @@ -973,12 +881,9 @@ static const struct usb_device_id mdc800_table[] = {
>  	{ }						/* Terminating entry */
>  };
>  
> -MODULE_DEVICE_TABLE (usb, mdc800_table);
> -/*
> - * USB Driver Struct for this device
> - */
> -static struct usb_driver mdc800_usb_driver =
> -{
> +MODULE_DEVICE_TABLE(usb, mdc800_table);
> +/* USB Driver Struct for this device */
> +static struct usb_driver mdc800_usb_driver = {
>  	.name =		"mdc800",
>  	.probe =	mdc800_usb_probe,
>  	.disconnect =	mdc800_usb_disconnect,
> @@ -991,43 +896,43 @@ static struct usb_driver mdc800_usb_driver =
>  	Init and Cleanup this driver (Main Functions)
>  *************************************************************************/
>  
> -static int __init usb_mdc800_init (void)
> +static int __init usb_mdc800_init(void)
>  {
>  	int retval = -ENODEV;
>  	/* Allocate Memory */
> -	mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
> +	mdc800 = kzalloc(sizeof(struct mdc800_data), GFP_KERNEL);
>  	if (!mdc800)
>  		goto cleanup_on_fail;
>  
>  	mdc800->dev = NULL;
> -	mdc800->state=NOT_CONNECTED;
> -	mutex_init (&mdc800->io_lock);
> +	mdc800->state = NOT_CONNECTED;
> +	mutex_init(&mdc800->io_lock);
>  
> -	init_waitqueue_head (&mdc800->irq_wait);
> -	init_waitqueue_head (&mdc800->write_wait);
> -	init_waitqueue_head (&mdc800->download_wait);
> +	init_waitqueue_head(&mdc800->irq_wait);
> +	init_waitqueue_head(&mdc800->write_wait);
> +	init_waitqueue_head(&mdc800->download_wait);
>  
>  	mdc800->irq_woken = 0;
>  	mdc800->downloaded = 0;
>  	mdc800->written = 0;
>  
> -	mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
> +	mdc800->irq_urb_buffer = kmalloc(8, GFP_KERNEL);
>  	if (!mdc800->irq_urb_buffer)
>  		goto cleanup_on_fail;
> -	mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
> +	mdc800->write_urb_buffer = kmalloc(8, GFP_KERNEL);
>  	if (!mdc800->write_urb_buffer)
>  		goto cleanup_on_fail;
> -	mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
> +	mdc800->download_urb_buffer = kmalloc(64, GFP_KERNEL);
>  	if (!mdc800->download_urb_buffer)
>  		goto cleanup_on_fail;
>  
> -	mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
> +	mdc800->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
>  	if (!mdc800->irq_urb)
>  		goto cleanup_on_fail;
> -	mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
> +	mdc800->download_urb = usb_alloc_urb(0, GFP_KERNEL);
>  	if (!mdc800->download_urb)
>  		goto cleanup_on_fail;
> -	mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
> +	mdc800->write_urb = usb_alloc_urb(0, GFP_KERNEL);
>  	if (!mdc800->write_urb)
>  		goto cleanup_on_fail;
>  
> @@ -1045,8 +950,7 @@ static int __init usb_mdc800_init (void)
>  
>  cleanup_on_fail:
>  
> -	if (mdc800 != NULL)
> -	{
> +	if (mdc800 != NULL) {
>  		printk(KERN_ERR "mdc800: can't alloc memory!\n");
>  
>  		kfree(mdc800->download_urb_buffer);
> @@ -1057,33 +961,32 @@ cleanup_on_fail:
>  		usb_free_urb(mdc800->download_urb);
>  		usb_free_urb(mdc800->irq_urb);
>  
> -		kfree (mdc800);
> +		kfree(mdc800);
>  	}
>  	mdc800 = NULL;
>  	return retval;
>  }
>  
>  
> -static void __exit usb_mdc800_cleanup (void)
> +static void __exit usb_mdc800_cleanup(void)
>  {
> -	usb_deregister (&mdc800_usb_driver);
> +	usb_deregister(&mdc800_usb_driver);
>  
> -	usb_free_urb (mdc800->irq_urb);
> -	usb_free_urb (mdc800->download_urb);
> -	usb_free_urb (mdc800->write_urb);
> +	usb_free_urb(mdc800->irq_urb);
> +	usb_free_urb(mdc800->download_urb);
> +	usb_free_urb(mdc800->write_urb);
>  
> -	kfree (mdc800->irq_urb_buffer);
> -	kfree (mdc800->write_urb_buffer);
> -	kfree (mdc800->download_urb_buffer);
> +	kfree(mdc800->irq_urb_buffer);
> +	kfree(mdc800->write_urb_buffer);
> +	kfree(mdc800->download_urb_buffer);
>  
> -	kfree (mdc800);
> +	kfree(mdc800);
>  	mdc800 = NULL;
>  }
>  
> -module_init (usb_mdc800_init);
> -module_exit (usb_mdc800_cleanup);
> +module_init(usb_mdc800_init);
> +module_exit(usb_mdc800_cleanup);
>  
> -MODULE_AUTHOR( DRIVER_AUTHOR );
> -MODULE_DESCRIPTION( DRIVER_DESC );
> +MODULE_AUTHOR(DRIVER_AUTHOR);
> +MODULE_DESCRIPTION(DRIVER_DESC);
>  MODULE_LICENSE("GPL");
> -

Ran checkpatch on this.

Result:

total: 0 errors, 28 warnings, 1231 lines checked

0001-usb-image-mdc800-fixed-various-style-issues.patch has style problems, please review.

Thanks

-- 
Varka Bhadram