[linux.git] / include / linux / usb / ncm.h

/*
 * USB CDC NCM auxiliary definitions
 */

#ifndef __LINUX_USB_NCM_H
#define __LINUX_USB_NCM_H

#include <linux/types.h>
#include <linux/usb/cdc.h>
#include <asm/unaligned.h>

#define NCM_NTB_MIN_IN_SIZE		2048
#define NCM_NTB_MIN_OUT_SIZE		2048

#define NCM_CONTROL_TIMEOUT		(5 * 1000)

/* bmNetworkCapabilities */

#define NCM_NCAP_ETH_FILTER	(1 << 0)
#define NCM_NCAP_NET_ADDRESS	(1 << 1)
#define NCM_NCAP_ENCAP_COMM	(1 << 2)
#define NCM_NCAP_MAX_DGRAM	(1 << 3)
#define NCM_NCAP_CRC_MODE	(1 << 4)

/*
 * Here are options for NCM Datagram Pointer table (NDP) parser.
 * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
 * in NDP16 offsets and sizes fields are 1 16bit word wide,
 * in NDP32 -- 2 16bit words wide. Also signatures are different.
 * To make the parser code the same, put the differences in the structure,
 * and switch pointers to the structures when the format is changed.
 */

struct ndp_parser_opts {
	u32		nth_sign;
	u32		ndp_sign;
	unsigned	nth_size;
	unsigned	ndp_size;
	unsigned	ndplen_align;
	/* sizes in u16 units */
	unsigned	dgram_item_len; /* index or length */
	unsigned	block_length;
	unsigned	fp_index;
	unsigned	reserved1;
	unsigned	reserved2;
	unsigned	next_fp_index;
};

#define INIT_NDP16_OPTS {					\
		.nth_sign = NCM_NTH16_SIGN,			\
		.ndp_sign = NCM_NDP16_NOCRC_SIGN,		\
		.nth_size = sizeof(struct usb_cdc_ncm_nth16),	\
		.ndp_size = sizeof(struct usb_cdc_ncm_ndp16),	\
		.ndplen_align = 4,				\
		.dgram_item_len = 1,				\
		.block_length = 1,				\
		.fp_index = 1,					\
		.reserved1 = 0,					\
		.reserved2 = 0,					\
		.next_fp_index = 1,				\
	}


#define INIT_NDP32_OPTS {					\
		.nth_sign = NCM_NTH32_SIGN,			\
		.ndp_sign = NCM_NDP32_NOCRC_SIGN,		\
		.nth_size = sizeof(struct usb_cdc_ncm_nth32),	\
		.ndp_size = sizeof(struct usb_cdc_ncm_ndp32),	\
		.ndplen_align = 8,				\
		.dgram_item_len = 2,				\
		.block_length = 2,				\
		.fp_index = 2,					\
		.reserved1 = 1,					\
		.reserved2 = 2,					\
		.next_fp_index = 2,				\
	}

static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
{
	switch (size) {
	case 1:
		put_unaligned_le16((u16)val, *p);
		break;
	case 2:
		put_unaligned_le32((u32)val, *p);

		break;
	default:
		BUG();
	}

	*p += size;
}

static inline unsigned get_ncm(__le16 **p, unsigned size)
{
	unsigned tmp;

	switch (size) {
	case 1:
		tmp = get_unaligned_le16(*p);
		break;
	case 2:
		tmp = get_unaligned_le32(*p);
		break;
	default:
		BUG();
	}

	*p += size;
	return tmp;
}

#endif /* __LINUX_USB_NCM_H */
Commit	Line	Data
65e0b499 YK	1	/*
	2	* USB CDC NCM auxiliary definitions
	3	*/
	4
	5	#ifndef __LINUX_USB_NCM_H
	6	#define __LINUX_USB_NCM_H
	7
	8	#include <linux/types.h>
	9	#include <linux/usb/cdc.h>
	10	#include <asm/unaligned.h>
	11
	12	#define NCM_NTB_MIN_IN_SIZE 2048
	13	#define NCM_NTB_MIN_OUT_SIZE 2048
	14
	15	#define NCM_CONTROL_TIMEOUT (5 * 1000)
	16
	17	/* bmNetworkCapabilities */
	18
	19	#define NCM_NCAP_ETH_FILTER (1 << 0)
	20	#define NCM_NCAP_NET_ADDRESS (1 << 1)
	21	#define NCM_NCAP_ENCAP_COMM (1 << 2)
	22	#define NCM_NCAP_MAX_DGRAM (1 << 3)
	23	#define NCM_NCAP_CRC_MODE (1 << 4)
	24
	25	/*
	26	* Here are options for NCM Datagram Pointer table (NDP) parser.
	27	* There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
	28	* in NDP16 offsets and sizes fields are 1 16bit word wide,
	29	* in NDP32 -- 2 16bit words wide. Also signatures are different.
	30	* To make the parser code the same, put the differences in the structure,
	31	* and switch pointers to the structures when the format is changed.
	32	*/
	33
	34	struct ndp_parser_opts {
	35	u32 nth_sign;
	36	u32 ndp_sign;
	37	unsigned nth_size;
	38	unsigned ndp_size;
	39	unsigned ndplen_align;
	40	/* sizes in u16 units */
	41	unsigned dgram_item_len; /* index or length */
	42	unsigned block_length;
	43	unsigned fp_index;
	44	unsigned reserved1;
	45	unsigned reserved2;
	46	unsigned next_fp_index;
	47	};
	48
	49	#define INIT_NDP16_OPTS { \
	50	.nth_sign = NCM_NTH16_SIGN, \
	51	.ndp_sign = NCM_NDP16_NOCRC_SIGN, \
	52	.nth_size = sizeof(struct usb_cdc_ncm_nth16), \
	53	.ndp_size = sizeof(struct usb_cdc_ncm_ndp16), \
	54	.ndplen_align = 4, \
	55	.dgram_item_len = 1, \
	56	.block_length = 1, \
	57	.fp_index = 1, \
	58	.reserved1 = 0, \
	59	.reserved2 = 0, \
	60	.next_fp_index = 1, \
	61	}
	62
	63
	64	#define INIT_NDP32_OPTS { \
65	.nth_sign = NCM_NTH32_SIGN, \
66	.ndp_sign = NCM_NDP32_NOCRC_SIGN, \
67	.nth_size = sizeof(struct usb_cdc_ncm_nth32), \
68	.ndp_size = sizeof(struct usb_cdc_ncm_ndp32), \
69	.ndplen_align = 8, \
70	.dgram_item_len = 2, \
71	.block_length = 2, \
72	.fp_index = 2, \
73	.reserved1 = 1, \
74	.reserved2 = 2, \
75	.next_fp_index = 2, \
76	}
77
78	static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
79	{
80	switch (size) {
81	case 1:
82	put_unaligned_le16((u16)val, *p);
83	break;
84	case 2:
85	put_unaligned_le32((u32)val, *p);
86
87	break;
88	default:
89	BUG();
90	}
91
92	*p += size;
93	}
94
95	static inline unsigned get_ncm(__le16 **p, unsigned size)
96	{
97	unsigned tmp;
98
99	switch (size) {
100	case 1:
101	tmp = get_unaligned_le16(*p);
102	break;
103	case 2:
104	tmp = get_unaligned_le32(*p);
105	break;
106	default:
107	BUG();
108	}
109
110	*p += size;
111	return tmp;
112	}
113
114	#endif /* __LINUX_USB_NCM_H */