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