Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752039AbbDXAjD (ORCPT ); Thu, 23 Apr 2015 20:39:03 -0400 Received: from mail-pd0-f173.google.com ([209.85.192.173]:33084 "EHLO mail-pd0-f173.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751701AbbDXAi4 (ORCPT ); Thu, 23 Apr 2015 20:38:56 -0400 From: Jason Eastman To: gregkh@linuxfoundation.org Cc: hofrat@osadl.org, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, Jason Eastman Subject: [PATCH] usb: image: mdc800: fixed various style issues Date: Thu, 23 Apr 2015 17:59:01 -0600 Message-Id: <1429833541-21717-1-git-send-email-eastman.jason.linux@gmail.com> X-Mailer: git-send-email 1.7.10.4 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 34214 Lines: 1275 Fixed several style issues with: comments, function perenthesis, indentation, and conditional braces Signed-off-by: Jason Eastman --- 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 * (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 who + * Thanks to Oliver Neukum 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 (iio_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"); - -- 1.7.10.4 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/