1 /*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2012-10-01 Yi Qiu first version
9 * 2012-12-12 heyuanjie87 change endpoint and function handler
10 * 2013-04-26 aozima add DEVICEQUALIFIER support.
11 * 2017-11-15 ZYH fix ep0 transform error
12 * 2023-10-11 ChuShicheng change rt_size_t to rt_ssize_t
13 */
14
15 #ifndef __USB_DEVICE_H__
16 #define __USB_DEVICE_H__
17
18 #include <rtthread.h>
19 #include "drivers/usb_common.h"
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 /* Vendor ID */
26 #ifdef USB_VENDOR_ID
27 #define _VENDOR_ID USB_VENDOR_ID
28 #else
29 #define _VENDOR_ID 0x0EFF
30 #endif
31 /* Product ID */
32 #ifdef USB_PRODUCT_ID
33 #define _PRODUCT_ID USB_PRODUCT_ID
34 #else
35 #define _PRODUCT_ID 0x0001
36 #endif
37
38 #ifndef MAX_INTF_STR
39 #define MAX_INTF_STR 20
40 #endif
41
42 #define USB_BCD_DEVICE 0x0200 /* USB Specification Release Number in Binary-Coded Decimal */
43 #define USB_BCD_VERSION 0x0200 /* USB 2.0 */
44 #define EP0_IN_ADDR 0x80
45 #define EP0_OUT_ADDR 0x00
46 #define EP_HANDLER(ep, func, size) RT_ASSERT(ep != RT_NULL); ep->handler(func, size)
47 #define EP_ADDRESS(ep) ep->ep_desc->bEndpointAddress
48 #define EP_MAXPACKET(ep) ep->ep_desc->wMaxPacketSize
49 #define FUNC_ENABLE(func) do{ \
50 if(func->ops->enable != RT_NULL && \
51 func->enabled == RT_FALSE) \
52 { \
53 if(func->ops->enable(func) == RT_EOK) \
54 func->enabled = RT_TRUE; \
55 } \
56 }while(0)
57 #define FUNC_DISABLE(func) do{ \
58 if(func->ops->disable != RT_NULL && \
59 func->enabled == RT_TRUE) \
60 { \
61 func->enabled = RT_FALSE; \
62 func->ops->disable(func); \
63 } \
64 }while(0)
65
66 #define RT_USBD_CLASS_CTRL_CONNECTED (RT_DEVICE_CTRL_BASE(USBDevice) + 0)
67
68 struct ufunction;
69 struct udevice;
70 struct uendpoint;
71
72 typedef enum
73 {
74 /* request to read full count */
75 UIO_REQUEST_READ_FULL,
76 /* request to read any count */
77 UIO_REQUEST_READ_BEST,
78 /* request to write full count */
79 UIO_REQUEST_WRITE,
80 }UIO_REQUEST_TYPE;
81
82 struct udcd_ops
83 {
84 rt_err_t (*set_address)(rt_uint8_t address);
85 rt_err_t (*set_config)(rt_uint8_t address);
86 rt_err_t (*ep_set_stall)(rt_uint8_t address);
87 rt_err_t (*ep_clear_stall)(rt_uint8_t address);
88 rt_err_t (*ep_enable)(struct uendpoint* ep);
89 rt_err_t (*ep_disable)(struct uendpoint* ep);
90 rt_ssize_t (*ep_read_prepare)(rt_uint8_t address, void *buffer, rt_size_t size);
91 rt_ssize_t (*ep_read)(rt_uint8_t address, void *buffer);
92 rt_ssize_t (*ep_write)(rt_uint8_t address, void *buffer, rt_size_t size);
93 rt_err_t (*ep0_send_status)(void);
94 rt_err_t (*suspend)(void);
95 rt_err_t (*wakeup)(void);
96 };
97
98 struct ep_id
99 {
100 rt_uint8_t addr;
101 rt_uint8_t type;
102 rt_uint8_t dir;
103 rt_uint16_t maxpacket;
104 rt_uint8_t status;
105 };
106
107 typedef rt_err_t (*udep_handler_t)(struct ufunction* func, rt_size_t size);
108
109 struct uio_request
110 {
111 rt_list_t list;
112 UIO_REQUEST_TYPE req_type;
113 rt_uint8_t* buffer;
114 rt_size_t size;
115 rt_size_t remain_size;
116 };
117 typedef struct uio_request* uio_request_t;
118
119 struct uendpoint
120 {
121 rt_list_t list;
122 uep_desc_t ep_desc;
123 rt_list_t request_list;
124 struct uio_request request;
125 rt_uint8_t* buffer;
126 rt_bool_t stalled;
127 struct ep_id* id;
128 udep_handler_t handler;
129 rt_err_t (*rx_indicate)(struct udevice* dev, rt_size_t size);
130 };
131 typedef struct uendpoint* uep_t;
132
133 struct udcd
134 {
135 struct rt_device parent;
136 const struct udcd_ops* ops;
137 struct uendpoint ep0;
138 uep0_stage_t stage;
139 struct ep_id* ep_pool;
140 rt_uint8_t device_is_hs;
141 };
142 typedef struct udcd* udcd_t;
143
144 struct ualtsetting
145 {
146 rt_list_t list;
147 uintf_desc_t intf_desc;
148 void* desc;
149 rt_size_t desc_size;
150 rt_list_t ep_list;
151 };
152 typedef struct ualtsetting* ualtsetting_t;
153
154 typedef rt_err_t (*uintf_handler_t)(struct ufunction* func, ureq_t setup);
155
156 struct uinterface
157 {
158 rt_list_t list;
159 rt_uint8_t intf_num;
160 ualtsetting_t curr_setting;
161 rt_list_t setting_list;
162 uintf_handler_t handler;
163 };
164 typedef struct uinterface* uintf_t;
165
166 struct ufunction_ops
167 {
168 rt_err_t (*enable)(struct ufunction* func);
169 rt_err_t (*disable)(struct ufunction* func);
170 rt_err_t (*sof_handler)(struct ufunction* func);
171 };
172 typedef struct ufunction_ops* ufunction_ops_t;
173
174 struct ufunction
175 {
176 rt_list_t list;
177 ufunction_ops_t ops;
178 struct udevice* device;
179 udev_desc_t dev_desc;
180 void* user_data;
181 rt_bool_t enabled;
182
183 rt_list_t intf_list;
184 };
185 typedef struct ufunction* ufunction_t;
186
187 struct uconfig
188 {
189 rt_list_t list;
190 struct uconfig_descriptor cfg_desc;
191 rt_list_t func_list;
192 };
193 typedef struct uconfig* uconfig_t;
194
195 struct udevice
196 {
197 rt_list_t list;
198 struct udevice_descriptor dev_desc;
199
200 struct usb_qualifier_descriptor * dev_qualifier;
201 usb_os_comp_id_desc_t os_comp_id_desc;
202 const char** str;
203 const char *str_intf[MAX_INTF_STR];
204 udevice_state_t state;
205 rt_list_t cfg_list;
206 uconfig_t curr_cfg;
207 rt_uint8_t nr_intf;
208
209 udcd_t dcd;
210 };
211 typedef struct udevice* udevice_t;
212
213 struct udclass
214 {
215 rt_list_t list;
216 ufunction_t (*rt_usbd_function_create)(udevice_t device);
217 };
218 typedef struct udclass* udclass_t;
219
220 enum udev_msg_type
221 {
222 USB_MSG_SETUP_NOTIFY,
223 USB_MSG_DATA_NOTIFY,
224 USB_MSG_EP0_OUT,
225 USB_MSG_EP_CLEAR_FEATURE,
226 USB_MSG_SOF,
227 USB_MSG_RESET,
228 USB_MSG_PLUG_IN,
229 /* we don't need to add a "PLUG_IN" event because after the cable is
230 * plugged in(before any SETUP) the classed have nothing to do. If the host
231 * is ready, it will send RESET and we will have USB_MSG_RESET. So, a RESET
232 * should reset and run the class while plug_in is not. */
233 USB_MSG_PLUG_OUT,
234 };
235 typedef enum udev_msg_type udev_msg_type;
236
237 struct ep_msg
238 {
239 rt_size_t size;
240 rt_uint8_t ep_addr;
241 };
242
243 struct udev_msg
244 {
245 udev_msg_type type;
246 udcd_t dcd;
247 union
248 {
249 struct ep_msg ep_msg;
250 struct urequest setup;
251 } content;
252 };
253 typedef struct udev_msg* udev_msg_t;
254
255 int rt_usbd_class_list_init(void);
256 udevice_t rt_usbd_device_new(void);
257 uconfig_t rt_usbd_config_new(void);
258 ufunction_t rt_usbd_function_new(udevice_t device, udev_desc_t dev_desc,
259 ufunction_ops_t ops);
260 uintf_t rt_usbd_interface_new(udevice_t device, uintf_handler_t handler);
261 uep_t rt_usbd_endpoint_new(uep_desc_t ep_desc, udep_handler_t handler);
262 ualtsetting_t rt_usbd_altsetting_new(rt_size_t desc_size);
263
264 rt_err_t rt_usbd_core_init(void);
265 rt_err_t rt_usb_device_init(void);
266 rt_err_t rt_usbd_event_signal(struct udev_msg* msg);
267 rt_err_t rt_usbd_device_set_controller(udevice_t device, udcd_t dcd);
268 rt_err_t rt_usbd_device_set_descriptor(udevice_t device, udev_desc_t dev_desc);
269 rt_err_t rt_usbd_device_set_string(udevice_t device, const char** ustring);
270 rt_err_t rt_usbd_device_set_interface_string(udevice_t device, int index, const char* string);
271 rt_err_t rt_usbd_device_set_qualifier(udevice_t device, struct usb_qualifier_descriptor* qualifier);
272 rt_err_t rt_usbd_device_set_os_comp_id_desc(udevice_t device, usb_os_comp_id_desc_t os_comp_id_desc);
273 rt_err_t rt_usbd_device_add_config(udevice_t device, uconfig_t cfg);
274 rt_err_t rt_usbd_config_add_function(uconfig_t cfg, ufunction_t func);
275 rt_err_t rt_usbd_class_register(udclass_t udclass);
276 rt_err_t rt_usbd_function_add_interface(ufunction_t func, uintf_t intf);
277 rt_err_t rt_usbd_interface_add_altsetting(uintf_t intf, ualtsetting_t setting);
278 rt_err_t rt_usbd_altsetting_add_endpoint(ualtsetting_t setting, uep_t ep);
279 rt_err_t rt_usbd_os_comp_id_desc_add_os_func_comp_id_desc(usb_os_comp_id_desc_t os_comp_id_desc, usb_os_func_comp_id_desc_t os_func_comp_id_desc);
280 rt_err_t rt_usbd_altsetting_config_descriptor(ualtsetting_t setting, const void* desc, rt_off_t intf_pos);
281 rt_err_t rt_usbd_set_config(udevice_t device, rt_uint8_t value);
282 rt_err_t rt_usbd_set_altsetting(uintf_t intf, rt_uint8_t value);
283
284 udevice_t rt_usbd_find_device(udcd_t dcd);
285 uconfig_t rt_usbd_find_config(udevice_t device, rt_uint8_t value);
286 uintf_t rt_usbd_find_interface(udevice_t device, rt_uint8_t value, ufunction_t *pfunc);
287 uep_t rt_usbd_find_endpoint(udevice_t device, ufunction_t* pfunc, rt_uint8_t ep_addr);
288 rt_size_t rt_usbd_io_request(udevice_t device, uep_t ep, uio_request_t req);
289 rt_size_t rt_usbd_ep0_write(udevice_t device, void *buffer, rt_size_t size);
290 rt_size_t rt_usbd_ep0_read(udevice_t device, void *buffer, rt_size_t size,
291 rt_err_t (*rx_ind)(udevice_t device, rt_size_t size));
292
293 int rt_usbd_vcom_class_register(void);
294 int rt_usbd_ecm_class_register(void);
295 int rt_usbd_hid_class_register(void);
296 int rt_usbd_msc_class_register(void);
297 int rt_usbd_rndis_class_register(void);
298 int rt_usbd_winusb_class_register(void);
299
300 #ifdef RT_USB_DEVICE_COMPOSITE
301 rt_err_t rt_usbd_function_set_iad(ufunction_t func, uiad_desc_t iad_desc);
302 #endif
303
304 rt_err_t rt_usbd_set_feature(udevice_t device, rt_uint16_t value, rt_uint16_t index);
305 rt_err_t rt_usbd_clear_feature(udevice_t device, rt_uint16_t value, rt_uint16_t index);
306 rt_err_t rt_usbd_ep_set_stall(udevice_t device, uep_t ep);
307 rt_err_t rt_usbd_ep_clear_stall(udevice_t device, uep_t ep);
308 rt_err_t rt_usbd_ep0_set_stall(udevice_t device);
309 rt_err_t rt_usbd_ep0_clear_stall(udevice_t device);
310 rt_err_t rt_usbd_ep0_setup_handler(udcd_t dcd, struct urequest* setup);
311 rt_err_t rt_usbd_ep0_in_handler(udcd_t dcd);
312 rt_err_t rt_usbd_ep0_out_handler(udcd_t dcd, rt_size_t size);
313 rt_err_t rt_usbd_ep_in_handler(udcd_t dcd, rt_uint8_t address, rt_size_t size);
314 rt_err_t rt_usbd_ep_out_handler(udcd_t dcd, rt_uint8_t address, rt_size_t size);
315 rt_err_t rt_usbd_reset_handler(udcd_t dcd);
316 rt_err_t rt_usbd_connect_handler(udcd_t dcd);
317 rt_err_t rt_usbd_disconnect_handler(udcd_t dcd);
318 rt_err_t rt_usbd_sof_handler(udcd_t dcd);
319
dcd_set_address(udcd_t dcd,rt_uint8_t address)320 rt_inline rt_err_t dcd_set_address(udcd_t dcd, rt_uint8_t address)
321 {
322 RT_ASSERT(dcd != RT_NULL);
323 RT_ASSERT(dcd->ops != RT_NULL);
324 RT_ASSERT(dcd->ops->set_address != RT_NULL);
325
326 return dcd->ops->set_address(address);
327 }
328
dcd_set_config(udcd_t dcd,rt_uint8_t address)329 rt_inline rt_err_t dcd_set_config(udcd_t dcd, rt_uint8_t address)
330 {
331 RT_ASSERT(dcd != RT_NULL);
332 RT_ASSERT(dcd->ops != RT_NULL);
333 RT_ASSERT(dcd->ops->set_config != RT_NULL);
334
335 return dcd->ops->set_config(address);
336 }
337
dcd_ep_enable(udcd_t dcd,uep_t ep)338 rt_inline rt_err_t dcd_ep_enable(udcd_t dcd, uep_t ep)
339 {
340 RT_ASSERT(dcd != RT_NULL);
341 RT_ASSERT(dcd->ops != RT_NULL);
342 RT_ASSERT(dcd->ops->ep_enable != RT_NULL);
343
344 return dcd->ops->ep_enable(ep);
345 }
346
dcd_ep_disable(udcd_t dcd,uep_t ep)347 rt_inline rt_err_t dcd_ep_disable(udcd_t dcd, uep_t ep)
348 {
349 RT_ASSERT(dcd != RT_NULL);
350 RT_ASSERT(dcd->ops != RT_NULL);
351 RT_ASSERT(dcd->ops->ep_disable != RT_NULL);
352
353 return dcd->ops->ep_disable(ep);
354 }
355
dcd_ep_read_prepare(udcd_t dcd,rt_uint8_t address,void * buffer,rt_size_t size)356 rt_inline rt_size_t dcd_ep_read_prepare(udcd_t dcd, rt_uint8_t address, void *buffer,
357 rt_size_t size)
358 {
359 RT_ASSERT(dcd != RT_NULL);
360 RT_ASSERT(dcd->ops != RT_NULL);
361
362 if(dcd->ops->ep_read_prepare != RT_NULL)
363 {
364 return dcd->ops->ep_read_prepare(address, buffer, size);
365 }
366 else
367 {
368 return 0;
369 }
370 }
371
dcd_ep_read(udcd_t dcd,rt_uint8_t address,void * buffer)372 rt_inline rt_size_t dcd_ep_read(udcd_t dcd, rt_uint8_t address, void *buffer)
373 {
374 RT_ASSERT(dcd != RT_NULL);
375 RT_ASSERT(dcd->ops != RT_NULL);
376
377 if(dcd->ops->ep_read != RT_NULL)
378 {
379 return dcd->ops->ep_read(address, buffer);
380 }
381 else
382 {
383 return 0;
384 }
385 }
386
dcd_ep_write(udcd_t dcd,rt_uint8_t address,void * buffer,rt_size_t size)387 rt_inline rt_size_t dcd_ep_write(udcd_t dcd, rt_uint8_t address, void *buffer,
388 rt_size_t size)
389 {
390 RT_ASSERT(dcd != RT_NULL);
391 RT_ASSERT(dcd->ops != RT_NULL);
392 RT_ASSERT(dcd->ops->ep_write != RT_NULL);
393
394 return dcd->ops->ep_write(address, buffer, size);
395 }
396
dcd_ep0_send_status(udcd_t dcd)397 rt_inline rt_err_t dcd_ep0_send_status(udcd_t dcd)
398 {
399 RT_ASSERT(dcd != RT_NULL);
400 RT_ASSERT(dcd->ops != RT_NULL);
401 RT_ASSERT(dcd->ops->ep0_send_status != RT_NULL);
402
403 return dcd->ops->ep0_send_status();
404 }
405
dcd_ep_set_stall(udcd_t dcd,rt_uint8_t address)406 rt_inline rt_err_t dcd_ep_set_stall(udcd_t dcd, rt_uint8_t address)
407 {
408 RT_ASSERT(dcd != RT_NULL);
409 RT_ASSERT(dcd->ops != RT_NULL);
410 RT_ASSERT(dcd->ops->ep_set_stall != RT_NULL);
411
412 return dcd->ops->ep_set_stall(address);
413 }
414
dcd_ep_clear_stall(udcd_t dcd,rt_uint8_t address)415 rt_inline rt_err_t dcd_ep_clear_stall(udcd_t dcd, rt_uint8_t address)
416 {
417 RT_ASSERT(dcd != RT_NULL);
418 RT_ASSERT(dcd->ops != RT_NULL);
419 RT_ASSERT(dcd->ops->ep_clear_stall != RT_NULL);
420
421 return dcd->ops->ep_clear_stall(address);
422 }
usbd_os_proerty_descriptor_send(ufunction_t func,ureq_t setup,usb_os_proerty_t usb_os_proerty,rt_uint8_t number_of_proerty)423 rt_inline void usbd_os_proerty_descriptor_send(ufunction_t func, ureq_t setup, usb_os_proerty_t usb_os_proerty, rt_uint8_t number_of_proerty)
424 {
425 struct usb_os_property_header header;
426 static rt_uint8_t * data;
427 rt_uint8_t * pdata;
428 rt_uint8_t index,i;
429 if(data == RT_NULL)
430 {
431 header.dwLength = sizeof(struct usb_os_property_header);
432 header.bcdVersion = 0x0100;
433 header.wIndex = 0x05;
434 header.wCount = number_of_proerty;
435 for(index = 0;index < number_of_proerty;index++)
436 {
437 header.dwLength += usb_os_proerty[index].dwSize;
438 }
439 data = (rt_uint8_t *)rt_malloc(header.dwLength);
440 RT_ASSERT(data != RT_NULL);
441 pdata = data;
442 rt_memcpy((void *)pdata,(void *)&header,sizeof(struct usb_os_property_header));
443 pdata += sizeof(struct usb_os_property_header);
444 for(index = 0;index < number_of_proerty;index++)
445 {
446 rt_memcpy((void *)pdata,(void *)&usb_os_proerty[index],10);
447 pdata += 10;
448 for(i = 0;i < usb_os_proerty[index].wPropertyNameLength/2;i++)
449 {
450 *pdata = usb_os_proerty[index].bPropertyName[i];
451 pdata++;
452 *pdata = 0;
453 pdata++;
454 }
455 *((rt_uint32_t *)pdata) = usb_os_proerty[index].dwPropertyDataLength;
456 pdata += 4;
457 for(i = 0;i < usb_os_proerty[index].dwPropertyDataLength/2;i++)
458 {
459 *pdata = usb_os_proerty[index].bPropertyData[i];
460 pdata++;
461 *pdata = 0;
462 pdata++;
463 }
464 }
465 }
466 rt_usbd_ep0_write(func->device, data, setup->wLength);
467 }
468
469 #ifdef __cplusplus
470 }
471 #endif
472
473 #endif
474