source: azure_iot_hub_f767zi/trunk/asp_baseplatform/usb/device/tusbd_base.c@ 457

Last change on this file since 457 was 457, checked in by coas-nagasima, 4 years ago

ファイルを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 20.5 KB
Line 
1/*
2 * TOPPERS BASE PLATFORM MIDDLEWARE
3 *
4 * Copyright (C) 2017-2017 by TOPPERS PROJECT
5 * Educational Working Group.
6 *
7 * 上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
8 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
9 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
10 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
11 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
12 * スコード中に含まれていること．
13 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
14 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
15 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
16 * の無保証規定を掲載すること．
17 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
18 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
19 * と．
20 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
21 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
22 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
23 * 報告すること．
24 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
25 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
26 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
27 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
28 * 免責すること．
29 *
30 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
31 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
32 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
33 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
34 * の責任を負わない．
35 *
36 * @(#) $Id$
37 */
38/*
39 * USB Device Middleware BASE部
40 */
41
42#include "tusbd_base.h"
43#include "tusbd_device.h"
44
45
46#define NUM_MAX_REQUEST 13
47#define NUM_STRING_TABLE 7
48
49static void DeviceGetStatus(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
50static void DeviceClearFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
51static void DeviceSetFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
52static void DeviceGetDescriptor(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
53static void DeviceSetAddress(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
54static void DeviceGetConfiguration(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
55static void DeviceSetConfiguration(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
56static void EndpointGetStatus(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
57static void EndpointClearFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
58static void EndpointSetFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req);
59
60
61/*
62 * DEVICE REQUEST関数テーブル
63 */
64static void (*usb_pbRequestDev[NUM_MAX_REQUEST])(TUSBD_Handle_t *pdevice, UsbSetupRequest *req) = {
65 DeviceGetStatus, DeviceClearFeature, tusbdControlSendStall, DeviceSetFeature,
66 tusbdControlSendStall, DeviceSetAddress, DeviceGetDescriptor, tusbdControlSendStall,
67 DeviceGetConfiguration, DeviceSetConfiguration, tusbdControlSendStall, tusbdControlSendStall,
68 tusbdControlSendStall
69};
70
71/*
72 * ENDPOINT REQUEST関数テーブル
73 */
74static void (*usb_pbRequestEp[NUM_MAX_REQUEST])(TUSBD_Handle_t *pdevice, UsbSetupRequest *req) = {
75 EndpointGetStatus, EndpointClearFeature, tusbdControlSendStall, EndpointSetFeature,
76 tusbdControlSendStall, tusbdControlSendStall, tusbdControlSendStall, tusbdControlSendStall,
77 tusbdControlSendStall, tusbdControlSendStall, tusbdControlSendStall, tusbdControlSendStall,
78 tusbdControlSendStall
79};
80
81static uint8_t *usb_string_table[NUM_STRING_TABLE] = {
82 TUSBD_LANGUAGEID_DESCRIPTOR,
83 TUSBD_MANUFACTURER_STRING,
84 TUSBD_PRODUCT_STRING,
85 TUSBD_SERIAL_STRING,
86 TUSBD_CONFIGURATION_STRING,
87 TUSBD_INTERFACE_STRING,
88 TUSBD_USER_STRING
89};
90
91
92/*
93 * DEVICE REQUEST GET STATUS
94 */
95static void
96DeviceGetStatus(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
97{
98 switch (pdevice->dev_state){
99 case TUSBD_STATE_ADDRESSED:
100 case TUSBD_STATE_CONFIGURED:
101 pdevice->devData[0] = TUSBD_CONFIG_SELF_POWERED;
102 pdevice->devData[1] = 0;
103 if(pdevice->dev_remote_wakeup)
104 pdevice->devData[0] |= TUSBD_CONFIG_REMOTE_WAKEUP;
105 tusbdControlSendData(pdevice, (uint8_t *)pdevice->devData, 2);
106 break;
107 default:
108 tusbdControlSendStall(pdevice, req);
109 break;
110 }
111}
112
113/*
114 * DEVICE REQUEST CLEAR FEATURE
115 */
116static void
117DeviceClearFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
118{
119 switch (pdevice->dev_state){
120 case TUSBD_STATE_ADDRESSED:
121 case TUSBD_STATE_CONFIGURED:
122 if(req->wValue == USB_FEATURE_REMOTE_WAKEUP){
123 pdevice->dev_remote_wakeup = 0;
124 tusbdClassSetup(pdevice, req);
125 tusbdControlSendStatus(pdevice);
126 }
127 break;
128 default:
129 tusbdControlSendStall(pdevice, req);
130 break;
131 }
132}
133
134/*
135 * DEVICE REQUEST SET FEATURE
136 */
137static void
138DeviceSetFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
139{
140 if(req->wValue == USB_FEATURE_REMOTE_WAKEUP){
141 pdevice->dev_remote_wakeup = 1;
142 tusbdClassSetup(pdevice, req);
143 tusbdControlSendStatus(pdevice);
144 }
145}
146
147/*
148 * DEVICE REQUEST GET DESCRIPTOR
149 */
150static void
151DeviceGetDescriptor(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
152{
153 uint16_t len;
154 uint8_t *pbuf;
155
156 switch (req->wValue >> 8){
157#if defined(TUSBD_BOS_DESCRIPTOR)
158 case BOS_DESCRIPTOR:
159 pbuf = TUSBD_BOS_DESCRIPTOR;
160 len = TUSBD_BOS_DESCRIPTOR[0];
161 break;
162#endif
163 case DEVICE_DESCRIPTOR:
164 pbuf = TUSBD_DEVICE_DESCRIPTOR;
165 len = TUSBD_DEVICE_DESCRIPTOR[0];
166 break;
167 case CONFIGURATION_DESCRIPTOR:
168 if(pdevice->dev_speed == USB_DEVICE_SPEED_HIGH){
169 pbuf = TUSBD_HS_CONFIG_DESCRIPTOR;
170 len = TUSBD_HS_CONFIG_DESC_LENGTH;
171 }
172 else{
173 pbuf = TUSBD_FS_CONFIG_DESCRIPTOR;
174 len = TUSBD_FS_CONFIG_DESC_LENGTH;
175 }
176 break;
177 case STRING_DESCRIPTOR:
178 if(((uint8_t)req->wValue) < NUM_STRING_TABLE){
179 pbuf = usb_string_table[(uint8_t)req->wValue];
180 if(pbuf == NULL){
181 tusbdControlSendStall(pdevice, req);
182 return;
183 }
184 len = pbuf[0];
185 }
186 else{
187 tusbdControlSendStall(pdevice, req);
188 return;
189 }
190 break;
191 case DEVICE_QUALIFIER_DESCRIPTOR:
192 if(pdevice->dev_speed == USB_DEVICE_SPEED_HIGH){
193 pbuf = TUSBD_DEVICE_QUALIFIER_DESCRIPTOR;
194 len = TUSBD_DEVICE_QUALIFIER_DESCRIPTOR[0];
195 break;
196 }
197 else{
198 tusbdControlSendStall(pdevice, req);
199 return;
200 }
201 case OTHER_SPEED_CONFIGURATION_DESC:
202 if(pdevice->dev_speed == USB_DEVICE_SPEED_HIGH){
203 pbuf = TUSBD_OTR_CONFIG_DESCRIPTOR;
204 len = TUSBD_OTR_CONFIG_DESC_LENGTH;
205 break;
206 }
207 else{
208 tusbdControlSendStall(pdevice, req);
209 return;
210 }
211 default:
212 tusbdControlSendStall(pdevice, req);
213 return;
214 }
215
216 if(len != 0 && req->wLength != 0){
217 if(len > req->wLength)
218 len = req->wLength;
219 tusbdControlSendData(pdevice, pbuf, len);
220 }
221}
222
223/*
224 * DEVICE REQUEST SET ADDRESS
225 */
226static void
227DeviceSetAddress(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
228{
229 uint8_t dev_addr;
230
231 if(req->wIndex == 0 && req->wLength == 0){
232 dev_addr = (uint8_t)(req->wValue) & 0x7F;
233 if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
234 tusbdControlSendStall(pdevice , req);
235 }
236 else{
237 pdevice->dev_address = dev_addr;
238 tusbdDriverSetUSBAddress(pdevice, dev_addr);
239 tusbdControlSendStatus(pdevice);
240 if(dev_addr != 0){
241 pdevice->dev_state = TUSBD_STATE_ADDRESSED;
242 }
243 else{
244 pdevice->dev_state = TUSBD_STATE_INIT;
245 }
246 }
247 }
248 else{
249 tusbdControlSendStall(pdevice, req);
250 }
251}
252
253/*
254 * DEVICE REQUEST GET CONFIGURATION
255 */
256static void
257DeviceGetConfiguration(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
258{
259 if(req->wLength != 1){
260 tusbdControlSendStall(pdevice , req);
261 }
262 else{
263 switch (pdevice->dev_state){
264 case TUSBD_STATE_ADDRESSED:
265 pdevice->devData[0] = 0;
266 tusbdControlSendData(pdevice, (uint8_t *)pdevice->devData, 1);
267 break;
268 case TUSBD_STATE_CONFIGURED:
269 pdevice->devData[0] = pdevice->dev_config;
270 tusbdControlSendData(pdevice, (uint8_t *)pdevice->devData, 1);
271 break;
272 default:
273 tusbdControlSendStall(pdevice, req);
274 break;
275 }
276 }
277}
278
279/*
280 * DEVICE REQUEST SET CONFIGURATION
281 */
282static void
283DeviceSetConfiguration(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
284{
285 uint8_t cfgidx;
286
287 cfgidx = (uint8_t)(req->wValue);
288 if(cfgidx > TUSBD_MAX_NUM_CONFIGURATION){
289 tusbdControlSendStall(pdevice , req);
290 return;
291 }
292
293 switch (pdevice->dev_state){
294 case TUSBD_STATE_ADDRESSED:
295 if(cfgidx){
296 pdevice->dev_config = cfgidx;
297 pdevice->dev_state = TUSBD_STATE_CONFIGURED;
298 if(tusbdClassInit(pdevice, cfgidx) != TUSBD_E_OK){
299 tusbdControlSendStall(pdevice , req);
300 return;
301 }
302 tusbdControlSendStatus(pdevice);
303 }
304 else{
305 tusbdControlSendStatus(pdevice);
306 }
307 break;
308 case TUSBD_STATE_CONFIGURED:
309 if(cfgidx == 0){
310 pdevice->dev_state = TUSBD_STATE_ADDRESSED;
311 pdevice->dev_config = cfgidx;
312 tusbdClassDeInit(pdevice, cfgidx);
313 tusbdControlSendStatus(pdevice);
314 }
315 else if(cfgidx != pdevice->dev_config){
316 /*
317 * 古いCONFIGURATIONをリセット
318 */
319 tusbdClassDeInit(pdevice, cfgidx);
320
321 /*
322 * 新しいCONFIGURATIONで初期化
323 */
324 pdevice->dev_config = cfgidx;
325 if(tusbdClassInit(pdevice, cfgidx) != TUSBD_E_OK){
326 tusbdControlSendStall(pdevice , req);
327 return;
328 }
329 tusbdControlSendStatus(pdevice);
330 }
331 else{
332 tusbdControlSendStatus(pdevice);
333 }
334 break;
335 default:
336 tusbdControlSendStall(pdevice, req);
337 break;
338 }
339}
340
341/*
342 * ENDPOINT REQUEST GET STATUS
343 */
344static void
345EndpointGetStatus(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
346{
347 TUSBD_Endpoint_t *pep;
348 uint8_t ep_addr = req->wIndex & 0xFF;
349
350 switch (pdevice->dev_state){
351 case TUSBD_STATE_ADDRESSED:
352 if((ep_addr & 0x7F) != 0x00){
353 tusbdDriverStallEp(pdevice , ep_addr);
354 }
355 break;
356 case TUSBD_STATE_CONFIGURED:
357 pep = ((ep_addr & USB_DEVICE_TO_HOST) != 0) ? &pdevice->ep_in[ep_addr & 0x7F] : &pdevice->ep_out[ep_addr & 0x7F];
358 if(tusbdDriverStallConditionEp(pdevice, ep_addr)){
359 pep->status = 0x0001;
360 }
361 else{
362 pep->status = 0x0000;
363 }
364 tusbdControlSendData(pdevice, (uint8_t *)&pep->status, 2);
365 break;
366 default:
367 tusbdControlSendStall(pdevice, req);
368 break;
369 }
370}
371
372/*
373 * ENDPOINT REQUEST CLEAR FEATURE
374 */
375static void
376EndpointClearFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
377{
378 uint8_t ep_addr = req->wIndex & 0xFF;
379
380 switch (pdevice->dev_state){
381 case TUSBD_STATE_ADDRESSED:
382 if((ep_addr & 0x7F) != 0x00){
383 tusbdDriverStallEp(pdevice , ep_addr);
384 }
385 break;
386 case TUSBD_STATE_CONFIGURED:
387 if(req->wValue == USB_FEATURE_EP_HALT){
388 if((ep_addr & 0x7F) != 0x00){
389 tusbdDriverClearStallEp(pdevice , ep_addr);
390 tusbdClassSetup(pdevice, req);
391 }
392 tusbdControlSendStatus(pdevice);
393 }
394 break;
395 default:
396 tusbdControlSendStall(pdevice, req);
397 break;
398 }
399}
400
401/*
402 * ENDPOINT REQUEST SET FEATURE
403 */
404static void
405EndpointSetFeature(TUSBD_Handle_t *pdevice, UsbSetupRequest *req)
406{
407 uint8_t ep_addr = req->wIndex & 0xFF;
408
409 switch (pdevice->dev_state){
410 case TUSBD_STATE_ADDRESSED:
411 if((ep_addr & 0x7F) != 0x00){
412 tusbdDriverStallEp(pdevice , ep_addr);
413 }
414 break;
415 case TUSBD_STATE_CONFIGURED:
416 if(req->wValue == USB_FEATURE_EP_HALT){
417 if((ep_addr & 0x7F) != 0x00){
418 tusbdDriverStallEp(pdevice , ep_addr);
419 }
420 }
421 tusbdClassSetup(pdevice, req);
422 tusbdControlSendStatus(pdevice);
423 break;
424 default:
425 tusbdControlSendStall(pdevice, req);
426 break;
427 }
428}
429
430
431/*
432 * USB DEVICE初期化
433 * parameter1 pdevice: USB DEVICEハンドラ
434 * parameter2 id: デバイスID
435 * return TUSBD_ERCODE
436 */
437TUSBD_ERCODE
438tusbdInit(TUSBD_Handle_t *pdevice, uint8_t id)
439{
440 if(pdevice == NULL)
441 return TUSBD_E_ERR;
442
443 /*
444 * ハンドラ初期化
445 */
446 pdevice->dev_state = TUSBD_STATE_INIT;
447 pdevice->id = id;
448
449 /*
450 * ハードウェア初期化
451 */
452 return tusbdDriverInit(pdevice);
453}
454
455/*
456 * USB DEVICE終了
457 * parameter1 pdevice: USB DEVICEハンドラ
458 * return TUSBD_ERCODE
459 */
460TUSBD_ERCODE
461tusbdDeInit(TUSBD_Handle_t *pdevice)
462{
463 /*
464 * デバイス状態をリセットに
465 */
466 pdevice->dev_state = TUSBD_STATE_RESET;
467
468 /*
469 * ドライバクラスを停止
470 */
471 tusbdClassDeInit(pdevice, pdevice->dev_config);
472
473 /*
474 * ハードウェアを終了
475 */
476 return tusbdDriverDeInit(pdevice);
477}
478
479/*
480 * USB DEVICE開始
481 * parameter1 pdevice: USB DEVICEハンドラ
482 * return TUSBD_ERCODE
483 */
484TUSBD_ERCODE
485tusbdStart(TUSBD_Handle_t *pdevice)
486{
487 pdevice->ep0_state = TUSBD_EP0_IDLE;
488 /*
489 * USB DEVICEドライバ開始
490 */
491 return tusbdDriverStart(pdevice);
492}
493
494/*
495 * USB DEVICE 停止
496 * parameter1 pdevice: USB DEVICEハンドラ
497 * return TUSBD_ERCODE
498 */
499TUSBD_ERCODE
500tusbdStop(TUSBD_Handle_t *pdevice)
501{
502 /*
503 * ドライバクラス停止
504 */
505 tusbdClassDeInit(pdevice, pdevice->dev_config);
506
507 /*
508 * USB DEVICEドライバ停止
509 */
510 tusbdDriverStop(pdevice);
511 return TUSBD_E_OK;
512}
513
514
515/*
516 * USB DEVICE EP0 SETUP STAGE処理
517 * parameter1 pdevice: USB DEVICEハンドラ
518 * parameter2 psetup:セットアップデータ
519 * return TUSBD_ERCODE
520 */
521TUSBD_ERCODE
522tusbdSetupStage(TUSBD_Handle_t *pdevice, uint8_t *psetup)
523{
524 UsbSetupRequest *req = &pdevice->request;
525 volatile uint8_t *p = psetup;
526
527 req->bmRequest = p[0];
528 req->bRequest = p[1];
529 req->wValue = p[2] | (p[3] << 8);
530 req->wIndex = p[4] | (p[5] << 8);
531 req->wLength = p[6] | (p[7] << 8);
532
533 pdevice->ep0_state = TUSBD_EP0_SETUP;
534 pdevice->ep0_data_len = pdevice->request.wLength;
535
536 switch (pdevice->request.bmRequest & 0x1F){
537 case USB_RECIPIENT_DEVICE:
538 if(req->bRequest < NUM_MAX_REQUEST)
539 usb_pbRequestDev[req->bRequest](pdevice, req);
540 else
541 tusbdControlSendStall(pdevice, req);
542 break;
543 case USB_RECIPIENT_INTERFACE:
544 if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
545 if((req->wIndex & 0xFF) <= TUSBD_MAX_NUM_INTERFACES){
546 tusbdClassSetup(pdevice, req);
547 if(req->wLength == 0){
548 tusbdControlSendStatus(pdevice);
549 }
550 }
551 }
552 else
553 tusbdControlSendStall(pdevice, req);
554 break;
555 case USB_RECIPIENT_ENDPOINT:
556 if((req->bmRequest & USB_REQUEST_TYPE_MASK) == USB_REQUEST_TYPE_CLASS){
557 tusbdClassSetup(pdevice, req);
558 }
559 else{
560 if(req->bRequest < NUM_MAX_REQUEST)
561 usb_pbRequestEp[req->bRequest](pdevice, req);
562 else
563 tusbdControlSendStall(pdevice, req);
564 }
565 break;
566 default:
567 tusbdControlSendStall(pdevice, req);
568 break;
569 }
570 return TUSBD_E_OK;
571}
572
573/*
574 * USB DEVICE DATAOUT(受信) STAGE処理
575 * parameter1 pdevice: USB DEVICEハンドラ
576 * parameter2 epnum: エンドポイント番号
577 * parameter3 pdata: 現在の受信データポインタ
578 * return TUSBD_ERCODE
579 */
580TUSBD_ERCODE
581tusbdDataOutStage(TUSBD_Handle_t *pdevice, uint8_t epnum, uint8_t *pdata)
582{
583 if(epnum == 0){ /* エンドポイント#0 */
584 TUSBD_Endpoint_t *pep = &pdevice->ep_out[0];
585 if(pdevice->ep0_state == TUSBD_EP0_DATAOUT){
586 if(pep->remlength > pep->maxpacket){
587 pep->remlength -= pep->maxpacket;
588 if(pep->remlength < pep->maxpacket)
589 tusbdControlContinueReceive(pdevice, pdata, pep->remlength);
590 else
591 tusbdControlContinueReceive(pdevice, pdata, pep->maxpacket);
592 }
593 else{
594 if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
595 tusbdClassEp0RxReady(pdevice);
596 }
597 tusbdControlSendStatus(pdevice);
598 }
599 }
600 }
601 else if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
602 tusbdClassDataOut(pdevice, epnum);
603 }
604 return TUSBD_E_OK;
605}
606
607/*
608 * USB DEVICE DATAIN(送信) STAGE処理
609 * parameter1 pdevice: USB DEVICEハンドラ
610 * parameter2 epnum: エンドポイント番号
611 * parameter3 pdata: 現在の送信データポインタ
612 * return TUSBD_ERCODE
613 */
614TUSBD_ERCODE
615tusbdDataInStage(TUSBD_Handle_t *pdevice, uint8_t epnum, uint8_t *pdata)
616{
617 if(epnum == 0){ /* エンドポイント#0 */
618 TUSBD_Endpoint_t *pep = &pdevice->ep_in[0];
619 if(pdevice->ep0_state == TUSBD_EP0_DATAIN){
620 if(pep->remlength > pep->maxpacket){
621 pep->remlength -= pep->maxpacket;
622 tusbdControlContinueSendData(pdevice, pdata, pep->remlength);
623 /*
624 * 受信設定初期化
625 */
626 tusbdDriverSetupReceive(pdevice, 0, NULL, 0);
627 }
628 else{ /* ZERO LENGTH PACKET送信処理 */
629 if((pep->xfersize % pep->maxpacket) == 0 && pep->xfersize >= pep->maxpacket
630 && pep->xfersize < pdevice->ep0_data_len){
631 tusbdControlContinueSendData(pdevice , NULL, 0);
632 pdevice->ep0_data_len = 0;
633 /*
634 * 受信設定初期化
635 */
636 tusbdDriverSetupReceive(pdevice, 0, NULL, 0);
637 }
638 else{
639 if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
640 tusbdClassEp0TxSent(pdevice);
641 }
642 tusbdControlReceiveStatus(pdevice);
643 }
644 }
645 }
646 if(pdevice->dev_test_mode == 1){
647 tusbdDriverTestMode(pdevice);
648 pdevice->dev_test_mode = 0;
649 }
650 }
651 else if(pdevice->dev_state == TUSBD_STATE_CONFIGURED){
652 tusbdClassDataIn(pdevice, epnum);
653 }
654 return TUSBD_E_OK;
655}
656
657/*
658 * USB DEVICE RESET処理
659 * parameter1 pdevice: USB DEVICEハンドラ
660 * return TUSBD_ERCODE
661 */
662
663TUSBD_ERCODE
664tusbdReset(TUSBD_Handle_t *pdevice)
665{
666 /*
667 * エンドポイント#0 オープン
668 */
669 tusbdDriverOpenEp(pdevice, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
670 pdevice->ep_out[0].maxpacket = USB_MAX_EP0_SIZE;
671 tusbdDriverOpenEp(pdevice, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
672 pdevice->ep_in[0].maxpacket = USB_MAX_EP0_SIZE;
673
674 /*
675 * デバイスユーザーステートをデフォルトに
676 */
677 pdevice->dev_state = TUSBD_STATE_INIT;
678
679 /*
680 * デバイスクラスをリセット
681 */
682 return tusbdClassDeInit(pdevice, pdevice->dev_config);
683}
684
685
686/*
687 * USB DEVICE SETUP SPEED処理
688 * parameter1 pdevice: USB DEVICEハンドラ
689 * parameter2 speed: デバイススピード
690 * return TUSBD_ERCODE
691 */
692TUSBD_ERCODE
693tusbdSetSpeed(TUSBD_Handle_t *pdevice, uint8_t speed)
694{
695 pdevice->dev_speed = speed & 3;
696 if(pdevice->makeDescriptor != NULL)
697 pdevice->makeDescriptor(pdevice->dev_speed);
698 return TUSBD_E_OK;
699}
700
701/*
702 * USB DEVICE SUSPEND REQUEST処理
703 * parameter1 pdevice: USB DEVICEハンドラ
704 * return TUSBD_ERCODE
705 */
706TUSBD_ERCODE
707tusbdSuspend(TUSBD_Handle_t *pdevice)
708{
709 pdevice->dev_old_state = pdevice->dev_state;
710 pdevice->dev_state = TUSBD_STATE_SUSPENDED;
711 tusbdClassSuspend(pdevice);
712 return TUSBD_E_OK;
713}
714
715/*
716 * USB DEVICE RESUME REQUEST処理
717 * parameter1 pdevice: USB DEVICEハンドラ
718 * return TUSBD_ERCODE
719 */
720
721TUSBD_ERCODE
722tusbdResume(TUSBD_Handle_t *pdevice)
723{
724 pdevice->dev_state = pdevice->dev_old_state;
725 tusbdClassResume(pdevice);
726 return TUSBD_E_OK;
727}
728
729/*
730 * USB DEVICE ISOIN INCOMPLETE処理
731 * parameter1 pdevice: USB DEVICEハンドラ
732 * parameter2 epnum: エンドポイント番号
733 * return TUSBD_ERCODE
734 */
735TUSBD_ERCODE
736tusbdIsoInIncomplete(TUSBD_Handle_t *pdevice, uint8_t epnum)
737{
738 tusbdClassInIncomlete(pdevice, epnum);
739 return TUSBD_E_OK;
740}
741
742/*
743 * USB DEVICE ISOOUT INCOMPLETE処理
744 * parameter1 pdevice: USB DEVICEハンドラ
745 * parameter2 epnum: エンドポイント番号
746 * return TUSBD_ERCODE
747 */
748TUSBD_ERCODE
749tusbdIsoOutIncomplete(TUSBD_Handle_t *pdevice, uint8_t epnum)
750{
751 tusbdClassOutIncomlete(pdevice, epnum);
752 return TUSBD_E_OK;
753}
754
755/*
756 * USB DEVICE CONNECTED処理
757 * parameter1 pdevice: USB DEVICEハンドラ
758 * return TUSBD_ERCODE
759 */
760TUSBD_ERCODE
761tusbdDeviceConnected(TUSBD_Handle_t *pdevice)
762{
763 return TUSBD_E_OK;
764}
765
766/*
767 * USB DEVICE DISCONNECTED処理
768 * parameter1 pdevice: USB DEVICEハンドラ
769 * return TUSBD_ERCODE
770 */
771TUSBD_ERCODE
772tusbdDeviceDisconnected(TUSBD_Handle_t *pdevice)
773{
774 /* Free Class Resources */
775 pdevice->dev_state = TUSBD_STATE_INIT;
776 tusbdClassDeInit(pdevice, pdevice->dev_config);
777 return TUSBD_E_OK;
778}
779
780/*
781 * USB DEVICE SEARCH DIECRIPTOR
782 * parameter1 pdevice: USB DEVICEハンドラ
783 * parameter2 type: 検索DESCRIPTORタイプ
784 * return DESCRIPTORポインタ
785 */
786uint8_t *
787tusbdFindDescriptor(TUSBD_Handle_t *pdevice, uint8_t type)
788{
789 uint16_t wTotalLength;
790 uint8_t *cptr = TUSBD_FS_CONFIG_DESCRIPTOR;
791 uint8_t *dptr;
792
793 if(cptr == NULL)
794 return NULL;
795 if(cptr[0] != CONFIGURATION_DESCRIPTOR_LENGTH || cptr[1] != CONFIGURATION_DESCRIPTOR)
796 return NULL;
797
798 wTotalLength = cptr[2] | (cptr[3] << 8);
799 if(wTotalLength <= (CONFIGURATION_DESCRIPTOR_LENGTH+2))
800 return NULL;
801
802 dptr = cptr + CONFIGURATION_DESCRIPTOR_LENGTH;
803 do{
804 if(dptr[1] == type)
805 return dptr;
806 dptr += dptr[0]; /* bLength */
807 }while(dptr < (cptr + wTotalLength));
808 return NULL;
809}
810
811
Note: See TracBrowser for help on using the repository browser.