+usb/usb-gadget-rndis-fix-up-coding-style-issues-in-the-file.patch

+usb/drivers-usb-ftdi-elan-sema.patch

+

+From tglx@linutronix.de Tue Sep 7 19:17:28 2010

+From: Thomas Gleixner <tglx@linutronix.de>

+Date: Tue, 07 Sep 2010 14:32:43 -0000

+Subject: usb: ftdi-elan: Convert "mutex" to semaphore

+Cc: Andrew Morton <akpm@linux-foundation.org>, Ingo Molnar <mingo@elte.hu>, Peter Zijlstra <peterz@infradead.org>, Christoph Hellwig <hch@infradead.org>, Greg Kroah-Hartman <gregkh@suse.de>, linux-usb@vger.kernel.org

+Message-ID: <20100907125055.947634394@linutronix.de>

+Content-Disposition: inline; filename=drivers-usb-ftdi-elan-sema.patch

+

+

+The "mutex" ftdi->sw_lock is used as a lock and a completion. Convert

+it to a real semaphore which allows both.

+

+Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

+

+---

+ drivers/usb/misc/ftdi-elan.c | 2 +-

+ 1 file changed, 1 insertion(+), 1 deletion(-)

+

+--- a/drivers/usb/misc/ftdi-elan.c

++++ b/drivers/usb/misc/ftdi-elan.c

+@@ -2769,7 +2769,7 @@ static int ftdi_elan_probe(struct usb_in

+ ftdi->sequence_num = ++ftdi_instances;

+ mutex_unlock(&ftdi_module_lock);

+ ftdi_elan_init_kref(ftdi);

+- init_MUTEX(&ftdi->sw_lock);

++ sema_init(&ftdi->sw_lock, 1);

+ ftdi->udev = usb_get_dev(interface_to_usbdev(interface));

+ ftdi->interface = interface;

+ mutex_init(&ftdi->u132_lock);

+From mihai.dontu@gmail.com Tue Sep 7 19:16:11 2010

+From: Mihai Donțu <mihai.dontu@gmail.com>

+Date: Wed, 8 Sep 2010 02:54:02 +0300

+Subject: USB: gadget: rndis: fix up coding style issues in the file

+To: Greg KH <gregkh@suse.de>

+Cc: "Gadiyar, Anand" <gadiyar@ti.com>, Maxim Osipov <maxim.osipov@gmail.com>, Sergei Shtylyov <sshtylyov@mvista.com>, David Brownell <dbrownell@users.sourceforge.net>, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org

+Message-ID: <201009080254.03070.mihai.dontu@gmail.com>

+

+Corrected the coding style.

+

+Signed-off-by: Mihai Dontu <mihai.dontu@gmail.com>

+Cc: David Brownell <dbrownell@users.sourceforge.net>

+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

+

+---

+ drivers/usb/gadget/rndis.c | 494 ++++++++++++++++++++++-----------------------

+ 1 file changed, 245 insertions(+), 249 deletions(-)

+

+--- a/drivers/usb/gadget/rndis.c

++++ b/drivers/usb/gadget/rndis.c

+@@ -61,17 +61,17 @@ MODULE_PARM_DESC (rndis_debug, "enable d

+ #define RNDIS_MAX_CONFIGS 1

+

+

+-static rndis_params rndis_per_dev_params [RNDIS_MAX_CONFIGS];

++static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS];

+

+ /* Driver Version */

+-static const __le32 rndis_driver_version = cpu_to_le32 (1);

++static const __le32 rndis_driver_version = cpu_to_le32(1);

+

+ /* Function Prototypes */

+-static rndis_resp_t *rndis_add_response (int configNr, u32 length);

++static rndis_resp_t *rndis_add_response(int configNr, u32 length);

+

+

+ /* supported OIDs */

+-static const u32 oid_supported_list [] =

++static const u32 oid_supported_list[] =

+ {

+ /* the general stuff */

+ OID_GEN_SUPPORTED_LIST,

+@@ -161,21 +161,20 @@ static const u32 oid_supported_list [] =

+

+

+ /* NDIS Functions */

+-static int

+-gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,

+- rndis_resp_t *r)

+-{

+- int retval = -ENOTSUPP;

+- u32 length = 4; /* usually */

+- __le32 *outbuf;

+- int i, count;

+- rndis_query_cmplt_type *resp;

+- struct net_device *net;

++static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf,

++ unsigned buf_len, rndis_resp_t *r)

++{

++ int retval = -ENOTSUPP;

++ u32 length = 4; /* usually */

++ __le32 *outbuf;

++ int i, count;

++ rndis_query_cmplt_type *resp;

++ struct net_device *net;

+ struct rtnl_link_stats64 temp;

+ const struct rtnl_link_stats64 *stats;

+

+ if (!r) return -ENOMEM;

+- resp = (rndis_query_cmplt_type *) r->buf;

++ resp = (rndis_query_cmplt_type *)r->buf;

+

+ if (!resp) return -ENOMEM;

+

+@@ -191,8 +190,8 @@ gen_ndis_query_resp (int configNr, u32 O

+ }

+

+ /* response goes here, right after the header */

+- outbuf = (__le32 *) &resp[1];

+- resp->InformationBufferOffset = cpu_to_le32 (16);

++ outbuf = (__le32 *)&resp[1];

++ resp->InformationBufferOffset = cpu_to_le32(16);

+

+ net = rndis_per_dev_params[configNr].dev;

+ stats = dev_get_stats(net, &temp);

+@@ -204,10 +203,10 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_GEN_SUPPORTED_LIST:

+ pr_debug("%s: OID_GEN_SUPPORTED_LIST\n", __func__);

+- length = sizeof (oid_supported_list);

+- count = length / sizeof (u32);

++ length = sizeof(oid_supported_list);

++ count = length / sizeof(u32);

+ for (i = 0; i < count; i++)

+- outbuf[i] = cpu_to_le32 (oid_supported_list[i]);

++ outbuf[i] = cpu_to_le32(oid_supported_list[i]);

+ retval = 0;

+ break;

+

+@@ -220,14 +219,14 @@ gen_ndis_query_resp (int configNr, u32 O

+ * reddite ergo quae sunt Caesaris Caesari

+ * et quae sunt Dei Deo!

+ */

+- *outbuf = cpu_to_le32 (0);

++ *outbuf = cpu_to_le32(0);

+ retval = 0;

+ break;

+

+ /* mandatory */

+ case OID_GEN_MEDIA_SUPPORTED:

+ pr_debug("%s: OID_GEN_MEDIA_SUPPORTED\n", __func__);

+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);

++ *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);

+ retval = 0;

+ break;

+

+@@ -235,16 +234,16 @@ gen_ndis_query_resp (int configNr, u32 O

+ case OID_GEN_MEDIA_IN_USE:

+ pr_debug("%s: OID_GEN_MEDIA_IN_USE\n", __func__);

+ /* one medium, one transport... (maybe you do it better) */

+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);

++ *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);

+ retval = 0;

+ break;

+

+ /* mandatory */

+ case OID_GEN_MAXIMUM_FRAME_SIZE:

+ pr_debug("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__);

+- if (rndis_per_dev_params [configNr].dev) {

+- *outbuf = cpu_to_le32 (

+- rndis_per_dev_params [configNr].dev->mtu);

++ if (rndis_per_dev_params[configNr].dev) {

++ *outbuf = cpu_to_le32(

++ rndis_per_dev_params[configNr].dev->mtu);

+ retval = 0;

+ }

+ break;

+@@ -253,21 +252,21 @@ gen_ndis_query_resp (int configNr, u32 O

+ case OID_GEN_LINK_SPEED:

+ if (rndis_debug > 1)

+ pr_debug("%s: OID_GEN_LINK_SPEED\n", __func__);

+- if (rndis_per_dev_params [configNr].media_state

++ if (rndis_per_dev_params[configNr].media_state

+ == NDIS_MEDIA_STATE_DISCONNECTED)

+- *outbuf = cpu_to_le32 (0);

++ *outbuf = cpu_to_le32(0);

+ else

+- *outbuf = cpu_to_le32 (

+- rndis_per_dev_params [configNr].speed);

++ *outbuf = cpu_to_le32(

++ rndis_per_dev_params[configNr].speed);

+ retval = 0;

+ break;

+

+ /* mandatory */

+ case OID_GEN_TRANSMIT_BLOCK_SIZE:

+ pr_debug("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__);

+- if (rndis_per_dev_params [configNr].dev) {

+- *outbuf = cpu_to_le32 (

+- rndis_per_dev_params [configNr].dev->mtu);

++ if (rndis_per_dev_params[configNr].dev) {

++ *outbuf = cpu_to_le32(

++ rndis_per_dev_params[configNr].dev->mtu);

+ retval = 0;

+ }

+ break;

+@@ -275,9 +274,9 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_GEN_RECEIVE_BLOCK_SIZE:

+ pr_debug("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__);

+- if (rndis_per_dev_params [configNr].dev) {

+- *outbuf = cpu_to_le32 (

+- rndis_per_dev_params [configNr].dev->mtu);

++ if (rndis_per_dev_params[configNr].dev) {

++ *outbuf = cpu_to_le32(

++ rndis_per_dev_params[configNr].dev->mtu);

+ retval = 0;

+ }

+ break;

+@@ -285,18 +284,20 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_GEN_VENDOR_ID:

+ pr_debug("%s: OID_GEN_VENDOR_ID\n", __func__);

+- *outbuf = cpu_to_le32 (

+- rndis_per_dev_params [configNr].vendorID);

++ *outbuf = cpu_to_le32(

++ rndis_per_dev_params[configNr].vendorID);

+ retval = 0;

+ break;

+

+ /* mandatory */

+ case OID_GEN_VENDOR_DESCRIPTION:

+ pr_debug("%s: OID_GEN_VENDOR_DESCRIPTION\n", __func__);

+- if ( rndis_per_dev_params [configNr].vendorDescr ) {

+- length = strlen (rndis_per_dev_params [configNr].vendorDescr);

+- memcpy (outbuf,

+- rndis_per_dev_params [configNr].vendorDescr, length);

++ if (rndis_per_dev_params[configNr].vendorDescr) {

++ length = strlen(rndis_per_dev_params[configNr].

++ vendorDescr);

++ memcpy(outbuf,

++ rndis_per_dev_params[configNr].vendorDescr,

++ length);

+ } else {

+ outbuf[0] = 0;

+ }

+@@ -313,7 +314,7 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_GEN_CURRENT_PACKET_FILTER:

+ pr_debug("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);

+- *outbuf = cpu_to_le32 (*rndis_per_dev_params[configNr].filter);

++ *outbuf = cpu_to_le32(*rndis_per_dev_params[configNr].filter);

+ retval = 0;

+ break;

+

+@@ -328,14 +329,14 @@ gen_ndis_query_resp (int configNr, u32 O

+ case OID_GEN_MEDIA_CONNECT_STATUS:

+ if (rndis_debug > 1)

+ pr_debug("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);

+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]

++ *outbuf = cpu_to_le32(rndis_per_dev_params[configNr]

+ .media_state);

+ retval = 0;

+ break;

+

+ case OID_GEN_PHYSICAL_MEDIUM:

+ pr_debug("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);

+- *outbuf = cpu_to_le32 (0);

++ *outbuf = cpu_to_le32(0);

+ retval = 0;

+ break;

+

+@@ -409,10 +410,10 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_802_3_PERMANENT_ADDRESS:

+ pr_debug("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);

+- if (rndis_per_dev_params [configNr].dev) {

++ if (rndis_per_dev_params[configNr].dev) {

+ length = ETH_ALEN;

+- memcpy (outbuf,

+- rndis_per_dev_params [configNr].host_mac,

++ memcpy(outbuf,

++ rndis_per_dev_params[configNr].host_mac,

+ length);

+ retval = 0;

+ }

+@@ -421,9 +422,9 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_802_3_CURRENT_ADDRESS:

+ pr_debug("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);

+- if (rndis_per_dev_params [configNr].dev) {

++ if (rndis_per_dev_params[configNr].dev) {

+ length = ETH_ALEN;

+- memcpy (outbuf,

++ memcpy(outbuf,

+ rndis_per_dev_params [configNr].host_mac,

+ length);

+ retval = 0;

+@@ -434,7 +435,7 @@ gen_ndis_query_resp (int configNr, u32 O

+ case OID_802_3_MULTICAST_LIST:

+ pr_debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);

+ /* Multicast base address only */

+- *outbuf = cpu_to_le32 (0xE0000000);

++ *outbuf = cpu_to_le32(0xE0000000);

+ retval = 0;

+ break;

+

+@@ -442,7 +443,7 @@ gen_ndis_query_resp (int configNr, u32 O

+ case OID_802_3_MAXIMUM_LIST_SIZE:

+ pr_debug("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);

+ /* Multicast base address only */

+- *outbuf = cpu_to_le32 (1);

++ *outbuf = cpu_to_le32(1);

+ retval = 0;

+ break;

+

+@@ -466,14 +467,14 @@ gen_ndis_query_resp (int configNr, u32 O

+ /* mandatory */

+ case OID_802_3_XMIT_ONE_COLLISION:

+ pr_debug("%s: OID_802_3_XMIT_ONE_COLLISION\n", __func__);

+- *outbuf = cpu_to_le32 (0);

++ *outbuf = cpu_to_le32(0);

+ retval = 0;

+ break;

+

+ /* mandatory */

+ case OID_802_3_XMIT_MORE_COLLISIONS:

+ pr_debug("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __func__);

+- *outbuf = cpu_to_le32 (0);

++ *outbuf = cpu_to_le32(0);

+ retval = 0;

+ break;

+

+@@ -484,22 +485,22 @@ gen_ndis_query_resp (int configNr, u32 O

+ if (retval < 0)

+ length = 0;

+

+- resp->InformationBufferLength = cpu_to_le32 (length);

+- r->length = length + sizeof *resp;

+- resp->MessageLength = cpu_to_le32 (r->length);

++ resp->InformationBufferLength = cpu_to_le32(length);

++ r->length = length + sizeof(*resp);

++ resp->MessageLength = cpu_to_le32(r->length);

+ return retval;

+ }

+

+-static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,

+- rndis_resp_t *r)

++static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len,

++ rndis_resp_t *r)

+ {

+- rndis_set_cmplt_type *resp;

+- int i, retval = -ENOTSUPP;

+- struct rndis_params *params;

++ rndis_set_cmplt_type *resp;

++ int i, retval = -ENOTSUPP;

++ struct rndis_params *params;

+

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_set_cmplt_type *) r->buf;

++ resp = (rndis_set_cmplt_type *)r->buf;

+ if (!resp)

+ return -ENOMEM;

+

+@@ -514,7 +515,7 @@ static int gen_ndis_set_resp (u8 configN

+ }

+ }

+

+- params = &rndis_per_dev_params [configNr];

++ params = &rndis_per_dev_params[configNr];

+ switch (OID) {

+ case OID_GEN_CURRENT_PACKET_FILTER:

+

+@@ -537,11 +538,11 @@ static int gen_ndis_set_resp (u8 configN

+ params->state = RNDIS_DATA_INITIALIZED;

+ netif_carrier_on(params->dev);

+ if (netif_running(params->dev))

+- netif_wake_queue (params->dev);

++ netif_wake_queue(params->dev);

+ } else {

+ params->state = RNDIS_INITIALIZED;

+- netif_carrier_off (params->dev);

+- netif_stop_queue (params->dev);

++ netif_carrier_off(params->dev);

++ netif_stop_queue(params->dev);

+ }

+ break;

+

+@@ -563,48 +564,47 @@ static int gen_ndis_set_resp (u8 configN

+ * Response Functions

+ */

+

+-static int rndis_init_response (int configNr, rndis_init_msg_type *buf)

++static int rndis_init_response(int configNr, rndis_init_msg_type *buf)

+ {

+- rndis_init_cmplt_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ rndis_init_cmplt_type *resp;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+ if (!params->dev)

+ return -ENOTSUPP;

+

+- r = rndis_add_response (configNr, sizeof (rndis_init_cmplt_type));

++ r = rndis_add_response(configNr, sizeof(rndis_init_cmplt_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_init_cmplt_type *) r->buf;

++ resp = (rndis_init_cmplt_type *)r->buf;

+

+- resp->MessageType = cpu_to_le32 (

+- REMOTE_NDIS_INITIALIZE_CMPLT);

+- resp->MessageLength = cpu_to_le32 (52);

++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_INITIALIZE_CMPLT);

++ resp->MessageLength = cpu_to_le32(52);

+ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);

+- resp->MajorVersion = cpu_to_le32 (RNDIS_MAJOR_VERSION);

+- resp->MinorVersion = cpu_to_le32 (RNDIS_MINOR_VERSION);

+- resp->DeviceFlags = cpu_to_le32 (RNDIS_DF_CONNECTIONLESS);

+- resp->Medium = cpu_to_le32 (RNDIS_MEDIUM_802_3);

+- resp->MaxPacketsPerTransfer = cpu_to_le32 (1);

+- resp->MaxTransferSize = cpu_to_le32 (

++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

++ resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION);

++ resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);

++ resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);

++ resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);

++ resp->MaxPacketsPerTransfer = cpu_to_le32(1);

++ resp->MaxTransferSize = cpu_to_le32(

+ params->dev->mtu

+- + sizeof (struct ethhdr)

+- + sizeof (struct rndis_packet_msg_type)

++ + sizeof(struct ethhdr)

++ + sizeof(struct rndis_packet_msg_type)

+ + 22);

+- resp->PacketAlignmentFactor = cpu_to_le32 (0);

+- resp->AFListOffset = cpu_to_le32 (0);

+- resp->AFListSize = cpu_to_le32 (0);

++ resp->PacketAlignmentFactor = cpu_to_le32(0);

++ resp->AFListOffset = cpu_to_le32(0);

++ resp->AFListSize = cpu_to_le32(0);

+

+ params->resp_avail(params->v);

+ return 0;

+ }

+

+-static int rndis_query_response (int configNr, rndis_query_msg_type *buf)

++static int rndis_query_response(int configNr, rndis_query_msg_type *buf)

+ {

+ rndis_query_cmplt_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+ /* pr_debug("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID)); */

+ if (!params->dev)

+@@ -616,47 +616,46 @@ static int rndis_query_response (int con

+ * rndis_query_cmplt_type followed by data.

+ * oid_supported_list is the largest data reply

+ */

+- r = rndis_add_response (configNr,

+- sizeof (oid_supported_list) + sizeof(rndis_query_cmplt_type));

++ r = rndis_add_response(configNr,

++ sizeof(oid_supported_list) + sizeof(rndis_query_cmplt_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_query_cmplt_type *) r->buf;

++ resp = (rndis_query_cmplt_type *)r->buf;

+

+- resp->MessageType = cpu_to_le32 (REMOTE_NDIS_QUERY_CMPLT);

++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_QUERY_CMPLT);

+ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */

+

+- if (gen_ndis_query_resp (configNr, le32_to_cpu (buf->OID),

++ if (gen_ndis_query_resp(configNr, le32_to_cpu(buf->OID),

+ le32_to_cpu(buf->InformationBufferOffset)

+- + 8 + (u8 *) buf,

++ + 8 + (u8 *)buf,

+ le32_to_cpu(buf->InformationBufferLength),

+ r)) {

+ /* OID not supported */

+- resp->Status = cpu_to_le32 (

+- RNDIS_STATUS_NOT_SUPPORTED);

+- resp->MessageLength = cpu_to_le32 (sizeof *resp);

+- resp->InformationBufferLength = cpu_to_le32 (0);

+- resp->InformationBufferOffset = cpu_to_le32 (0);

++ resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);

++ resp->MessageLength = cpu_to_le32(sizeof *resp);

++ resp->InformationBufferLength = cpu_to_le32(0);

++ resp->InformationBufferOffset = cpu_to_le32(0);

+ } else

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);

++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

+

+ params->resp_avail(params->v);

+ return 0;

+ }

+

+-static int rndis_set_response (int configNr, rndis_set_msg_type *buf)

++static int rndis_set_response(int configNr, rndis_set_msg_type *buf)

+ {

+- u32 BufLength, BufOffset;

+- rndis_set_cmplt_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ u32 BufLength, BufOffset;

++ rndis_set_cmplt_type *resp;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+- r = rndis_add_response (configNr, sizeof (rndis_set_cmplt_type));

++ r = rndis_add_response(configNr, sizeof(rndis_set_cmplt_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_set_cmplt_type *) r->buf;

++ resp = (rndis_set_cmplt_type *)r->buf;

+

+- BufLength = le32_to_cpu (buf->InformationBufferLength);

+- BufOffset = le32_to_cpu (buf->InformationBufferOffset);

++ BufLength = le32_to_cpu(buf->InformationBufferLength);

++ BufOffset = le32_to_cpu(buf->InformationBufferOffset);

+

+ #ifdef VERBOSE_DEBUG

+ pr_debug("%s: Length: %d\n", __func__, BufLength);

+@@ -670,59 +669,59 @@ static int rndis_set_response (int confi

+ pr_debug("\n");

+ #endif

+

+- resp->MessageType = cpu_to_le32 (REMOTE_NDIS_SET_CMPLT);

+- resp->MessageLength = cpu_to_le32 (16);

++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_SET_CMPLT);

++ resp->MessageLength = cpu_to_le32(16);

+ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */

+- if (gen_ndis_set_resp (configNr, le32_to_cpu (buf->OID),

+- ((u8 *) buf) + 8 + BufOffset, BufLength, r))

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_NOT_SUPPORTED);

++ if (gen_ndis_set_resp(configNr, le32_to_cpu(buf->OID),

++ ((u8 *)buf) + 8 + BufOffset, BufLength, r))

++ resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);

+ else

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);

++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

+

+ params->resp_avail(params->v);

+ return 0;

+ }

+

+-static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)

++static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf)

+ {

+- rndis_reset_cmplt_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ rndis_reset_cmplt_type *resp;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+- r = rndis_add_response (configNr, sizeof (rndis_reset_cmplt_type));

++ r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_reset_cmplt_type *) r->buf;

++ resp = (rndis_reset_cmplt_type *)r->buf;

+

+- resp->MessageType = cpu_to_le32 (REMOTE_NDIS_RESET_CMPLT);

+- resp->MessageLength = cpu_to_le32 (16);

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);

++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_RESET_CMPLT);

++ resp->MessageLength = cpu_to_le32(16);

++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

+ /* resent information */

+- resp->AddressingReset = cpu_to_le32 (1);

++ resp->AddressingReset = cpu_to_le32(1);

+

+ params->resp_avail(params->v);

+ return 0;

+ }

+

+-static int rndis_keepalive_response (int configNr,

+- rndis_keepalive_msg_type *buf)

++static int rndis_keepalive_response(int configNr,

++ rndis_keepalive_msg_type *buf)

+ {

+- rndis_keepalive_cmplt_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ rndis_keepalive_cmplt_type *resp;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+ /* host "should" check only in RNDIS_DATA_INITIALIZED state */

+

+- r = rndis_add_response (configNr, sizeof (rndis_keepalive_cmplt_type));

++ r = rndis_add_response(configNr, sizeof(rndis_keepalive_cmplt_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_keepalive_cmplt_type *) r->buf;

++ resp = (rndis_keepalive_cmplt_type *)r->buf;

+

+- resp->MessageType = cpu_to_le32 (

++ resp->MessageType = cpu_to_le32(

+ REMOTE_NDIS_KEEPALIVE_CMPLT);

+- resp->MessageLength = cpu_to_le32 (16);

++ resp->MessageLength = cpu_to_le32(16);

+ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */

+- resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);

++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

+

+ params->resp_avail(params->v);

+ return 0;

+@@ -732,86 +731,85 @@ static int rndis_keepalive_response (int

+ /*

+ * Device to Host Comunication

+ */

+-static int rndis_indicate_status_msg (int configNr, u32 status)

++static int rndis_indicate_status_msg(int configNr, u32 status)

+ {

+- rndis_indicate_status_msg_type *resp;

+- rndis_resp_t *r;

+- struct rndis_params *params = rndis_per_dev_params + configNr;

++ rndis_indicate_status_msg_type *resp;

++ rndis_resp_t *r;

++ struct rndis_params *params = rndis_per_dev_params + configNr;

+

+ if (params->state == RNDIS_UNINITIALIZED)

+ return -ENOTSUPP;

+

+- r = rndis_add_response (configNr,

+- sizeof (rndis_indicate_status_msg_type));

++ r = rndis_add_response(configNr,

++ sizeof(rndis_indicate_status_msg_type));

+ if (!r)

+ return -ENOMEM;

+- resp = (rndis_indicate_status_msg_type *) r->buf;

++ resp = (rndis_indicate_status_msg_type *)r->buf;

+

+- resp->MessageType = cpu_to_le32 (

+- REMOTE_NDIS_INDICATE_STATUS_MSG);

+- resp->MessageLength = cpu_to_le32 (20);

+- resp->Status = cpu_to_le32 (status);

+- resp->StatusBufferLength = cpu_to_le32 (0);

+- resp->StatusBufferOffset = cpu_to_le32 (0);

++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_INDICATE_STATUS_MSG);

++ resp->MessageLength = cpu_to_le32(20);

++ resp->Status = cpu_to_le32(status);

++ resp->StatusBufferLength = cpu_to_le32(0);

++ resp->StatusBufferOffset = cpu_to_le32(0);

+

+ params->resp_avail(params->v);

+ return 0;

+ }

+

+-int rndis_signal_connect (int configNr)

++int rndis_signal_connect(int configNr)

+ {

+- rndis_per_dev_params [configNr].media_state

++ rndis_per_dev_params[configNr].media_state

+ = NDIS_MEDIA_STATE_CONNECTED;

+- return rndis_indicate_status_msg (configNr,

++ return rndis_indicate_status_msg(configNr,

+ RNDIS_STATUS_MEDIA_CONNECT);

+ }

+

+-int rndis_signal_disconnect (int configNr)

++int rndis_signal_disconnect(int configNr)

+ {

+- rndis_per_dev_params [configNr].media_state

++ rndis_per_dev_params[configNr].media_state

+ = NDIS_MEDIA_STATE_DISCONNECTED;

+- return rndis_indicate_status_msg (configNr,

++ return rndis_indicate_status_msg(configNr,

+ RNDIS_STATUS_MEDIA_DISCONNECT);

+ }

+

+-void rndis_uninit (int configNr)

++void rndis_uninit(int configNr)

+ {

+ u8 *buf;

+ u32 length;

+

+ if (configNr >= RNDIS_MAX_CONFIGS)

+ return;

+- rndis_per_dev_params [configNr].state = RNDIS_UNINITIALIZED;

++ rndis_per_dev_params[configNr].state = RNDIS_UNINITIALIZED;

+

+ /* drain the response queue */

+ while ((buf = rndis_get_next_response(configNr, &length)))

+ rndis_free_response(configNr, buf);

+ }

+

+-void rndis_set_host_mac (int configNr, const u8 *addr)

++void rndis_set_host_mac(int configNr, const u8 *addr)

+ {

+- rndis_per_dev_params [configNr].host_mac = addr;

++ rndis_per_dev_params[configNr].host_mac = addr;

+ }

+

+ /*

+ * Message Parser

+ */

+-int rndis_msg_parser (u8 configNr, u8 *buf)

++int rndis_msg_parser(u8 configNr, u8 *buf)

+ {

+ u32 MsgType, MsgLength;

+ __le32 *tmp;

+- struct rndis_params *params;

++ struct rndis_params *params;

+

+ if (!buf)

+ return -ENOMEM;

+

+- tmp = (__le32 *) buf;

++ tmp = (__le32 *)buf;

+ MsgType = get_unaligned_le32(tmp++);

+ MsgLength = get_unaligned_le32(tmp++);

+

+ if (configNr >= RNDIS_MAX_CONFIGS)

+ return -ENOTSUPP;

+- params = &rndis_per_dev_params [configNr];

++ params = &rndis_per_dev_params[configNr];

+

+ /* NOTE: RNDIS is *EXTREMELY* chatty ... Windows constantly polls for

+ * rx/tx statistics and link status, in addition to KEEPALIVE traffic

+@@ -822,41 +820,41 @@ int rndis_msg_parser (u8 configNr, u8 *b

+ switch (MsgType) {

+ case REMOTE_NDIS_INITIALIZE_MSG:

+ pr_debug("%s: REMOTE_NDIS_INITIALIZE_MSG\n",

+- __func__ );

++ __func__);

+ params->state = RNDIS_INITIALIZED;

+- return rndis_init_response (configNr,

+- (rndis_init_msg_type *) buf);

++ return rndis_init_response(configNr,

++ (rndis_init_msg_type *)buf);

+

+ case REMOTE_NDIS_HALT_MSG:

+ pr_debug("%s: REMOTE_NDIS_HALT_MSG\n",

+- __func__ );

++ __func__);

+ params->state = RNDIS_UNINITIALIZED;

+ if (params->dev) {

+- netif_carrier_off (params->dev);

+- netif_stop_queue (params->dev);

++ netif_carrier_off(params->dev);

++ netif_stop_queue(params->dev);

+ }

+ return 0;

+

+ case REMOTE_NDIS_QUERY_MSG:

+- return rndis_query_response (configNr,

+- (rndis_query_msg_type *) buf);

++ return rndis_query_response(configNr,

++ (rndis_query_msg_type *)buf);

+

+ case REMOTE_NDIS_SET_MSG:

+- return rndis_set_response (configNr,

+- (rndis_set_msg_type *) buf);

++ return rndis_set_response(configNr,

++ (rndis_set_msg_type *)buf);

+

+ case REMOTE_NDIS_RESET_MSG:

+ pr_debug("%s: REMOTE_NDIS_RESET_MSG\n",

+- __func__ );

+- return rndis_reset_response (configNr,

+- (rndis_reset_msg_type *) buf);

++ __func__);

++ return rndis_reset_response(configNr,

++ (rndis_reset_msg_type *)buf);

+

+ case REMOTE_NDIS_KEEPALIVE_MSG:

+ /* For USB: host does this every 5 seconds */

+ if (rndis_debug > 1)

+ pr_debug("%s: REMOTE_NDIS_KEEPALIVE_MSG\n",

+- __func__ );

+- return rndis_keepalive_response (configNr,

++ __func__);

++ return rndis_keepalive_response(configNr,

+ (rndis_keepalive_msg_type *)

+ buf);

+

+@@ -866,7 +864,7 @@ int rndis_msg_parser (u8 configNr, u8 *b

+ * suspending itself.

+ */

+ pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",

+- __func__ , MsgType, MsgLength);

++ __func__, MsgType, MsgLength);

+ {

+ unsigned i;

+ for (i = 0; i < MsgLength; i += 16) {

+@@ -901,10 +899,10 @@ int rndis_register(void (*resp_avail)(vo

+ return -EINVAL;

+

+ for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {

+- if (!rndis_per_dev_params [i].used) {

+- rndis_per_dev_params [i].used = 1;

+- rndis_per_dev_params [i].resp_avail = resp_avail;

+- rndis_per_dev_params [i].v = v;

++ if (!rndis_per_dev_params[i].used) {

++ rndis_per_dev_params[i].used = 1;

++ rndis_per_dev_params[i].resp_avail = resp_avail;

++ rndis_per_dev_params[i].v = v;

+ pr_debug("%s: configNr = %d\n", __func__, i);

+ return i;

+ }

+@@ -914,12 +912,12 @@ int rndis_register(void (*resp_avail)(vo

+ return -ENODEV;

+ }

+

+-void rndis_deregister (int configNr)

++void rndis_deregister(int configNr)

+ {

+- pr_debug("%s: \n", __func__);

++ pr_debug("%s:\n", __func__);

+

+ if (configNr >= RNDIS_MAX_CONFIGS) return;

+- rndis_per_dev_params [configNr].used = 0;

++ rndis_per_dev_params[configNr].used = 0;

+

+ return;

+ }

+@@ -931,76 +929,76 @@ int rndis_set_param_dev(u8 configNr, str

+ return -EINVAL;

+ if (configNr >= RNDIS_MAX_CONFIGS) return -1;

+

+- rndis_per_dev_params [configNr].dev = dev;

+- rndis_per_dev_params [configNr].filter = cdc_filter;

++ rndis_per_dev_params[configNr].dev = dev;

++ rndis_per_dev_params[configNr].filter = cdc_filter;

+

+ return 0;

+ }

+

+-int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr)

++int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)

+ {

+ pr_debug("%s:\n", __func__);

+ if (!vendorDescr) return -1;

+ if (configNr >= RNDIS_MAX_CONFIGS) return -1;

+

+- rndis_per_dev_params [configNr].vendorID = vendorID;

+- rndis_per_dev_params [configNr].vendorDescr = vendorDescr;

++ rndis_per_dev_params[configNr].vendorID = vendorID;

++ rndis_per_dev_params[configNr].vendorDescr = vendorDescr;

+

+ return 0;

+ }

+

+-int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed)

++int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)

+ {

+ pr_debug("%s: %u %u\n", __func__, medium, speed);

+ if (configNr >= RNDIS_MAX_CONFIGS) return -1;

+

+- rndis_per_dev_params [configNr].medium = medium;

+- rndis_per_dev_params [configNr].speed = speed;

++ rndis_per_dev_params[configNr].medium = medium;

++ rndis_per_dev_params[configNr].speed = speed;

+

+ return 0;

+ }

+

+-void rndis_add_hdr (struct sk_buff *skb)

++void rndis_add_hdr(struct sk_buff *skb)

+ {

+- struct rndis_packet_msg_type *header;

++ struct rndis_packet_msg_type *header;

+

+ if (!skb)

+ return;

+- header = (void *) skb_push (skb, sizeof *header);

+- memset (header, 0, sizeof *header);

++ header = (void *)skb_push(skb, sizeof(*header));

++ memset(header, 0, sizeof *header);

+ header->MessageType = cpu_to_le32(REMOTE_NDIS_PACKET_MSG);

+ header->MessageLength = cpu_to_le32(skb->len);

+- header->DataOffset = cpu_to_le32 (36);

+- header->DataLength = cpu_to_le32(skb->len - sizeof *header);

++ header->DataOffset = cpu_to_le32(36);

++ header->DataLength = cpu_to_le32(skb->len - sizeof(*header));

+ }

+

+-void rndis_free_response (int configNr, u8 *buf)

++void rndis_free_response(int configNr, u8 *buf)

+ {

+- rndis_resp_t *r;

+- struct list_head *act, *tmp;

++ rndis_resp_t *r;

++ struct list_head *act, *tmp;

+

+- list_for_each_safe (act, tmp,

+- &(rndis_per_dev_params [configNr].resp_queue))

++ list_for_each_safe(act, tmp,

++ &(rndis_per_dev_params[configNr].resp_queue))

+ {

+- r = list_entry (act, rndis_resp_t, list);

++ r = list_entry(act, rndis_resp_t, list);

+ if (r && r->buf == buf) {

+- list_del (&r->list);

+- kfree (r);

++ list_del(&r->list);

++ kfree(r);

+ }

+ }

+ }

+

+-u8 *rndis_get_next_response (int configNr, u32 *length)

++u8 *rndis_get_next_response(int configNr, u32 *length)

+ {

+- rndis_resp_t *r;

+- struct list_head *act, *tmp;

++ rndis_resp_t *r;

++ struct list_head *act, *tmp;

+

+ if (!length) return NULL;

+

+- list_for_each_safe (act, tmp,

+- &(rndis_per_dev_params [configNr].resp_queue))

++ list_for_each_safe(act, tmp,

++ &(rndis_per_dev_params[configNr].resp_queue))

+ {

+- r = list_entry (act, rndis_resp_t, list);

++ r = list_entry(act, rndis_resp_t, list);

+ if (!r->send) {

+ r->send = 1;

+ *length = r->length;

+@@ -1011,20 +1009,20 @@ u8 *rndis_get_next_response (int configN

+ return NULL;

+ }

+

+-static rndis_resp_t *rndis_add_response (int configNr, u32 length)

++static rndis_resp_t *rndis_add_response(int configNr, u32 length)

+ {

+- rndis_resp_t *r;

++ rndis_resp_t *r;

+

+- /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */

+- r = kmalloc (sizeof (rndis_resp_t) + length, GFP_ATOMIC);

++ /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */

++ r = kmalloc(sizeof(rndis_resp_t) + length, GFP_ATOMIC);

+ if (!r) return NULL;

+

+- r->buf = (u8 *) (r + 1);

++ r->buf = (u8 *)(r + 1);

+ r->length = length;

+ r->send = 0;

+

+- list_add_tail (&r->list,

+- &(rndis_per_dev_params [configNr].resp_queue));

++ list_add_tail(&r->list,

++ &(rndis_per_dev_params[configNr].resp_queue));

+ return r;

+ }

+

+@@ -1033,7 +1031,7 @@ int rndis_rm_hdr(struct gether *port,

+ struct sk_buff_head *list)

+ {

+ /* tmp points to a struct rndis_packet_msg_type */

+- __le32 *tmp = (void *) skb->data;

++ __le32 *tmp = (void *)skb->data;

+

+ /* MessageType, MessageLength */

+ if (cpu_to_le32(REMOTE_NDIS_PACKET_MSG)

+@@ -1054,7 +1052,7 @@ int rndis_rm_hdr(struct gether *port,

+ return 0;

+ }

+

+-#ifdef CONFIG_USB_GADGET_DEBUG_FILES

++#ifdef CONFIG_USB_GADGET_DEBUG_FILES

+

+ static int rndis_proc_show(struct seq_file *m, void *v)

+ {

+@@ -1087,7 +1085,7 @@ static int rndis_proc_show(struct seq_fi

+ }

+

+ static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,

+- size_t count, loff_t *ppos)

++ size_t count, loff_t *ppos)

+ {

+ rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;

+ u32 speed = 0;

+@@ -1109,11 +1107,11 @@ static ssize_t rndis_proc_write(struct f

+ case '8':

+ case '9':

+ fl_speed = 1;

+- speed = speed*10 + c - '0';

++ speed = speed * 10 + c - '0';

+ break;

+ case 'C':

+ case 'c':

+- rndis_signal_connect (p->confignr);

++ rndis_signal_connect(p->confignr);

+ break;

+ case 'D':

+ case 'd':

+@@ -1145,11 +1143,11 @@ static const struct file_operations rndi

+ .write = rndis_proc_write,

+ };

+

+-#define NAME_TEMPLATE "driver/rndis-%03d"

++#define NAME_TEMPLATE "driver/rndis-%03d"

+

+ static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];

+

+-#endif /* CONFIG_USB_GADGET_DEBUG_FILES */

++#endif /* CONFIG_USB_GADGET_DEBUG_FILES */

+

+

+ int rndis_init(void)

+@@ -1160,42 +1158,40 @@ int rndis_init(void)

+ #ifdef CONFIG_USB_GADGET_DEBUG_FILES

+ char name [20];

+

+- sprintf (name, NAME_TEMPLATE, i);

+- if (!(rndis_connect_state [i]

+- = proc_create_data(name, 0660, NULL,

++ sprintf(name, NAME_TEMPLATE, i);

++ rndis_connect_state[i] = proc_create_data(name, 0660, NULL,

+ &rndis_proc_fops,

+- (void *)(rndis_per_dev_params + i))))

+- {

+- pr_debug("%s :remove entries", __func__);

++ (void *)(rndis_per_dev_params + i))

++ if (!rndis_connect_state[i]) {

++ pr_debug("%s: remove entries", __func__);

+ while (i) {

+- sprintf (name, NAME_TEMPLATE, --i);

+- remove_proc_entry (name, NULL);

++ sprintf(name, NAME_TEMPLATE, --i);

++ remove_proc_entry(name, NULL);

+ }

+ pr_debug("\n");

+ return -EIO;

+ }

+ #endif

+- rndis_per_dev_params [i].confignr = i;

+- rndis_per_dev_params [i].used = 0;

+- rndis_per_dev_params [i].state = RNDIS_UNINITIALIZED;

+- rndis_per_dev_params [i].media_state

++ rndis_per_dev_params[i].confignr = i;

++ rndis_per_dev_params[i].used = 0;

++ rndis_per_dev_params[i].state = RNDIS_UNINITIALIZED;

++ rndis_per_dev_params[i].media_state

+ = NDIS_MEDIA_STATE_DISCONNECTED;

+- INIT_LIST_HEAD (&(rndis_per_dev_params [i].resp_queue));

++ INIT_LIST_HEAD(&(rndis_per_dev_params[i].resp_queue));

+ }

+

+ return 0;

+ }

+

+-void rndis_exit (void)

++void rndis_exit(void)

+ {

+-#ifdef CONFIG_USB_GADGET_DEBUG_FILES

++#ifdef CONFIG_USB_GADGET_DEBUG_FILES

+ u8 i;

+- char name [20];

++ char name[20];

+

+ for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {

+- sprintf (name, NAME_TEMPLATE, i);

+- remove_proc_entry (name, NULL);

++ sprintf(name, NAME_TEMPLATE, i);

++ remove_proc_entry(name, NULL);

+ }

+ #endif

+ }

+-