Commit 7390e8b0 authored by Linus Walleij's avatar Linus Walleij Committed by David S. Miller
Browse files

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: default avatarJussi Kivilinna <jussi.kivilinna@mbnet.fi>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 647c0c70

drivers/net/usb/rndis_host.c

+28 −26
Original line number Diff line number Diff line
@@ -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);

drivers/net/wireless/rndis_wlan.c

+107 −105

File changed.

Preview size limit exceeded, changes collapsed.

include/linux/usb/rndis_host.h

+42 −42
Original line number Diff line number Diff line
@@ -49,46 +49,46 @@ struct rndis_msg_hdr { 
 */

#define	RNDIS_CONTROL_TIMEOUT_MS	(5 * 1000)



#define RNDIS_MSG_COMPLETION	cpu_to_le32(0x80000000)

#define RNDIS_MSG_COMPLETION	0x80000000



/* codes for "msg_type" field of rndis messages;

 * only the data channel uses packet messages (maybe batched);

 * everything else goes on the control channel.

 */

#define RNDIS_MSG_PACKET	cpu_to_le32(0x00000001)	/* 1-N packets */

#define RNDIS_MSG_INIT		cpu_to_le32(0x00000002)

#define RNDIS_MSG_PACKET	0x00000001	/* 1-N packets */

#define RNDIS_MSG_INIT		0x00000002

#define RNDIS_MSG_INIT_C	(RNDIS_MSG_INIT|RNDIS_MSG_COMPLETION)

#define RNDIS_MSG_HALT		cpu_to_le32(0x00000003)

#define RNDIS_MSG_QUERY		cpu_to_le32(0x00000004)

#define RNDIS_MSG_HALT		0x00000003

#define RNDIS_MSG_QUERY		0x00000004

#define RNDIS_MSG_QUERY_C	(RNDIS_MSG_QUERY|RNDIS_MSG_COMPLETION)

#define RNDIS_MSG_SET		cpu_to_le32(0x00000005)

#define RNDIS_MSG_SET		0x00000005

#define RNDIS_MSG_SET_C		(RNDIS_MSG_SET|RNDIS_MSG_COMPLETION)

#define RNDIS_MSG_RESET		cpu_to_le32(0x00000006)

#define RNDIS_MSG_RESET		0x00000006

#define RNDIS_MSG_RESET_C	(RNDIS_MSG_RESET|RNDIS_MSG_COMPLETION)

#define RNDIS_MSG_INDICATE	cpu_to_le32(0x00000007)

#define RNDIS_MSG_KEEPALIVE	cpu_to_le32(0x00000008)

#define RNDIS_MSG_INDICATE	0x00000007

#define RNDIS_MSG_KEEPALIVE	0x00000008

#define RNDIS_MSG_KEEPALIVE_C	(RNDIS_MSG_KEEPALIVE|RNDIS_MSG_COMPLETION)



/* codes for "status" field of completion messages */

#define	RNDIS_STATUS_SUCCESS			cpu_to_le32(0x00000000)

#define	RNDIS_STATUS_FAILURE			cpu_to_le32(0xc0000001)

#define	RNDIS_STATUS_INVALID_DATA		cpu_to_le32(0xc0010015)

#define	RNDIS_STATUS_NOT_SUPPORTED		cpu_to_le32(0xc00000bb)

#define	RNDIS_STATUS_MEDIA_CONNECT		cpu_to_le32(0x4001000b)

#define	RNDIS_STATUS_MEDIA_DISCONNECT		cpu_to_le32(0x4001000c)

#define	RNDIS_STATUS_MEDIA_SPECIFIC_INDICATION	cpu_to_le32(0x40010012)

#define	RNDIS_STATUS_SUCCESS			0x00000000

#define	RNDIS_STATUS_FAILURE			0xc0000001

#define	RNDIS_STATUS_INVALID_DATA		0xc0010015

#define	RNDIS_STATUS_NOT_SUPPORTED		0xc00000bb

#define	RNDIS_STATUS_MEDIA_CONNECT		0x4001000b

#define	RNDIS_STATUS_MEDIA_DISCONNECT		0x4001000c

#define	RNDIS_STATUS_MEDIA_SPECIFIC_INDICATION	0x40010012



/* codes for OID_GEN_PHYSICAL_MEDIUM */

#define	RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED	cpu_to_le32(0x00000000)

#define	RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN	cpu_to_le32(0x00000001)

#define	RNDIS_PHYSICAL_MEDIUM_CABLE_MODEM	cpu_to_le32(0x00000002)

#define	RNDIS_PHYSICAL_MEDIUM_PHONE_LINE	cpu_to_le32(0x00000003)

#define	RNDIS_PHYSICAL_MEDIUM_POWER_LINE	cpu_to_le32(0x00000004)

#define	RNDIS_PHYSICAL_MEDIUM_DSL		cpu_to_le32(0x00000005)

#define	RNDIS_PHYSICAL_MEDIUM_FIBRE_CHANNEL	cpu_to_le32(0x00000006)

#define	RNDIS_PHYSICAL_MEDIUM_1394		cpu_to_le32(0x00000007)

#define	RNDIS_PHYSICAL_MEDIUM_WIRELESS_WAN	cpu_to_le32(0x00000008)

#define	RNDIS_PHYSICAL_MEDIUM_MAX		cpu_to_le32(0x00000009)

#define	RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED	0x00000000

#define	RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN	0x00000001

#define	RNDIS_PHYSICAL_MEDIUM_CABLE_MODEM	0x00000002

#define	RNDIS_PHYSICAL_MEDIUM_PHONE_LINE	0x00000003

#define	RNDIS_PHYSICAL_MEDIUM_POWER_LINE	0x00000004

#define	RNDIS_PHYSICAL_MEDIUM_DSL		0x00000005

#define	RNDIS_PHYSICAL_MEDIUM_FIBRE_CHANNEL	0x00000006

#define	RNDIS_PHYSICAL_MEDIUM_1394		0x00000007

#define	RNDIS_PHYSICAL_MEDIUM_WIRELESS_WAN	0x00000008

#define	RNDIS_PHYSICAL_MEDIUM_MAX		0x00000009



struct rndis_data_hdr {

	__le32	msg_type;		/* RNDIS_MSG_PACKET */
@@ -226,24 +226,24 @@ struct rndis_keepalive_c { /* IN (optionally OUT) */ 
 * there are gobs more that may optionally be supported.  We'll avoid as much

 * of that mess as possible.

 */

#define OID_802_3_PERMANENT_ADDRESS	cpu_to_le32(0x01010101)

#define OID_GEN_MAXIMUM_FRAME_SIZE	cpu_to_le32(0x00010106)

#define OID_GEN_CURRENT_PACKET_FILTER	cpu_to_le32(0x0001010e)

#define OID_GEN_PHYSICAL_MEDIUM		cpu_to_le32(0x00010202)

#define OID_802_3_PERMANENT_ADDRESS	0x01010101

#define OID_GEN_MAXIMUM_FRAME_SIZE	0x00010106

#define OID_GEN_CURRENT_PACKET_FILTER	0x0001010e

#define OID_GEN_PHYSICAL_MEDIUM		0x00010202



/* packet filter bits used by OID_GEN_CURRENT_PACKET_FILTER */

#define RNDIS_PACKET_TYPE_DIRECTED		cpu_to_le32(0x00000001)

#define RNDIS_PACKET_TYPE_MULTICAST		cpu_to_le32(0x00000002)

#define RNDIS_PACKET_TYPE_ALL_MULTICAST		cpu_to_le32(0x00000004)

#define RNDIS_PACKET_TYPE_BROADCAST		cpu_to_le32(0x00000008)

#define RNDIS_PACKET_TYPE_SOURCE_ROUTING	cpu_to_le32(0x00000010)

#define RNDIS_PACKET_TYPE_PROMISCUOUS		cpu_to_le32(0x00000020)

#define RNDIS_PACKET_TYPE_SMT			cpu_to_le32(0x00000040)

#define RNDIS_PACKET_TYPE_ALL_LOCAL		cpu_to_le32(0x00000080)

#define RNDIS_PACKET_TYPE_GROUP			cpu_to_le32(0x00001000)

#define RNDIS_PACKET_TYPE_ALL_FUNCTIONAL	cpu_to_le32(0x00002000)

#define RNDIS_PACKET_TYPE_FUNCTIONAL		cpu_to_le32(0x00004000)

#define RNDIS_PACKET_TYPE_MAC_FRAME		cpu_to_le32(0x00008000)

#define RNDIS_PACKET_TYPE_DIRECTED		0x00000001

#define RNDIS_PACKET_TYPE_MULTICAST		0x00000002

#define RNDIS_PACKET_TYPE_ALL_MULTICAST		0x00000004

#define RNDIS_PACKET_TYPE_BROADCAST		0x00000008

#define RNDIS_PACKET_TYPE_SOURCE_ROUTING	0x00000010

#define RNDIS_PACKET_TYPE_PROMISCUOUS		0x00000020

#define RNDIS_PACKET_TYPE_SMT			0x00000040

#define RNDIS_PACKET_TYPE_ALL_LOCAL		0x00000080

#define RNDIS_PACKET_TYPE_GROUP			0x00001000

#define RNDIS_PACKET_TYPE_ALL_FUNCTIONAL	0x00002000

#define RNDIS_PACKET_TYPE_FUNCTIONAL		0x00004000

#define RNDIS_PACKET_TYPE_MAC_FRAME		0x00008000



/* default filter used with RNDIS devices */

#define RNDIS_DEFAULT_FILTER ( \

CRA Git | Maintained and supported by SUSTech CRA and CCSE