usb/net: rndis: inline the cpu_to_le32() macro

The header file <linux/usb/rndis_host.h> used a number of #defines
that included the cpu_to_le32() macro to assure the result will be
in LE endianness. Inlining this into the code instead of using it
in the code definitions yields consolidation opportunities later
on as you will see in the following patches. The individual
drivers also used local defines - all are switched over to the
pattern of doing the conversion at the call sites instead.

Signed-off-by: Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 28 insertions, 26 deletions

diff --git a/drivers/net/usb/rndis_host.c b/drivers/net/usb/rndis_host.c
index c8f1b5b3aff..3b7ddfd25fd 100644
--- a/drivers/net/usb/rndis_host.c
+++ b/drivers/net/usb/rndis_host.c
@@ -78,10 +78,10 @@ static void rndis_msg_indicate(struct usbnet *dev, struct rndis_indicate *msg,
                 dev->driver_info->indication(dev, msg, buflen);
         } else {
                 switch (msg->status) {
-                case RNDIS_STATUS_MEDIA_CONNECT:
+                case cpu_to_le32(RNDIS_STATUS_MEDIA_CONNECT):
                         dev_info(udev, "rndis media connect\n");
                         break;
-                case RNDIS_STATUS_MEDIA_DISCONNECT:
+                case cpu_to_le32(RNDIS_STATUS_MEDIA_DISCONNECT):
                         dev_info(udev, "rndis media disconnect\n");
                         break;
                 default:
@@ -117,8 +117,8 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
          */
 
         /* Issue the request; xid is unique, don't bother byteswapping it */
-        if (likely(buf->msg_type != RNDIS_MSG_HALT &&
-                   buf->msg_type != RNDIS_MSG_RESET)) {
+        if (likely(buf->msg_type != cpu_to_le32(RNDIS_MSG_HALT) &&
+                   buf->msg_type != cpu_to_le32(RNDIS_MSG_RESET))) {
                 xid = dev->xid++;
                 if (!xid)
                         xid = dev->xid++;
@@ -149,7 +149,7 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
         }
 
         /* Poll the control channel; the request probably completed immediately */
-        rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
+        rsp = buf->msg_type | cpu_to_le32(RNDIS_MSG_COMPLETION);
         for (count = 0; count < 10; count++) {
                 memset(buf, 0, CONTROL_BUFFER_SIZE);
                 retval = usb_control_msg(dev->udev,
@@ -164,9 +164,10 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
                         request_id = (__force u32) buf->request_id;
                         if (likely(buf->msg_type == rsp)) {
                                 if (likely(request_id == xid)) {
-                                        if (unlikely(rsp == RNDIS_MSG_RESET_C))
+                                        if (unlikely(rsp ==
+                                            cpu_to_le32(RNDIS_MSG_RESET_C)))
                                                 return 0;
-                                        if (likely(RNDIS_STATUS_SUCCESS
+                                        if (likely(cpu_to_le32(RNDIS_STATUS_SUCCESS)
                                                         == buf->status))
                                                 return 0;
                                         dev_dbg(&info->control->dev,
@@ -179,16 +180,15 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
                                         request_id, xid);
                                 /* then likely retry */
                         } else switch (buf->msg_type) {
-                        case RNDIS_MSG_INDICATE:        /* fault/event */
+                        case cpu_to_le32(RNDIS_MSG_INDICATE): /* fault/event */
                                 rndis_msg_indicate(dev, (void *)buf, buflen);
-
                                 break;
-                        case RNDIS_MSG_KEEPALIVE: {     /* ping */
+                        case cpu_to_le32(RNDIS_MSG_KEEPALIVE): { /* ping */
                                 struct rndis_keepalive_c *msg = (void *)buf;
 
-                                msg->msg_type = RNDIS_MSG_KEEPALIVE_C;
+                                msg->msg_type = cpu_to_le32(RNDIS_MSG_KEEPALIVE_C);
                                 msg->msg_len = cpu_to_le32(sizeof *msg);
-                                msg->status = RNDIS_STATUS_SUCCESS;
+                                msg->status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
                                 retval = usb_control_msg(dev->udev,
                                         usb_sndctrlpipe(dev->udev, 0),
                                         USB_CDC_SEND_ENCAPSULATED_COMMAND,
@@ -251,7 +251,7 @@ static int rndis_query(struct usbnet *dev, struct usb_interface *intf,
         u.buf = buf;
 
         memset(u.get, 0, sizeof *u.get + in_len);
-        u.get->msg_type = RNDIS_MSG_QUERY;
+        u.get->msg_type = cpu_to_le32(RNDIS_MSG_QUERY);
         u.get->msg_len = cpu_to_le32(sizeof *u.get + in_len);
         u.get->oid = oid;
         u.get->len = cpu_to_le32(in_len);
@@ -324,7 +324,7 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
         if (retval < 0)
                 goto fail;
 
-        u.init->msg_type = RNDIS_MSG_INIT;
+        u.init->msg_type = cpu_to_le32(RNDIS_MSG_INIT);
         u.init->msg_len = cpu_to_le32(sizeof *u.init);
         u.init->major_version = cpu_to_le32(1);
         u.init->minor_version = cpu_to_le32(0);
@@ -395,22 +395,23 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
         /* Check physical medium */
         phym = NULL;
         reply_len = sizeof *phym;
-        retval = rndis_query(dev, intf, u.buf, OID_GEN_PHYSICAL_MEDIUM,
+        retval = rndis_query(dev, intf, u.buf,
+                             cpu_to_le32(OID_GEN_PHYSICAL_MEDIUM),
                         0, (void **) &phym, &reply_len);
         if (retval != 0 || !phym) {
                 /* OID is optional so don't fail here. */
-                phym_unspec = RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED;
+                phym_unspec = cpu_to_le32(RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED);
                 phym = &phym_unspec;
         }
         if ((flags & FLAG_RNDIS_PHYM_WIRELESS) &&
-                        *phym != RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
+            *phym != cpu_to_le32(RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN)) {
                 netif_dbg(dev, probe, dev->net,
                           "driver requires wireless physical medium, but device is not\n");
                 retval = -ENODEV;
                 goto halt_fail_and_release;
         }
         if ((flags & FLAG_RNDIS_PHYM_NOT_WIRELESS) &&
-                        *phym == RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
+            *phym == cpu_to_le32(RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN)) {
                 netif_dbg(dev, probe, dev->net,
                           "driver requires non-wireless physical medium, but device is wireless.\n");
                 retval = -ENODEV;
@@ -419,7 +420,8 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
 
         /* Get designated host ethernet address */
         reply_len = ETH_ALEN;
-        retval = rndis_query(dev, intf, u.buf, OID_802_3_PERMANENT_ADDRESS,
+        retval = rndis_query(dev, intf, u.buf,
+                             cpu_to_le32(OID_802_3_PERMANENT_ADDRESS),
                         48, (void **) &bp, &reply_len);
         if (unlikely(retval< 0)) {
                 dev_err(&intf->dev, "rndis get ethaddr, %d\n", retval);
@@ -430,12 +432,12 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
 
         /* set a nonzero filter to enable data transfers */
         memset(u.set, 0, sizeof *u.set);
-        u.set->msg_type = RNDIS_MSG_SET;
+        u.set->msg_type = cpu_to_le32(RNDIS_MSG_SET);
         u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
-        u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
+        u.set->oid = cpu_to_le32(OID_GEN_CURRENT_PACKET_FILTER);
         u.set->len = cpu_to_le32(4);
         u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
-        *(__le32 *)(u.buf + sizeof *u.set) = RNDIS_DEFAULT_FILTER;
+        *(__le32 *)(u.buf + sizeof *u.set) = cpu_to_le32(RNDIS_DEFAULT_FILTER);
 
         retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
         if (unlikely(retval < 0)) {
@@ -450,7 +452,7 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
 
 halt_fail_and_release:
         memset(u.halt, 0, sizeof *u.halt);
-        u.halt->msg_type = RNDIS_MSG_HALT;
+        u.halt->msg_type = cpu_to_le32(RNDIS_MSG_HALT);
         u.halt->msg_len = cpu_to_le32(sizeof *u.halt);
         (void) rndis_command(dev, (void *)u.halt, CONTROL_BUFFER_SIZE);
 fail_and_release:
@@ -475,7 +477,7 @@ void rndis_unbind(struct usbnet *dev, struct usb_interface *intf)
         /* try to clear any rndis state/activity (no i/o from stack!) */
         halt = kzalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
         if (halt) {
-                halt->msg_type = RNDIS_MSG_HALT;
+                halt->msg_type = cpu_to_le32(RNDIS_MSG_HALT);
                 halt->msg_len = cpu_to_le32(sizeof *halt);
                 (void) rndis_command(dev, (void *)halt, CONTROL_BUFFER_SIZE);
                 kfree(halt);
@@ -501,7 +503,7 @@ int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                 data_len = le32_to_cpu(hdr->data_len);
 
                 /* don't choke if we see oob, per-packet data, etc */
-                if (unlikely(hdr->msg_type != RNDIS_MSG_PACKET ||
+                if (unlikely(hdr->msg_type != cpu_to_le32(RNDIS_MSG_PACKET) ||
                              skb->len < msg_len ||
                              (data_offset + data_len + 8) > msg_len)) {
                         dev->net->stats.rx_frame_errors++;
@@ -569,7 +571,7 @@ rndis_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
 fill:
         hdr = (void *) __skb_push(skb, sizeof *hdr);
         memset(hdr, 0, sizeof *hdr);
-        hdr->msg_type = RNDIS_MSG_PACKET;
+        hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET);
         hdr->msg_len = cpu_to_le32(skb->len);
         hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8);
         hdr->data_len = cpu_to_le32(len);