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