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