include/linux/usb/ncm.h

   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 */