Upgrade Chopstx, change stack size
[gnuk/neug.git] / src / usb_stm32f103.c
1 #include <stdint.h>
2 #include <stdlib.h>
3
4 #include "sys.h"
5 #include "usb_lld.h"
6
7 #define USB_MAX_PACKET_SIZE 64  /* For FS device */
8
9 enum STANDARD_REQUESTS
10 {
11   GET_STATUS = 0,
12   CLEAR_FEATURE,
13   RESERVED1,
14   SET_FEATURE,
15   RESERVED2,
16   SET_ADDRESS,
17   GET_DESCRIPTOR,
18   SET_DESCRIPTOR,
19   GET_CONFIGURATION,
20   SET_CONFIGURATION,
21   GET_INTERFACE,
22   SET_INTERFACE,
23   SYNCH_FRAME,
24   TOTAL_REQUEST  /* Total number of Standard request */
25 };
26
27 /* The state machine states of a control pipe */
28 enum CONTROL_STATE
29 {
30   WAIT_SETUP,
31   SETTING_UP,
32   IN_DATA,
33   OUT_DATA,
34   LAST_IN_DATA,
35   WAIT_STATUS_IN,
36   WAIT_STATUS_OUT,
37   STALLED,
38   PAUSE
39 };
40
41 enum FEATURE_SELECTOR
42 {
43   ENDPOINT_STALL,
44   DEVICE_REMOTE_WAKEUP
45 };
46
47 struct DATA_INFO
48 {
49   uint8_t *addr;
50   uint16_t len;
51   uint8_t require_zlp;
52 };
53
54
55 struct DEVICE_INFO
56 {
57   uint8_t current_configuration;
58   uint8_t current_feature;
59   uint8_t state;
60   /**/
61   uint8_t bmRequestType;
62   uint8_t bRequest;
63   /**/
64   uint16_t value;
65 };
66
67 static struct DEVICE_INFO device_info;
68 static struct DATA_INFO data_info;
69
70 static struct DEVICE_INFO *const dev_p = &device_info;
71 static struct DATA_INFO *const data_p = &data_info;
72
73 #define REG_BASE  (0x40005C00UL) /* USB_IP Peripheral Registers base address */
74 #define PMA_ADDR  (0x40006000UL) /* USB_IP Packet Memory Area base address   */
75
76 /* Control register */
77 #define CNTR    ((volatile uint16_t *)(REG_BASE + 0x40))
78 /* Interrupt status register */
79 #define ISTR    ((volatile uint16_t *)(REG_BASE + 0x44))
80 /* Frame number register */
81 #define FNR     ((volatile uint16_t *)(REG_BASE + 0x48))
82 /* Device address register */
83 #define DADDR   ((volatile uint16_t *)(REG_BASE + 0x4C))
84 /* Buffer Table address register */
85 #define BTABLE  ((volatile uint16_t *)(REG_BASE + 0x50))
86
87 #define ISTR_CTR    (0x8000) /* Correct TRansfer (read-only bit) */
88 #define ISTR_OVR    (0x4000) /* OVeR/underrun (clear-only bit) */
89 #define ISTR_ERR    (0x2000) /* ERRor (clear-only bit) */
90 #define ISTR_WKUP   (0x1000) /* WaKe UP (clear-only bit) */
91 #define ISTR_SUSP   (0x0800) /* SUSPend (clear-only bit) */
92 #define ISTR_RESET  (0x0400) /* RESET (clear-only bit) */
93 #define ISTR_SOF    (0x0200) /* Start Of Frame (clear-only bit) */
94 #define ISTR_ESOF   (0x0100) /* Expected Start Of Frame (clear-only bit) */
95
96 #define ISTR_DIR    (0x0010)  /* DIRection of transaction (read-only bit)  */
97 #define ISTR_EP_ID  (0x000F)  /* EndPoint IDentifier (read-only bit)  */
98
99 #define CLR_OVR    (~ISTR_OVR)   /* clear OVeR/underrun bit*/
100 #define CLR_ERR    (~ISTR_ERR)   /* clear ERRor bit */
101 #define CLR_WKUP   (~ISTR_WKUP)  /* clear WaKe UP bit     */
102 #define CLR_SUSP   (~ISTR_SUSP)  /* clear SUSPend bit     */
103 #define CLR_RESET  (~ISTR_RESET) /* clear RESET bit      */
104 #define CLR_SOF    (~ISTR_SOF)   /* clear Start Of Frame bit   */
105 #define CLR_ESOF   (~ISTR_ESOF)  /* clear Expected Start Of Frame bit */
106
107 #define CNTR_CTRM   (0x8000) /* Correct TRansfer Mask */
108 #define CNTR_OVRM   (0x4000) /* OVeR/underrun Mask */
109 #define CNTR_ERRM   (0x2000) /* ERRor Mask */
110 #define CNTR_WKUPM  (0x1000) /* WaKe UP Mask */
111 #define CNTR_SUSPM  (0x0800) /* SUSPend Mask */
112 #define CNTR_RESETM (0x0400) /* RESET Mask   */
113 #define CNTR_SOFM   (0x0200) /* Start Of Frame Mask */
114 #define CNTR_ESOFM  (0x0100) /* Expected Start Of Frame Mask */
115
116 #define CNTR_RESUME (0x0010) /* RESUME request */
117 #define CNTR_FSUSP  (0x0008) /* Force SUSPend */
118 #define CNTR_LPMODE (0x0004) /* Low-power MODE */
119 #define CNTR_PDWN   (0x0002) /* Power DoWN */
120 #define CNTR_FRES   (0x0001) /* Force USB RESet */
121
122 #define DADDR_EF (0x80)
123 #define DADDR_ADD (0x7F)
124
125 #define EP_CTR_RX      (0x8000) /* EndPoint Correct TRansfer RX */
126 #define EP_DTOG_RX     (0x4000) /* EndPoint Data TOGGLE RX */
127 #define EPRX_STAT      (0x3000) /* EndPoint RX STATus bit field */
128 #define EP_SETUP       (0x0800) /* EndPoint SETUP */
129 #define EP_T_FIELD     (0x0600) /* EndPoint TYPE */
130 #define EP_KIND        (0x0100) /* EndPoint KIND */
131 #define EP_CTR_TX      (0x0080) /* EndPoint Correct TRansfer TX */
132 #define EP_DTOG_TX     (0x0040) /* EndPoint Data TOGGLE TX */
133 #define EPTX_STAT      (0x0030) /* EndPoint TX STATus bit field */
134 #define EPADDR_FIELD   (0x000F) /* EndPoint ADDRess FIELD */
135
136 #define EPREG_MASK     (EP_CTR_RX|EP_SETUP|EP_T_FIELD|EP_KIND|EP_CTR_TX|EPADDR_FIELD)
137
138 /* STAT_TX[1:0] STATus for TX transfer */
139 #define EP_TX_DIS      (0x0000) /* EndPoint TX DISabled */
140 #define EP_TX_STALL    (0x0010) /* EndPoint TX STALLed */
141 #define EP_TX_NAK      (0x0020) /* EndPoint TX NAKed */
142 #define EP_TX_VALID    (0x0030) /* EndPoint TX VALID */
143 #define EPTX_DTOG1     (0x0010) /* EndPoint TX Data TOGgle bit1 */
144 #define EPTX_DTOG2     (0x0020) /* EndPoint TX Data TOGgle bit2 */
145
146 /* STAT_RX[1:0] STATus for RX transfer */
147 #define EP_RX_DIS      (0x0000) /* EndPoint RX DISabled */
148 #define EP_RX_STALL    (0x1000) /* EndPoint RX STALLed */
149 #define EP_RX_NAK      (0x2000) /* EndPoint RX NAKed */
150 #define EP_RX_VALID    (0x3000) /* EndPoint RX VALID */
151 #define EPRX_DTOG1     (0x1000) /* EndPoint RX Data TOGgle bit1 */
152 #define EPRX_DTOG2     (0x2000) /* EndPoint RX Data TOGgle bit1 */
153
154 static void usb_handle_transfer (uint16_t istr_value);
155
156 static void st103_set_btable (void)
157 {
158   *BTABLE = 0;
159 }
160
161 static uint16_t st103_get_istr (void)
162 {
163   return *ISTR;
164 }
165
166 static void st103_set_istr (uint16_t istr)
167 {
168   *ISTR = istr;
169 }
170
171 static void st103_set_cntr (uint16_t cntr)
172 {
173   *CNTR = cntr;
174 }
175
176 static void st103_set_daddr (uint16_t daddr)
177 {
178   *DADDR  = daddr | DADDR_EF;
179 }
180
181 static void st103_set_epreg (uint8_t ep_num, uint16_t value)
182 {
183   uint16_t *reg_p = (uint16_t *)(REG_BASE + ep_num*4);
184
185   *reg_p = value;
186 }
187
188 static uint16_t st103_get_epreg (uint8_t ep_num)
189 {
190   uint16_t *reg_p = (uint16_t *)(REG_BASE + ep_num*4);
191
192   return *reg_p;
193 }
194
195 static void st103_set_tx_addr (uint8_t ep_num, uint16_t addr)
196 {
197   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+0)*2);
198
199   *reg_p = addr;
200 }
201
202 static uint16_t st103_get_tx_addr (uint8_t ep_num)
203 {
204   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+0)*2);
205
206   return *reg_p;
207 }
208
209
210 static void st103_set_tx_count (uint8_t ep_num, uint16_t size)
211 {
212   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+2)*2);
213
214   *reg_p = size;
215 }
216
217 static uint16_t st103_get_tx_count (uint8_t ep_num)
218 {
219   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+2)*2);
220
221   return *reg_p  & 0x03ff;
222 }
223
224
225 static void st103_set_rx_addr (uint8_t ep_num, uint16_t addr)
226 {
227   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+4)*2);
228
229   *reg_p = addr;
230 }
231
232 static uint16_t st103_get_rx_addr (uint8_t ep_num)
233 {
234   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+4)*2);
235
236   return *reg_p;
237 }
238
239
240 static void st103_set_rx_buf_size (uint8_t ep_num, uint16_t size)
241 {                               /* Assume size is even */
242   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+6)*2);
243   uint16_t value;
244
245   if (size <= 62)
246     value = (size & 0x3e) << 9;
247   else
248     value = 0x8000 | (((size >> 5) - 1) << 10);
249
250   *reg_p = value;
251 }
252
253 static uint16_t st103_get_rx_count (uint8_t ep_num)
254 {
255   uint16_t *reg_p = (uint16_t *)(PMA_ADDR + (ep_num*8+6)*2);
256
257   return *reg_p & 0x03ff;
258 }
259
260
261 static void st103_ep_clear_ctr_rx (uint8_t ep_num)
262 {
263   uint16_t value = st103_get_epreg (ep_num) & ~EP_CTR_RX & EPREG_MASK;
264
265   st103_set_epreg (ep_num, value);
266 }
267
268 static void st103_ep_clear_ctr_tx (uint8_t ep_num)
269 {
270   uint16_t value = st103_get_epreg (ep_num) & ~EP_CTR_TX & EPREG_MASK;
271
272   st103_set_epreg (ep_num, value);
273 }
274
275 static void st103_ep_set_rxtx_status (uint8_t ep_num, uint16_t st_rx,
276                                       uint16_t st_tx)
277 {
278   uint16_t value = st103_get_epreg (ep_num);
279
280   value &= (EPREG_MASK|EPRX_STAT|EPTX_STAT);
281   value ^= (EPRX_DTOG1 & st_rx);
282   value ^= (EPRX_DTOG2 & st_rx);
283   value ^= (EPTX_DTOG1 & st_tx);
284   value ^= (EPTX_DTOG2 & st_tx);
285   value |= EP_CTR_RX | EP_CTR_TX;
286   st103_set_epreg (ep_num, value);
287 }
288
289 static void st103_ep_set_rx_status (uint8_t ep_num, uint16_t st_rx)
290 {
291   uint16_t value = st103_get_epreg (ep_num);
292
293   value &= (EPREG_MASK|EPRX_STAT);
294   value ^= (EPRX_DTOG1 & st_rx);
295   value ^= (EPRX_DTOG2 & st_rx);
296   value |= EP_CTR_RX | EP_CTR_TX;
297   st103_set_epreg (ep_num, value);
298 }
299
300 static uint16_t st103_ep_get_rx_status (uint8_t ep_num)
301 {
302   uint16_t value = st103_get_epreg (ep_num);
303
304   return value & EPRX_STAT;
305 }
306
307 static void st103_ep_set_tx_status (uint8_t ep_num, uint16_t st_tx)
308 {
309   uint16_t value = st103_get_epreg (ep_num);
310
311   value &= (EPREG_MASK|EPTX_STAT);
312   value ^= (EPTX_DTOG1 & st_tx);
313   value ^= (EPTX_DTOG2 & st_tx);
314   value |= EP_CTR_RX | EP_CTR_TX;
315   st103_set_epreg (ep_num, value);
316 }
317
318 static uint16_t st103_ep_get_tx_status (uint8_t ep_num)
319 {
320   uint16_t value = st103_get_epreg (ep_num);
321
322   return value & EPTX_STAT;
323 }
324
325 static void st103_ep_clear_dtog_rx (uint8_t ep_num)
326 {
327   uint16_t value = st103_get_epreg (ep_num);
328
329   if ((value & EP_DTOG_RX))
330     {
331       value &= EPREG_MASK;
332       value |= EP_CTR_RX | EP_CTR_TX | EP_DTOG_RX;
333       st103_set_epreg (ep_num, value);
334     }
335 }
336
337 static void st103_ep_clear_dtog_tx (uint8_t ep_num)
338 {
339   uint16_t value = st103_get_epreg (ep_num);
340
341   if ((value & EP_DTOG_TX))
342     {
343       value &= EPREG_MASK;
344       value |= EP_CTR_RX | EP_CTR_TX | EP_DTOG_TX;
345       st103_set_epreg (ep_num, value);
346     }
347 }
348 \f
349 void usb_lld_init (uint8_t feature)
350 {
351   usb_lld_sys_init ();
352
353   dev_p->state = IN_DATA;
354
355   usb_lld_set_configuration (0);
356   usb_lld_set_feature (feature);
357
358   /* Reset USB */
359   st103_set_cntr (CNTR_FRES);
360   st103_set_cntr (0);
361
362   /* Clear Interrupt Status Register, and enable interrupt for USB */
363   st103_set_istr (0);
364   st103_set_cntr (CNTR_CTRM | CNTR_RESETM);
365 }
366
367 void usb_lld_prepare_shutdown (void)
368 {
369   st103_set_istr (0);
370   st103_set_cntr (0);
371 }
372
373 void usb_lld_shutdown (void)
374 {
375   st103_set_cntr (CNTR_PDWN);
376   usb_lld_sys_shutdown ();
377 }
378
379 void
380 usb_interrupt_handler (void)
381 {
382   uint16_t istr_value = st103_get_istr ();
383
384   if ((istr_value & ISTR_RESET))
385     {
386       st103_set_istr (CLR_RESET);
387       usb_cb_device_reset ();
388     }
389   else
390     {
391       if ((istr_value & ISTR_OVR))
392         st103_set_istr (CLR_OVR);
393
394       if ((istr_value & ISTR_ERR))
395         st103_set_istr (CLR_ERR);
396
397       if ((istr_value & ISTR_CTR))
398         usb_handle_transfer (istr_value);
399     }
400 }
401
402 static void handle_datastage_out (void)
403 {
404   if (data_p->addr && data_p->len)
405     {
406       uint32_t len = st103_get_rx_count (ENDP0);
407
408       if (len > data_p->len)
409         len = data_p->len;
410
411       usb_lld_from_pmabuf (data_p->addr, st103_get_rx_addr (ENDP0), len);
412       data_p->len -= len;
413       data_p->addr += len;
414     }
415
416   if (data_p->len == 0)
417     {
418       dev_p->state = WAIT_STATUS_IN;
419       st103_set_tx_count (ENDP0, 0);
420       st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_VALID);
421     }
422   else
423     {
424       dev_p->state = OUT_DATA;
425       st103_ep_set_rx_status (ENDP0, EP_RX_VALID);
426     }
427 }
428
429 static void handle_datastage_in (void)
430 {
431   uint32_t len = USB_MAX_PACKET_SIZE;;
432
433   if ((data_p->len == 0) && (dev_p->state == LAST_IN_DATA))
434     {
435       if (data_p->require_zlp)
436         {
437           data_p->require_zlp = 0;
438
439           /* No more data to send.  Send empty packet */
440           st103_set_tx_count (ENDP0, 0);
441           st103_ep_set_rxtx_status (ENDP0, EP_RX_VALID, EP_TX_VALID);
442         }
443       else
444         {
445           /* No more data to send, proceed to receive OUT acknowledge.*/
446           dev_p->state = WAIT_STATUS_OUT;
447           st103_ep_set_rxtx_status (ENDP0, EP_RX_VALID, EP_TX_STALL);
448         }
449
450       return;
451     }
452
453   dev_p->state = (data_p->len <= len) ? LAST_IN_DATA : IN_DATA;
454
455   if (len > data_p->len)
456     len = data_p->len;
457
458   usb_lld_to_pmabuf (data_p->addr, st103_get_tx_addr (ENDP0), len);
459   data_p->len -= len;
460   data_p->addr += len;
461   st103_set_tx_count (ENDP0, len);
462   st103_ep_set_tx_status (ENDP0, EP_TX_VALID);
463 }
464
465 typedef int (*HANDLER) (uint8_t req, struct control_info *detail);
466
467 static int std_none (uint8_t req, struct control_info *detail)
468 {
469   (void)req; (void)detail;
470   return USB_UNSUPPORT;
471 }
472
473 static int std_get_status (uint8_t req, struct control_info *detail)
474 {
475   uint8_t rcp = req & RECIPIENT;
476   uint16_t status_info = 0;
477
478   if (detail->value != 0 || detail->len != 2 || (detail->index >> 8) != 0
479       || (req & REQUEST_DIR) == 0)
480     return USB_UNSUPPORT;
481
482   if (rcp == DEVICE_RECIPIENT)
483     {
484       if (detail->index == 0)
485         {
486           /* Get Device Status */
487           uint8_t feature = dev_p->current_feature;
488
489           /* Remote Wakeup enabled */
490           if ((feature & (1 << 5)))
491             status_info |= 2;
492           else
493             status_info &= ~2;
494
495           /* Bus-powered */
496           if ((feature & (1 << 6)))
497             status_info |= 1;
498           else /* Self-powered */
499             status_info &= ~1;
500
501           return usb_lld_reply_request (&status_info, 2, detail);
502         }
503     }
504   else if (rcp == INTERFACE_RECIPIENT)
505     {
506       int r;
507
508       if (dev_p->current_configuration == 0)
509         return USB_UNSUPPORT;
510
511       r = usb_cb_interface (USB_QUERY_INTERFACE, detail);
512       if (r != USB_SUCCESS)
513         return USB_UNSUPPORT;
514
515       return usb_lld_reply_request (&status_info, 2, detail);
516     }
517   else if (rcp == ENDPOINT_RECIPIENT)
518     {
519       uint8_t endpoint = (detail->index & 0x0f);
520       uint16_t status;
521
522       if ((detail->index & 0x70) || endpoint == ENDP0)
523         return USB_UNSUPPORT;
524
525       if ((detail->index & 0x80))
526         {
527           status = st103_ep_get_tx_status (endpoint);
528           if (status == 0)              /* Disabled */
529             return USB_UNSUPPORT;
530           else if (status == EP_TX_STALL)
531             status_info |= 1; /* IN Endpoint stalled */
532         }
533       else
534         {
535           status = st103_ep_get_rx_status (endpoint);
536           if (status == 0)              /* Disabled */
537             return USB_UNSUPPORT;
538           else if (status == EP_RX_STALL)
539             status_info |= 1; /* OUT Endpoint stalled */
540         }
541
542       return usb_lld_reply_request (&status_info, 2, detail);
543     }
544
545   return USB_UNSUPPORT;
546 }
547
548 static int std_clear_feature (uint8_t req, struct control_info *detail)
549 {
550   uint8_t rcp = req & RECIPIENT;
551
552   if ((req & REQUEST_DIR) == 1)
553     return USB_UNSUPPORT;
554
555   if (rcp == DEVICE_RECIPIENT)
556     {
557       if (detail->len != 0 || detail->index != 0)
558         return USB_UNSUPPORT;
559
560       if (detail->value == DEVICE_REMOTE_WAKEUP)
561         {
562           dev_p->current_feature &= ~(1 << 5);
563           return USB_SUCCESS;
564         }
565     }
566   else if (rcp == ENDPOINT_RECIPIENT)
567     {
568       uint8_t endpoint = (detail->index & 0x0f);
569       uint16_t status;
570
571       if (dev_p->current_configuration == 0)
572         return USB_UNSUPPORT;
573
574       if (detail->len != 0 || (detail->index >> 8) != 0
575           || detail->value != ENDPOINT_STALL || endpoint == ENDP0)
576         return USB_UNSUPPORT;
577
578       if ((detail->index & 0x80))
579         status = st103_ep_get_tx_status (endpoint);
580       else
581         status = st103_ep_get_rx_status (endpoint);
582
583       if (status == 0)          /* Disabled */
584         return USB_UNSUPPORT;
585
586       if (detail->index & 0x80)         /* IN endpoint */
587         st103_ep_clear_dtog_tx (endpoint);
588       else                      /* OUT endpoint */
589         st103_ep_clear_dtog_rx (endpoint);
590
591       // event??
592       return USB_SUCCESS;
593     }
594
595   return USB_UNSUPPORT;
596 }
597
598 static int std_set_feature (uint8_t req, struct control_info *detail)
599 {
600   uint8_t rcp = req & RECIPIENT;
601
602   if ((req & REQUEST_DIR) == 1)
603     return USB_UNSUPPORT;
604
605   if (rcp == DEVICE_RECIPIENT)
606     {
607       if (detail->len != 0 || detail->index != 0)
608         return USB_UNSUPPORT;
609
610       if (detail->value == DEVICE_REMOTE_WAKEUP)
611         {
612           dev_p->current_feature |= 1 << 5;
613           // event??
614           return USB_SUCCESS;
615         }
616     }
617   else if (rcp == ENDPOINT_RECIPIENT)
618     {
619       uint8_t endpoint = (detail->index & 0x0f);
620       uint32_t status;
621
622       if (dev_p->current_configuration == 0)
623         return USB_UNSUPPORT;
624
625       if (detail->len != 0 || (detail->index >> 8) != 0
626           || detail->value != 0 || endpoint == ENDP0)
627         return USB_UNSUPPORT;
628
629       if ((detail->index & 0x80))
630         status = st103_ep_get_tx_status (endpoint);
631       else
632         status = st103_ep_get_rx_status (endpoint);
633
634       if (status == 0)          /* Disabled */
635         return USB_UNSUPPORT;
636
637       if (detail->index & 0x80)
638         /* IN endpoint */
639         st103_ep_set_tx_status (endpoint, EP_TX_STALL);
640       else
641         /* OUT endpoint */
642         st103_ep_set_rx_status (endpoint, EP_RX_STALL);
643
644       // event??
645       return USB_SUCCESS;
646     }
647
648   return USB_UNSUPPORT;
649 }
650
651 static int std_set_address (uint8_t req, struct control_info *detail)
652 {
653   uint8_t rcp = req & RECIPIENT;
654
655   if ((req & REQUEST_DIR) == 1)
656     return USB_UNSUPPORT;
657
658   if (rcp == DEVICE_RECIPIENT && detail->len == 0 && detail->value <= 127
659       && detail->index == 0 && dev_p->current_configuration == 0)
660     return USB_SUCCESS;
661
662   return USB_UNSUPPORT;
663 }
664
665 static int std_get_descriptor (uint8_t req, struct control_info *detail)
666 {
667   uint8_t rcp = req & RECIPIENT;
668
669   if ((req & REQUEST_DIR) == 0)
670     return USB_UNSUPPORT;
671
672   return usb_cb_get_descriptor (rcp, (detail->value >> 8),
673                                 (detail->value & 0xff), detail);
674 }
675
676 static int std_get_configuration (uint8_t req,  struct control_info *detail)
677 {
678   uint8_t rcp = req & RECIPIENT;
679
680   (void)detail;
681   if ((req & REQUEST_DIR) == 0)
682     return USB_UNSUPPORT;
683
684   if (rcp == DEVICE_RECIPIENT)
685     return usb_lld_reply_request (&dev_p->current_configuration, 1, detail);
686
687   return USB_UNSUPPORT;
688 }
689
690 static int std_set_configuration (uint8_t req, struct control_info *detail)
691 {
692   uint8_t rcp = req & RECIPIENT;
693
694   if ((req & REQUEST_DIR) == 1)
695     return USB_UNSUPPORT;
696
697   if (rcp == DEVICE_RECIPIENT && detail->index == 0 && detail->len == 0)
698     return usb_cb_handle_event (USB_EVENT_CONFIG, detail->value);
699
700   return USB_UNSUPPORT;
701 }
702
703 static int std_get_interface (uint8_t req, struct control_info *detail)
704 {
705   uint8_t rcp = req & RECIPIENT;
706
707   if ((req & REQUEST_DIR) == 0)
708     return USB_UNSUPPORT;
709
710   if (rcp == INTERFACE_RECIPIENT)
711     {
712       if (detail->value != 0 || (detail->index >> 8) != 0 || detail->len != 1)
713         return USB_UNSUPPORT;
714
715       if (dev_p->current_configuration == 0)
716         return USB_UNSUPPORT;
717
718       return usb_cb_interface (USB_GET_INTERFACE, detail);
719     }
720
721   return USB_UNSUPPORT;
722 }
723
724 static int std_set_interface (uint8_t req, struct control_info *detail)
725 {
726   uint8_t rcp = req & RECIPIENT;
727
728   if ((req & REQUEST_DIR) == 1 || rcp != INTERFACE_RECIPIENT
729       || detail->len != 0 || (detail->index >> 8) != 0
730       || (detail->value >> 8) != 0 || dev_p->current_configuration == 0)
731     return USB_UNSUPPORT;
732
733   return usb_cb_interface (USB_SET_INTERFACE, detail);
734 }
735
736
737 static void handle_setup0 (void)
738 {
739   const uint16_t *pw;
740   struct control_info ctrl;
741   uint16_t w;
742   uint8_t req_no;
743   int r = USB_UNSUPPORT;
744   HANDLER handler;
745
746   pw = (uint16_t *)(PMA_ADDR + (uint8_t *)(st103_get_rx_addr (ENDP0) * 2));
747   w = *pw++;
748
749   dev_p->bmRequestType = w & 0xff;
750   dev_p->bRequest = req_no = w >> 8;
751   pw++;
752   ctrl.value = *pw++;
753   pw++;
754   ctrl.index  = *pw++;
755   pw++;
756   ctrl.len = *pw;
757
758   data_p->addr = NULL;
759   data_p->len = 0;
760   data_p->require_zlp = 0;
761
762   if ((dev_p->bmRequestType & REQUEST_TYPE) == STANDARD_REQUEST)
763     {
764       if (req_no < TOTAL_REQUEST)
765         {
766           switch (req_no)
767             {
768             case 0: handler = std_get_status;  break;
769             case 1: handler = std_clear_feature;  break;
770             case 3: handler = std_set_feature;  break;
771             case 5: handler = std_set_address;  break;
772             case 6: handler = std_get_descriptor;  break;
773             case 8: handler = std_get_configuration;  break;
774             case 9: handler = std_set_configuration;  break;
775             case 10: handler = std_get_interface;  break;
776             case 11: handler = std_set_interface;  break;
777             default: handler = std_none;  break;
778             }
779
780           r = (*handler) (dev_p->bmRequestType, &ctrl);
781         }
782     }
783   else
784     r = usb_cb_setup (dev_p->bmRequestType, req_no, &ctrl);
785
786   if (r != USB_SUCCESS)
787     dev_p->state = STALLED;
788   else
789     {
790       if (USB_SETUP_SET (dev_p->bmRequestType))
791         {
792           dev_p->value = ctrl.value;
793           if (ctrl.len == 0)
794             {
795               dev_p->state = WAIT_STATUS_IN;
796               st103_set_tx_count (ENDP0, 0);
797               st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_VALID);
798             }
799           else
800             {
801               dev_p->state = OUT_DATA;
802               st103_ep_set_rx_status (ENDP0, EP_RX_VALID);
803             }
804         }
805     }
806 }
807
808 static void handle_in0 (void)
809 {
810   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
811     handle_datastage_in ();
812   else if (dev_p->state == WAIT_STATUS_IN)
813     {
814       if ((dev_p->bRequest == SET_ADDRESS) &&
815           ((dev_p->bmRequestType & (REQUEST_TYPE | RECIPIENT))
816            == (STANDARD_REQUEST | DEVICE_RECIPIENT)))
817         {
818           st103_set_daddr (dev_p->value);
819           usb_cb_handle_event (USB_EVENT_ADDRESS, dev_p->value);
820         }
821       else
822         usb_cb_ctrl_write_finish  (dev_p->bmRequestType, dev_p->bRequest,
823                                    dev_p->value);
824
825       dev_p->state = STALLED;
826     }
827   else
828     dev_p->state = STALLED;
829 }
830
831 static void handle_out0 (void)
832 {
833   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
834     /* host aborts the transfer before finish */
835     dev_p->state = STALLED;
836   else if (dev_p->state == OUT_DATA)
837     handle_datastage_out ();
838   else if (dev_p->state == WAIT_STATUS_OUT)
839     dev_p->state = STALLED;
840   /* Unexpect state, STALL the endpoint */
841   else
842     dev_p->state = STALLED;
843 }
844 \f
845 static void nop_proc (void)
846 {
847 }
848
849 #define WEAK __attribute__ ((weak, alias ("nop_proc")))
850 void WEAK EP1_IN_Callback (void);
851 void WEAK EP2_IN_Callback (void);
852 void WEAK EP3_IN_Callback (void);
853 void WEAK EP4_IN_Callback (void);
854 void WEAK EP5_IN_Callback (void);
855 void WEAK EP6_IN_Callback (void);
856 void WEAK EP7_IN_Callback (void);
857
858 void WEAK EP1_OUT_Callback (void);
859 void WEAK EP2_OUT_Callback (void);
860 void WEAK EP3_OUT_Callback (void);
861 void WEAK EP4_OUT_Callback (void);
862 void WEAK EP5_OUT_Callback (void);
863 void WEAK EP6_OUT_Callback (void);
864 void WEAK EP7_OUT_Callback (void);
865
866 static void
867 usb_handle_transfer (uint16_t istr_value)
868 {
869   uint16_t ep_value = 0;
870   uint8_t ep_index;
871
872   ep_index = (istr_value & ISTR_EP_ID);
873   /* Decode and service non control endpoints interrupt  */
874   /* process related endpoint register */
875   ep_value = st103_get_epreg (ep_index);
876
877   if (ep_index == 0)
878     {
879       if ((ep_value & EP_CTR_TX))
880         {
881           st103_ep_clear_ctr_tx (ep_index);
882           handle_in0 ();
883         }
884
885       if ((ep_value & EP_CTR_RX))
886         {
887           st103_ep_clear_ctr_rx (ep_index);
888
889           if ((ep_value & EP_SETUP))
890             handle_setup0 ();
891           else
892             handle_out0 ();
893         }
894
895       if (dev_p->state == STALLED)
896         st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_STALL);
897     }
898   else
899     {
900       if ((ep_value & EP_CTR_RX))
901         {
902           st103_ep_clear_ctr_rx (ep_index);
903           switch ((ep_index - 1))
904             {
905             case 0: EP1_OUT_Callback ();  break;
906             case 1: EP2_OUT_Callback ();  break;
907             case 2: EP3_OUT_Callback ();  break;
908             case 3: EP4_OUT_Callback ();  break;
909             case 4: EP5_OUT_Callback ();  break;
910             case 5: EP6_OUT_Callback ();  break;
911             case 6: EP7_OUT_Callback ();  break;
912             }
913         }
914
915       if ((ep_value & EP_CTR_TX))
916         {
917           st103_ep_clear_ctr_tx (ep_index);
918           switch ((ep_index - 1))
919             {
920             case 0: EP1_IN_Callback ();  break;
921             case 1: EP2_IN_Callback ();  break;
922             case 2: EP3_IN_Callback ();  break;
923             case 3: EP4_IN_Callback ();  break;
924             case 4: EP5_IN_Callback ();  break;
925             case 5: EP6_IN_Callback ();  break;
926             case 6: EP7_IN_Callback ();  break;
927             }
928         }
929     }
930 }
931 \f
932 void usb_lld_reset (void)
933 {
934   st103_set_btable ();
935   st103_set_daddr (0);
936 }
937
938 void usb_lld_txcpy (const void *src,
939                     int ep_num, int offset, size_t len)
940 {
941   usb_lld_to_pmabuf (src, st103_get_tx_addr (ep_num) + offset, len);
942 }
943
944 void usb_lld_write (uint8_t ep_num, const void *buf, size_t len)
945 {
946   usb_lld_to_pmabuf (buf, st103_get_tx_addr (ep_num), len);
947   st103_set_tx_count (ep_num, len);
948   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
949 }
950
951 void usb_lld_rxcpy (uint8_t *dst,
952                     int ep_num, int offset, size_t len)
953 {
954   usb_lld_from_pmabuf (dst, st103_get_rx_addr (ep_num) + offset, len);
955 }
956
957 void usb_lld_tx_enable (int ep_num, size_t len)
958 {
959   st103_set_tx_count (ep_num, len);
960   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
961 }
962
963 int usb_lld_tx_data_len (int ep_num)
964 {
965   return st103_get_tx_count (ep_num);
966 }
967
968 int usb_lld_rx_data_len (int ep_num)
969 {
970   return st103_get_rx_count (ep_num);
971 }
972
973 void usb_lld_stall_tx (int ep_num)
974 {
975   st103_ep_set_tx_status (ep_num, EP_TX_STALL);
976 }
977
978 void usb_lld_stall_rx (int ep_num)
979 {
980   st103_ep_set_rx_status (ep_num, EP_RX_STALL);
981 }
982
983 void usb_lld_rx_enable (int ep_num)
984 {
985   st103_ep_set_rx_status (ep_num, EP_RX_VALID);
986 }
987
988 void usb_lld_setup_endpoint (int ep_num, int ep_type, int ep_kind,
989                              int ep_rx_addr, int ep_tx_addr,
990                              int ep_rx_buf_size)
991 {
992   uint16_t epreg_value = st103_get_epreg (ep_num);
993   uint16_t ep_rxtx_status = 0;  /* Both disabled */
994
995   /* Clear: Write 1 if 1: EP_DTOG_RX, EP_DTOG_TX */
996   /* Set: Write:          EP_T_FIELD, EP_KIND, EPADDR_FIELD */
997   /* Set: Toggle:         EPRX_STAT, EPTX_STAT */
998   epreg_value &= (EPRX_STAT | EP_SETUP | EPTX_STAT | EP_DTOG_RX | EP_DTOG_TX);
999 #if USB_KEEP_CORRECT_TRANSFER_FLAGS
1000   /* Keep: Write 1:       EP_CTR_RX, EP_CTR_TX */
1001   epreg_value |= (EP_CTR_RX|EP_CTR_TX);
1002 #else
1003   /* Clear: Write 0:      EP_CTR_RX, EP_CTR_TX */
1004 #endif
1005   epreg_value |= ep_type;
1006   epreg_value |= ep_kind;
1007   epreg_value |= ep_num;
1008
1009   if (ep_rx_addr)
1010     {
1011       ep_rxtx_status |= EP_RX_VALID;
1012       st103_set_rx_addr (ep_num, ep_rx_addr);
1013       st103_set_rx_buf_size (ep_num, ep_rx_buf_size);
1014     }
1015
1016   if (ep_tx_addr)
1017     {
1018       ep_rxtx_status |= EP_TX_NAK;
1019       st103_set_tx_addr (ep_num, ep_tx_addr);
1020     }
1021
1022   epreg_value ^= (EPRX_DTOG1 & ep_rxtx_status);
1023   epreg_value ^= (EPRX_DTOG2 & ep_rxtx_status);
1024   epreg_value ^= (EPTX_DTOG1 & ep_rxtx_status);
1025   epreg_value ^= (EPTX_DTOG2 & ep_rxtx_status);
1026
1027   st103_set_epreg (ep_num, epreg_value);
1028 }
1029
1030 void usb_lld_set_configuration (uint8_t config)
1031 {
1032   dev_p->current_configuration = config;
1033 }
1034
1035 uint8_t usb_lld_current_configuration (void)
1036 {
1037   return dev_p->current_configuration;
1038 }
1039
1040 void usb_lld_set_feature (uint8_t feature)
1041 {
1042   dev_p->current_feature = feature;
1043 }
1044
1045 void usb_lld_set_data_to_recv (const void *p, size_t len)
1046 {
1047   data_p->addr = (uint8_t *)p;
1048   data_p->len = len;
1049 }
1050
1051 void usb_lld_to_pmabuf (const void *src, uint16_t addr, size_t n)
1052 {
1053   const uint8_t *s = (const uint8_t *)src;
1054   uint16_t *p;
1055   uint16_t w;
1056
1057   if (n == 0)
1058     return;
1059
1060   if ((addr & 1))
1061     {
1062       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1063       w = *p;
1064       w = (w & 0xff) | (*s++) << 8;
1065       *p = w;
1066       p += 2;
1067       n--;
1068     }
1069   else
1070     p = (uint16_t *)(PMA_ADDR + addr * 2);
1071
1072   while (n >= 2)
1073     {
1074       w = *s++;
1075       w |= (*s++) << 8;
1076       *p = w;
1077       p += 2;
1078       n -= 2;
1079     }
1080
1081   if (n > 0)
1082     {
1083       w = *s;
1084       *p = w;
1085     }
1086 }
1087
1088 void usb_lld_from_pmabuf (void *dst, uint16_t addr, size_t n)
1089 {
1090   uint8_t *d = (uint8_t *)dst;
1091   uint16_t *p;
1092   uint16_t w;
1093
1094   if (n == 0)
1095     return;
1096
1097   if ((addr & 1))
1098     {
1099       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1100       w = *p;
1101       *d++ = (w >> 8);
1102       p += 2;
1103       n--;
1104     }
1105   else
1106     p = (uint16_t *)(PMA_ADDR + addr * 2);
1107
1108   while (n >= 2)
1109     {
1110       w = *p;
1111       *d++ = (w & 0xff);
1112       *d++ = (w >> 8);
1113       p += 2;
1114       n -= 2;
1115     }
1116
1117   if (n > 0)
1118     {
1119       w = *p;
1120       *d = (w & 0xff);
1121     }
1122 }
1123
1124
1125 /*
1126  * BUF: Pointer to data memory.  Data memory should not be allocated
1127  *      on stack when BUFLEN > USB_MAX_PACKET_SIZE.
1128  *
1129  * BUFLEN: size of the data.
1130  */
1131 int
1132 usb_lld_reply_request (const void *buf, size_t buflen, struct control_info *ctl)
1133 {
1134   uint32_t len_asked = ctl->len;
1135   uint32_t len;
1136
1137   data_p->addr = (void *)buf;
1138   data_p->len = buflen;
1139
1140   /* Restrict the data length to be the one host asks for */
1141   if (data_p->len > len_asked)
1142     data_p->len = len_asked;
1143
1144   if (data_p->len != 0 && (data_p->len % USB_MAX_PACKET_SIZE) == 0)
1145     data_p->require_zlp = 1;
1146
1147   if (data_p->len < USB_MAX_PACKET_SIZE)
1148     {
1149       len = data_p->len;
1150       dev_p->state = LAST_IN_DATA;
1151     }
1152   else
1153     {
1154       len = USB_MAX_PACKET_SIZE;
1155       dev_p->state = IN_DATA;
1156     }
1157
1158   if (len)
1159     {
1160       usb_lld_to_pmabuf (data_p->addr, st103_get_tx_addr (ENDP0), len);
1161       data_p->len -= len;
1162       data_p->addr += len;
1163     }
1164
1165   st103_set_tx_count (ENDP0, len);
1166   st103_ep_set_tx_status (ENDP0, EP_TX_VALID);
1167   return USB_SUCCESS;
1168 }