USB: gadget: rndis: fix up coding style issues in the file
authorMihai Donțu <mihai.dontu@gmail.com>
Tue, 7 Sep 2010 23:54:02 +0000 (02:54 +0300)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 22 Oct 2010 17:21:30 +0000 (10:21 -0700)
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

index 972d5ddd1e18043f23281b3282681c6c9eb0ea62..5b314041dfa9d35fbfad3b928dc4305ea4818232 100644 (file)
@@ -61,17 +61,17 @@ MODULE_PARM_DESC (rndis_debug, "enable debugging");
 #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)
+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;
+       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 OID, u8 *buf, unsigned buf_len,
        }
 
        /* 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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
                 * 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 OID, u8 *buf, unsigned buf_len,
        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 OID, u8 *buf, unsigned buf_len,
        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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        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 OID, u8 *buf, unsigned buf_len,
        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 OID, u8 *buf, unsigned buf_len,
        /* 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 OID, u8 *buf, unsigned buf_len,
        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 configNr, u32 OID, u8 *buf, u32 buf_len,
                }
        }
 
-       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 configNr, u32 OID, u8 *buf, u32 buf_len,
                        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 configNr, u32 OID, u8 *buf, u32 buf_len,
  * 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 configNr, rndis_query_msg_type *buf)
         * 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 configNr, rndis_set_msg_type *buf)
        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 configNr,
 /*
  * 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 *buf)
        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 *buf)
                 * 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)(void *v), void *v)
                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)(void *v), void *v)
        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, struct net_device *dev, u16 *cdc_filter)
                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 configNr, u32 *length)
        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_file *m, void *v)
 }
 
 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 file *file, const char __user *buffer,
                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 rndis_proc_fops = {
        .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("%sremove 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
 }
-