1 /*
2  * Copyright (c) 2024, sakumisu
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  */
6 #include "usbh_core.h"
7 #include "usbh_cdc_ncm.h"
8 
9 #undef USB_DBG_TAG
10 #define USB_DBG_TAG "usbh_cdc_ncm"
11 #include "usb_log.h"
12 
13 #define DEV_FORMAT "/dev/cdc_ncm"
14 
15 /* general descriptor field offsets */
16 #define DESC_bLength            0 /** Length offset */
17 #define DESC_bDescriptorType    1 /** Descriptor type offset */
18 #define DESC_bDescriptorSubType 2 /** Descriptor subtype offset */
19 
20 /* interface descriptor field offsets */
21 #define INTF_DESC_bInterfaceNumber  2 /** Interface number offset */
22 #define INTF_DESC_bAlternateSetting 3 /** Alternate setting offset */
23 
24 #define CONFIG_USBHOST_CDC_NCM_ETH_MAX_SEGSZE 1514U
25 
26 static USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_cdc_ncm_rx_buffer[CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE];
27 static USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_cdc_ncm_tx_buffer[CONFIG_USBHOST_CDC_NCM_ETH_MAX_TX_SIZE];
28 static USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_cdc_ncm_inttx_buffer[USB_ALIGN_UP(16, CONFIG_USB_ALIGN_SIZE)];
29 
30 static USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_cdc_ncm_buf[USB_ALIGN_UP(32, CONFIG_USB_ALIGN_SIZE)];
31 
32 static struct usbh_cdc_ncm g_cdc_ncm_class;
33 
usbh_cdc_ncm_get_ntb_parameters(struct usbh_cdc_ncm * cdc_ncm_class,struct cdc_ncm_ntb_parameters * param)34 static int usbh_cdc_ncm_get_ntb_parameters(struct usbh_cdc_ncm *cdc_ncm_class, struct cdc_ncm_ntb_parameters *param)
35 {
36     struct usb_setup_packet *setup;
37     int ret;
38 
39     if (!cdc_ncm_class || !cdc_ncm_class->hport) {
40         return -USB_ERR_INVAL;
41     }
42     setup = cdc_ncm_class->hport->setup;
43 
44     setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
45     setup->bRequest = CDC_REQUEST_GET_NTB_PARAMETERS;
46     setup->wValue = 0;
47     setup->wIndex = cdc_ncm_class->ctrl_intf;
48     setup->wLength = 28;
49 
50     ret = usbh_control_transfer(cdc_ncm_class->hport, setup, g_cdc_ncm_buf);
51     if (ret < 8) {
52         return ret;
53     }
54 
55     memcpy((uint8_t *)param, g_cdc_ncm_buf, MIN(ret - 8, sizeof(struct cdc_ncm_ntb_parameters)));
56     return 0;
57 }
58 
print_ntb_parameters(struct cdc_ncm_ntb_parameters * param)59 static void print_ntb_parameters(struct cdc_ncm_ntb_parameters *param)
60 {
61     USB_LOG_RAW("CDC NCM ntb parameters:\r\n");
62     USB_LOG_RAW("wLength: 0x%02x             \r\n", param->wLength);
63     USB_LOG_RAW("bmNtbFormatsSupported: %s     \r\n", param->bmNtbFormatsSupported ? "NTB16" : "NTB32");
64 
65     USB_LOG_RAW("dwNtbInMaxSize: 0x%08x           \r\n", (unsigned int)param->dwNtbInMaxSize);
66     USB_LOG_RAW("wNdbInDivisor: 0x%02x \r\n", param->wNdbInDivisor);
67     USB_LOG_RAW("wNdbInPayloadRemainder: 0x%02x      \r\n", param->wNdbInPayloadRemainder);
68     USB_LOG_RAW("wNdbInAlignment: 0x%02x    \r\n", param->wNdbInAlignment);
69 
70     USB_LOG_RAW("dwNtbOutMaxSize: 0x%08x     \r\n", (unsigned int)param->dwNtbOutMaxSize);
71     USB_LOG_RAW("wNdbOutDivisor: 0x%02x     \r\n", param->wNdbOutDivisor);
72     USB_LOG_RAW("wNdbOutPayloadRemainder: 0x%02x     \r\n", param->wNdbOutPayloadRemainder);
73     USB_LOG_RAW("wNdbOutAlignment: 0x%02x     \r\n", param->wNdbOutAlignment);
74 
75     USB_LOG_RAW("wNtbOutMaxDatagrams: 0x%02x     \r\n", param->wNtbOutMaxDatagrams);
76 }
77 
usbh_cdc_ncm_get_connect_status(struct usbh_cdc_ncm * cdc_ncm_class)78 int usbh_cdc_ncm_get_connect_status(struct usbh_cdc_ncm *cdc_ncm_class)
79 {
80     int ret;
81 
82     usbh_int_urb_fill(&cdc_ncm_class->intin_urb, cdc_ncm_class->hport, cdc_ncm_class->intin, g_cdc_ncm_inttx_buffer, 16, USB_OSAL_WAITING_FOREVER, NULL, NULL);
83     ret = usbh_submit_urb(&cdc_ncm_class->intin_urb);
84     if (ret < 0) {
85         return ret;
86     }
87 
88     if (g_cdc_ncm_inttx_buffer[1] == CDC_ECM_NOTIFY_CODE_NETWORK_CONNECTION) {
89         if (g_cdc_ncm_inttx_buffer[2] == CDC_ECM_NET_CONNECTED) {
90             cdc_ncm_class->connect_status = true;
91         } else {
92             cdc_ncm_class->connect_status = false;
93         }
94     } else if (g_cdc_ncm_inttx_buffer[1] == CDC_ECM_NOTIFY_CODE_CONNECTION_SPEED_CHANGE) {
95         memcpy(cdc_ncm_class->speed, &g_cdc_ncm_inttx_buffer[8], 8);
96     }
97     return 0;
98 }
99 
usbh_cdc_ncm_connect(struct usbh_hubport * hport,uint8_t intf)100 static int usbh_cdc_ncm_connect(struct usbh_hubport *hport, uint8_t intf)
101 {
102     struct usb_endpoint_descriptor *ep_desc;
103     int ret;
104     uint8_t altsetting = 0;
105     char mac_buffer[12];
106     uint8_t *p;
107     uint8_t cur_iface = 0xff;
108     uint8_t mac_str_idx = 0xff;
109 
110     struct usbh_cdc_ncm *cdc_ncm_class = &g_cdc_ncm_class;
111 
112     memset(cdc_ncm_class, 0, sizeof(struct usbh_cdc_ncm));
113 
114     cdc_ncm_class->hport = hport;
115     cdc_ncm_class->ctrl_intf = intf;
116     cdc_ncm_class->data_intf = intf + 1;
117 
118     hport->config.intf[intf].priv = cdc_ncm_class;
119     hport->config.intf[intf + 1].priv = NULL;
120 
121     p = hport->raw_config_desc;
122     while (p[DESC_bLength]) {
123         switch (p[DESC_bDescriptorType]) {
124             case USB_DESCRIPTOR_TYPE_INTERFACE:
125                 cur_iface = p[INTF_DESC_bInterfaceNumber];
126                 //cur_alt_setting = p[INTF_DESC_bAlternateSetting];
127                 break;
128             case CDC_CS_INTERFACE:
129                 if ((cur_iface == cdc_ncm_class->ctrl_intf) && p[DESC_bDescriptorSubType] == CDC_FUNC_DESC_ETHERNET_NETWORKING) {
130                     struct cdc_eth_descriptor *desc = (struct cdc_eth_descriptor *)p;
131                     mac_str_idx = desc->iMACAddress;
132                     cdc_ncm_class->max_segment_size = desc->wMaxSegmentSize;
133                     goto get_mac;
134                 }
135                 break;
136 
137             default:
138                 break;
139         }
140         /* skip to next descriptor */
141         p += p[DESC_bLength];
142     }
143 
144 get_mac:
145     if (mac_str_idx == 0xff) {
146         USB_LOG_ERR("Do not find cdc ncm mac string\r\n");
147         return -1;
148     }
149 
150     memset(mac_buffer, 0, 12);
151     ret = usbh_get_string_desc(cdc_ncm_class->hport, mac_str_idx, (uint8_t *)mac_buffer, 12);
152     if (ret < 0) {
153         return ret;
154     }
155 
156     for (int i = 0, j = 0; i < 12; i += 2, j++) {
157         char byte_str[3];
158         byte_str[0] = mac_buffer[i];
159         byte_str[1] = mac_buffer[i + 1];
160         byte_str[2] = '\0';
161 
162         uint32_t byte = strtoul(byte_str, NULL, 16);
163         cdc_ncm_class->mac[j] = (unsigned char)byte;
164     }
165 
166     USB_LOG_INFO("CDC NCM MAC address %02x:%02x:%02x:%02x:%02x:%02x\r\n",
167                  cdc_ncm_class->mac[0],
168                  cdc_ncm_class->mac[1],
169                  cdc_ncm_class->mac[2],
170                  cdc_ncm_class->mac[3],
171                  cdc_ncm_class->mac[4],
172                  cdc_ncm_class->mac[5]);
173 
174     if (cdc_ncm_class->max_segment_size > CONFIG_USBHOST_CDC_NCM_ETH_MAX_SEGSZE) {
175         USB_LOG_ERR("CDC NCM Max Segment Size is overflow, default is %u, but now %u\r\n", CONFIG_USBHOST_CDC_NCM_ETH_MAX_SEGSZE, cdc_ncm_class->max_segment_size);
176     } else {
177         USB_LOG_INFO("CDC NCM Max Segment Size:%u\r\n", cdc_ncm_class->max_segment_size);
178     }
179 
180     usbh_cdc_ncm_get_ntb_parameters(cdc_ncm_class, &cdc_ncm_class->ntb_param);
181     print_ntb_parameters(&cdc_ncm_class->ntb_param);
182 
183     /* enable int ep */
184     ep_desc = &hport->config.intf[intf].altsetting[0].ep[0].ep_desc;
185     USBH_EP_INIT(cdc_ncm_class->intin, ep_desc);
186 
187     if (hport->config.intf[intf + 1].altsetting_num > 1) {
188         altsetting = hport->config.intf[intf + 1].altsetting_num - 1;
189 
190         for (uint8_t i = 0; i < hport->config.intf[intf + 1].altsetting[altsetting].intf_desc.bNumEndpoints; i++) {
191             ep_desc = &hport->config.intf[intf + 1].altsetting[altsetting].ep[i].ep_desc;
192 
193             if (ep_desc->bEndpointAddress & 0x80) {
194                 USBH_EP_INIT(cdc_ncm_class->bulkin, ep_desc);
195             } else {
196                 USBH_EP_INIT(cdc_ncm_class->bulkout, ep_desc);
197             }
198         }
199 
200         USB_LOG_INFO("Select cdc ncm altsetting: %d\r\n", altsetting);
201         usbh_set_interface(cdc_ncm_class->hport, cdc_ncm_class->data_intf, altsetting);
202     } else {
203         for (uint8_t i = 0; i < hport->config.intf[intf + 1].altsetting[0].intf_desc.bNumEndpoints; i++) {
204             ep_desc = &hport->config.intf[intf + 1].altsetting[0].ep[i].ep_desc;
205 
206             if (ep_desc->bEndpointAddress & 0x80) {
207                 USBH_EP_INIT(cdc_ncm_class->bulkin, ep_desc);
208             } else {
209                 USBH_EP_INIT(cdc_ncm_class->bulkout, ep_desc);
210             }
211         }
212     }
213 
214     strncpy(hport->config.intf[intf].devname, DEV_FORMAT, CONFIG_USBHOST_DEV_NAMELEN);
215 
216     USB_LOG_INFO("Register CDC NCM Class:%s\r\n", hport->config.intf[intf].devname);
217 
218     usbh_cdc_ncm_run(cdc_ncm_class);
219     return ret;
220 }
221 
usbh_cdc_ncm_disconnect(struct usbh_hubport * hport,uint8_t intf)222 static int usbh_cdc_ncm_disconnect(struct usbh_hubport *hport, uint8_t intf)
223 {
224     int ret = 0;
225 
226     struct usbh_cdc_ncm *cdc_ncm_class = (struct usbh_cdc_ncm *)hport->config.intf[intf].priv;
227 
228     if (cdc_ncm_class) {
229         if (cdc_ncm_class->bulkin) {
230             usbh_kill_urb(&cdc_ncm_class->bulkin_urb);
231         }
232 
233         if (cdc_ncm_class->bulkout) {
234             usbh_kill_urb(&cdc_ncm_class->bulkout_urb);
235         }
236 
237         if (cdc_ncm_class->intin) {
238             usbh_kill_urb(&cdc_ncm_class->intin_urb);
239         }
240 
241         if (hport->config.intf[intf].devname[0] != '\0') {
242             usb_osal_thread_schedule_other();
243             USB_LOG_INFO("Unregister CDC NCM Class:%s\r\n", hport->config.intf[intf].devname);
244             usbh_cdc_ncm_stop(cdc_ncm_class);
245         }
246 
247         memset(cdc_ncm_class, 0, sizeof(struct usbh_cdc_ncm));
248     }
249 
250     return ret;
251 }
252 
usbh_cdc_ncm_rx_thread(CONFIG_USB_OSAL_THREAD_SET_ARGV)253 void usbh_cdc_ncm_rx_thread(CONFIG_USB_OSAL_THREAD_SET_ARGV)
254 {
255     uint32_t g_cdc_ncm_rx_length;
256     int ret;
257 #if CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE <= (16 * 1024)
258     uint32_t transfer_size = CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE;
259 #else
260     uint32_t transfer_size = (16 * 1024);
261 #endif
262 
263     (void)CONFIG_USB_OSAL_THREAD_GET_ARGV;
264     USB_LOG_INFO("Create cdc ncm rx thread\r\n");
265     // clang-format off
266 find_class:
267     // clang-format on
268     g_cdc_ncm_class.connect_status = false;
269     if (usbh_find_class_instance("/dev/cdc_ncm") == NULL) {
270         goto delete;
271     }
272 
273     while (g_cdc_ncm_class.connect_status == false) {
274         ret = usbh_cdc_ncm_get_connect_status(&g_cdc_ncm_class);
275         if (ret < 0) {
276             usb_osal_msleep(100);
277             goto find_class;
278         }
279     }
280 
281     g_cdc_ncm_rx_length = 0;
282     while (1) {
283         usbh_bulk_urb_fill(&g_cdc_ncm_class.bulkin_urb, g_cdc_ncm_class.hport, g_cdc_ncm_class.bulkin, &g_cdc_ncm_rx_buffer[g_cdc_ncm_rx_length], transfer_size, USB_OSAL_WAITING_FOREVER, NULL, NULL);
284         ret = usbh_submit_urb(&g_cdc_ncm_class.bulkin_urb);
285         if (ret < 0) {
286             goto find_class;
287         }
288 
289         g_cdc_ncm_rx_length += g_cdc_ncm_class.bulkin_urb.actual_length;
290 
291         /* A transfer is complete because last packet is a short packet.
292          * Short packet is not zero, match g_cdc_ncm_rx_length % USB_GET_MAXPACKETSIZE(g_cdc_ncm_class.bulkin->wMaxPacketSize).
293          * Short packet is zero, check if g_cdc_ncm_class.bulkin_urb.actual_length < transfer_size, for example transfer is complete with size is 1024 < 2048.
294         */
295         if ((g_cdc_ncm_rx_length % USB_GET_MAXPACKETSIZE(g_cdc_ncm_class.bulkin->wMaxPacketSize)) ||
296             (g_cdc_ncm_class.bulkin_urb.actual_length < transfer_size)) {
297             USB_LOG_DBG("rxlen:%d\r\n", g_cdc_ncm_rx_length);
298 
299             struct cdc_ncm_nth16 *nth16 = (struct cdc_ncm_nth16 *)&g_cdc_ncm_rx_buffer[0];
300             if ((nth16->dwSignature != CDC_NCM_NTH16_SIGNATURE) ||
301                 (nth16->wHeaderLength != 12) ||
302                 (nth16->wBlockLength != g_cdc_ncm_rx_length)) {
303                 USB_LOG_ERR("invalid rx nth16\r\n");
304                 g_cdc_ncm_rx_length = 0;
305                 continue;
306             }
307 
308             struct cdc_ncm_ndp16 *ndp16 = (struct cdc_ncm_ndp16 *)&g_cdc_ncm_rx_buffer[nth16->wNdpIndex];
309             if ((ndp16->dwSignature != CDC_NCM_NDP16_SIGNATURE_NCM0) && (ndp16->dwSignature != CDC_NCM_NDP16_SIGNATURE_NCM1)) {
310                 USB_LOG_ERR("invalid rx ndp16\r\n");
311                 g_cdc_ncm_rx_length = 0;
312                 continue;
313             }
314 
315             uint16_t datagram_num = (ndp16->wLength - 8) / 4;
316 
317             USB_LOG_DBG("datagram num:%02x\r\n", datagram_num);
318             for (uint16_t i = 0; i < datagram_num; i++) {
319                 struct cdc_ncm_ndp16_datagram *ndp16_datagram = (struct cdc_ncm_ndp16_datagram *)&g_cdc_ncm_rx_buffer[nth16->wNdpIndex + 8 + 4 * i];
320                 if (ndp16_datagram->wDatagramIndex && ndp16_datagram->wDatagramLength) {
321                     USB_LOG_DBG("ndp16_datagram index:%02x, length:%02x\r\n", ndp16_datagram->wDatagramIndex, ndp16_datagram->wDatagramLength);
322 
323                     uint8_t *buf = (uint8_t *)&g_cdc_ncm_rx_buffer[ndp16_datagram->wDatagramIndex];
324                     usbh_cdc_ncm_eth_input(buf, ndp16_datagram->wDatagramLength);
325                 }
326             }
327 
328             g_cdc_ncm_rx_length = 0;
329         } else {
330 #if CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE <= (16 * 1024)
331             if (g_cdc_ncm_rx_length == CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE) {
332 #else
333             if ((g_cdc_ncm_rx_length + (16 * 1024)) > CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE) {
334 #endif
335                 USB_LOG_ERR("Rx packet is overflow, please reduce tcp window size or increase CONFIG_USBHOST_CDC_NCM_ETH_MAX_RX_SIZE\r\n");
336                 while (1) {
337                 }
338             }
339         }
340     }
341     // clang-format off
342 delete:
343     USB_LOG_INFO("Delete cdc ncm rx thread\r\n");
344     usb_osal_thread_delete(NULL);
345     // clang-format on
346 }
347 
348 uint8_t *usbh_cdc_ncm_get_eth_txbuf(void)
349 {
350     return &g_cdc_ncm_tx_buffer[16];
351 }
352 
353 int usbh_cdc_ncm_eth_output(uint32_t buflen)
354 {
355     struct cdc_ncm_ndp16_datagram *ndp16_datagram;
356 
357     if (g_cdc_ncm_class.connect_status == false) {
358         return -USB_ERR_NOTCONN;
359     }
360 
361     struct cdc_ncm_nth16 *nth16 = (struct cdc_ncm_nth16 *)&g_cdc_ncm_tx_buffer[0];
362 
363     nth16->dwSignature = CDC_NCM_NTH16_SIGNATURE;
364     nth16->wHeaderLength = 12;
365     nth16->wSequence = g_cdc_ncm_class.bulkout_sequence++;
366     nth16->wBlockLength = 16 + 16 + USB_ALIGN_UP(buflen, 4);
367     nth16->wNdpIndex = 16 + USB_ALIGN_UP(buflen, 4);
368 
369     struct cdc_ncm_ndp16 *ndp16 = (struct cdc_ncm_ndp16 *)&g_cdc_ncm_tx_buffer[nth16->wNdpIndex];
370 
371     ndp16->dwSignature = CDC_NCM_NDP16_SIGNATURE_NCM0;
372     ndp16->wLength = 16;
373     ndp16->wNextNdpIndex = 0;
374 
375     ndp16_datagram = (struct cdc_ncm_ndp16_datagram *)&g_cdc_ncm_tx_buffer[nth16->wNdpIndex + 8 + 4 * 0];
376     ndp16_datagram->wDatagramIndex = 16;
377     ndp16_datagram->wDatagramLength = buflen;
378 
379     ndp16_datagram = (struct cdc_ncm_ndp16_datagram *)&g_cdc_ncm_tx_buffer[nth16->wNdpIndex + 8 + 4 * 1];
380     ndp16_datagram->wDatagramIndex = 0;
381     ndp16_datagram->wDatagramLength = 0;
382 
383     USB_LOG_DBG("txlen:%d\r\n", nth16->wBlockLength);
384 
385     usbh_bulk_urb_fill(&g_cdc_ncm_class.bulkout_urb, g_cdc_ncm_class.hport, g_cdc_ncm_class.bulkout, g_cdc_ncm_tx_buffer, nth16->wBlockLength, USB_OSAL_WAITING_FOREVER, NULL, NULL);
386     return usbh_submit_urb(&g_cdc_ncm_class.bulkout_urb);
387 }
388 
389 __WEAK void usbh_cdc_ncm_run(struct usbh_cdc_ncm *cdc_ncm_class)
390 {
391     (void)cdc_ncm_class;
392 }
393 
394 __WEAK void usbh_cdc_ncm_stop(struct usbh_cdc_ncm *cdc_ncm_class)
395 {
396     (void)cdc_ncm_class;
397 }
398 
399 const struct usbh_class_driver cdc_ncm_class_driver = {
400     .driver_name = "cdc_ncm",
401     .connect = usbh_cdc_ncm_connect,
402     .disconnect = usbh_cdc_ncm_disconnect
403 };
404 
405 CLASS_INFO_DEFINE const struct usbh_class_info cdc_ncm_class_info = {
406     .match_flags = USB_CLASS_MATCH_INTF_CLASS | USB_CLASS_MATCH_INTF_SUBCLASS | USB_CLASS_MATCH_INTF_PROTOCOL,
407     .bInterfaceClass = USB_DEVICE_CLASS_CDC,
408     .bInterfaceSubClass = CDC_NETWORK_CONTROL_MODEL,
409     .bInterfaceProtocol = CDC_COMMON_PROTOCOL_NONE,
410     .id_table = NULL,
411     .class_driver = &cdc_ncm_class_driver
412 };
413