dd33e67153188e1267d90b7b6cda036748f17c10
[gnuk/neug.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 (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   return usb_cb_get_descriptor (rcp, (value >> 8), (value & 0xff), index);
701 }
702
703 static int std_get_configuration (uint8_t req, uint16_t value,
704                                   uint16_t index, uint16_t length)
705 {
706   uint8_t rcp = req & RECIPIENT;
707
708   if ((req & REQUEST_DIR) == 0)
709     return USB_UNSUPPORT;
710
711   (void)value;  (void)index;  (void)length;
712   if (rcp == DEVICE_RECIPIENT)
713     {
714       data_p->addr = &dev_p->current_configuration;
715       data_p->len = 1;
716       return USB_SUCCESS;
717     }
718
719   return USB_UNSUPPORT;
720 }
721
722 static int std_set_configuration (uint8_t req, uint16_t value,
723                                   uint16_t index, uint16_t length)
724 {
725   uint8_t rcp = req & RECIPIENT;
726
727   if ((req & REQUEST_DIR) == 1)
728     return USB_UNSUPPORT;
729
730   if (rcp == DEVICE_RECIPIENT && index == 0 && length == 0)
731     {
732       int r;
733
734       r = usb_cb_handle_event (USB_EVENT_CONFIG, value);
735       if (r == USB_SUCCESS)
736         return USB_SUCCESS;
737     }
738
739   return USB_UNSUPPORT;
740 }
741
742 static int std_get_interface (uint8_t req, uint16_t value,
743                               uint16_t index, uint16_t length)
744 {
745   uint8_t rcp = req & RECIPIENT;
746
747   if ((req & REQUEST_DIR) == 0)
748     return USB_UNSUPPORT;
749
750   if (rcp == INTERFACE_RECIPIENT)
751     {
752       if (value != 0 || (index >> 8) != 0 || length != 1)
753         return USB_UNSUPPORT;
754
755       if (dev_p->current_configuration == 0)
756         return USB_UNSUPPORT;
757
758       return usb_cb_interface (USB_GET_INTERFACE, index, 0);
759     }
760
761   return USB_UNSUPPORT;
762 }
763
764 static int std_set_interface (uint8_t req, uint16_t value,
765                               uint16_t index, uint16_t length)
766 {
767   uint8_t rcp = req & RECIPIENT;
768
769   if ((req & REQUEST_DIR) == 1)
770     return USB_UNSUPPORT;
771
772   if (rcp == INTERFACE_RECIPIENT)
773     {
774       int r;
775
776       if (length != 0 || (index >> 8) != 0 || (value >> 8) != 0)
777         return  USB_UNSUPPORT;
778
779       if (dev_p->current_configuration != 0)
780         return USB_UNSUPPORT;
781
782       r = usb_cb_interface (USB_SET_INTERFACE, index, value);
783       if (r == USB_SUCCESS)
784         return USB_SUCCESS;
785     }
786
787   return USB_UNSUPPORT;
788 }
789
790
791 static void handle_setup0 (void)
792 {
793   const uint16_t *pw;
794   uint16_t w;
795   uint8_t req;
796   int r = USB_UNSUPPORT;
797   HANDLER handler;
798
799   pw = (uint16_t *)(PMA_ADDR + (uint8_t *)(st103_get_rx_addr (ENDP0) * 2));
800   w = *pw++;
801
802   ctrl_p->bmRequestType = w & 0xff;
803   ctrl_p->bRequest = req = w >> 8;
804   pw++;
805   ctrl_p->wValue = *pw++;
806   pw++;
807   ctrl_p->wIndex  = *pw++;
808   pw++;
809   ctrl_p->wLength = *pw;
810
811   data_p->addr = NULL;
812   data_p->len = 0;
813   data_p->offset = 0;
814
815   if ((ctrl_p->bmRequestType & REQUEST_TYPE) == STANDARD_REQUEST)
816     {
817       if (req < TOTAL_REQUEST)
818         {
819           switch (req)
820             {
821             case 0: handler = std_get_status;  break;
822             case 1: handler = std_clear_feature;  break;
823             case 3: handler = std_set_feature;  break;
824             case 5: handler = std_set_address;  break;
825             case 6: handler = std_get_descriptor;  break;
826             case 8: handler = std_get_configuration;  break;
827             case 9: handler = std_set_configuration;  break;
828             case 10: handler = std_get_interface;  break;
829             case 11: handler = std_set_interface;  break;
830             default: handler = std_none;  break;
831             }
832
833           r = (*handler) (ctrl_p->bmRequestType,
834                           ctrl_p->wValue, ctrl_p->wIndex, ctrl_p->wLength);
835         }
836     }
837   else
838     r = usb_cb_setup (ctrl_p->bmRequestType, req,
839                       ctrl_p->wValue, ctrl_p->wIndex, ctrl_p->wLength);
840
841   if (r != USB_SUCCESS)
842     dev_p->state = STALLED;
843   else
844     {
845       if (USB_SETUP_GET (ctrl_p->bmRequestType))
846         {
847           uint32_t len = ctrl_p->wLength;
848
849           /* Restrict the data length to be the one host asks for */
850           if (data_p->len > len)
851             data_p->len = len;
852
853           if ((data_p->len % USB_MAX_PACKET_SIZE) == 0)
854             data_p->require_zlp = TRUE;
855           else
856             data_p->require_zlp = FALSE;
857
858           dev_p->state = IN_DATA;
859           handle_datastage_in ();
860         }
861       else if (ctrl_p->wLength == 0)
862         {
863           dev_p->state = WAIT_STATUS_IN;
864           st103_set_tx_count (ENDP0, 0);
865           st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_VALID);
866         }
867       else
868         {
869           dev_p->state = OUT_DATA;
870           st103_ep_set_rx_status (ENDP0, EP_RX_VALID);
871         }
872     }
873 }
874
875 static void handle_in0 (void)
876 {
877   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
878     handle_datastage_in ();
879   else if (dev_p->state == WAIT_STATUS_IN)
880     {
881       if ((ctrl_p->bRequest == SET_ADDRESS) &&
882           ((ctrl_p->bmRequestType & (REQUEST_TYPE | RECIPIENT))
883            == (STANDARD_REQUEST | DEVICE_RECIPIENT)))
884         {
885           st103_set_daddr (ctrl_p->wValue);
886           usb_cb_handle_event (USB_EVENT_ADDRESS, ctrl_p->wValue);
887         }
888       else
889         usb_cb_ctrl_write_finish  (ctrl_p->bmRequestType,
890                                    ctrl_p->bRequest, ctrl_p->wValue,
891                                    ctrl_p->wIndex, ctrl_p->wLength);
892
893       dev_p->state = STALLED;
894     }
895   else
896     dev_p->state = STALLED;
897 }
898
899 static void handle_out0 (void)
900 {
901   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
902     /* host aborts the transfer before finish */
903     dev_p->state = STALLED;
904   else if (dev_p->state == OUT_DATA)
905     handle_datastage_out ();
906   else if (dev_p->state == WAIT_STATUS_OUT)
907     dev_p->state = STALLED;
908   /* Unexpect state, STALL the endpoint */
909   else
910     dev_p->state = STALLED;
911 }
912 \f
913 static void nop_proc (void)
914 {
915 }
916
917 #define WEAK __attribute__ ((weak, alias ("nop_proc")))
918 void WEAK EP1_IN_Callback (void);
919 void WEAK EP2_IN_Callback (void);
920 void WEAK EP3_IN_Callback (void);
921 void WEAK EP4_IN_Callback (void);
922 void WEAK EP5_IN_Callback (void);
923 void WEAK EP6_IN_Callback (void);
924 void WEAK EP7_IN_Callback (void);
925
926 void WEAK EP1_OUT_Callback (void);
927 void WEAK EP2_OUT_Callback (void);
928 void WEAK EP3_OUT_Callback (void);
929 void WEAK EP4_OUT_Callback (void);
930 void WEAK EP5_OUT_Callback (void);
931 void WEAK EP6_OUT_Callback (void);
932 void WEAK EP7_OUT_Callback (void);
933
934 static void
935 usb_handle_transfer (void)
936 {
937   uint16_t ep_value = 0;
938   uint16_t istr_value;
939   uint8_t ep_index;
940
941   while (((istr_value = st103_get_istr ()) & ISTR_CTR) != 0)
942     {
943       ep_index = (istr_value & ISTR_EP_ID);
944       if (ep_index == 0)
945         {
946           if ((istr_value & ISTR_DIR) == 0)
947             {                           /* DIR = 0 */
948               /* DIR = 0      => IN  int */
949               /* DIR = 0 implies that (EP_CTR_TX = 1) always  */
950
951               st103_ep_clear_ctr_tx (ENDP0);
952               handle_in0 ();
953             }
954           else
955             {                           /* DIR = 1 */
956               /* DIR = 1 & CTR_RX       => SETUP or OUT int */
957               /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
958
959               ep_value = st103_get_epreg (ENDP0);
960               if ((ep_value & EP_SETUP) != 0)
961                 {
962                   st103_ep_clear_ctr_rx (ENDP0);
963                   handle_setup0 ();
964                 }
965               else if ((ep_value & EP_CTR_RX) != 0)
966                 {
967                   st103_ep_clear_ctr_rx (ENDP0);
968                   handle_out0 ();
969                 }
970             }
971
972           if (dev_p->state == STALLED)
973             st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_STALL);
974         }
975       else
976         {
977           /* Decode and service non control endpoints interrupt  */
978           /* process related endpoint register */
979           ep_value = st103_get_epreg (ep_index);
980
981           if ((ep_value & EP_CTR_RX) != 0)
982             {
983               st103_ep_clear_ctr_rx (ep_index);
984               switch ((ep_index - 1))
985                 {
986                 case 0: EP1_OUT_Callback ();  break;
987                 case 1: EP2_OUT_Callback ();  break;
988                 case 2: EP3_OUT_Callback ();  break;
989                 case 3: EP4_OUT_Callback ();  break;
990                 case 4: EP5_OUT_Callback ();  break;
991                 case 5: EP6_OUT_Callback ();  break;
992                 case 6: EP7_OUT_Callback ();  break;
993                 }
994             }
995
996           if ((ep_value & EP_CTR_TX) != 0)
997             {
998               st103_ep_clear_ctr_tx (ep_index);
999               switch ((ep_index - 1))
1000                 {
1001                 case 0: EP1_IN_Callback ();  break;
1002                 case 1: EP2_IN_Callback ();  break;
1003                 case 2: EP3_IN_Callback ();  break;
1004                 case 3: EP4_IN_Callback ();  break;
1005                 case 4: EP5_IN_Callback ();  break;
1006                 case 5: EP6_IN_Callback ();  break;
1007                 case 6: EP7_IN_Callback ();  break;
1008                 }
1009             }
1010         }
1011     }
1012 }
1013 \f
1014 void usb_lld_reset (void)
1015 {
1016   st103_set_btable ();
1017   st103_set_daddr (0);
1018 }
1019
1020 void usb_lld_txcpy (const void *src,
1021                     int ep_num, int offset, size_t len)
1022 {
1023   usb_lld_to_pmabuf (src, st103_get_tx_addr (ep_num) + offset, len);
1024 }
1025
1026 void usb_lld_write (uint8_t ep_num, const void *buf, size_t len)
1027 {
1028   usb_lld_to_pmabuf (buf, st103_get_tx_addr (ep_num), len);
1029   st103_set_tx_count (ep_num, len);
1030   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
1031 }
1032
1033 void usb_lld_rxcpy (uint8_t *dst,
1034                     int ep_num, int offset, size_t len)
1035 {
1036   usb_lld_from_pmabuf (dst, st103_get_rx_addr (ep_num) + offset, len);
1037 }
1038
1039 void usb_lld_tx_enable (int ep_num, size_t len)
1040 {
1041   st103_set_tx_count (ep_num, len);
1042   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
1043 }
1044
1045 int usb_lld_tx_data_len (int ep_num)
1046 {
1047   return st103_get_tx_count (ep_num);
1048 }
1049
1050 int usb_lld_rx_data_len (int ep_num)
1051 {
1052   return st103_get_rx_count (ep_num);
1053 }
1054
1055 void usb_lld_stall_tx (int ep_num)
1056 {
1057   st103_ep_set_tx_status (ep_num, EP_TX_STALL);
1058 }
1059
1060 void usb_lld_stall_rx (int ep_num)
1061 {
1062   st103_ep_set_rx_status (ep_num, EP_RX_STALL);
1063 }
1064
1065 void usb_lld_rx_enable (int ep_num)
1066 {
1067   st103_ep_set_rx_status (ep_num, EP_RX_VALID);
1068 }
1069
1070 void usb_lld_setup_endpoint (int ep_num, int ep_type, int ep_kind,
1071                              int ep_rx_addr, int ep_tx_addr,
1072                              int ep_rx_buf_size)
1073 {
1074   uint16_t epreg_value = st103_get_epreg (ep_num);
1075   uint16_t ep_rxtx_status = 0;  /* Both disabled */
1076
1077   /* Clear: Write 1 if 1: EP_DTOG_RX, EP_DTOG_TX */
1078   /* Set: Write:          EP_T_FIELD, EP_KIND, EPADDR_FIELD */
1079   /* Set: Toggle:         EPRX_STAT, EPTX_STAT */
1080   epreg_value &= (EPRX_STAT | EP_SETUP | EPTX_STAT | EP_DTOG_RX | EP_DTOG_TX);
1081 #if USB_KEEP_CORRECT_TRANSFER_FLAGS
1082   /* Keep: Write 1:       EP_CTR_RX, EP_CTR_TX */
1083   epreg_value |= (EP_CTR_RX|EP_CTR_TX);
1084 #else
1085   /* Clear: Write 0:      EP_CTR_RX, EP_CTR_TX */
1086 #endif
1087   epreg_value |= ep_type;
1088   epreg_value |= ep_kind;
1089   epreg_value |= ep_num;
1090
1091   if (ep_rx_addr)
1092     {
1093       ep_rxtx_status |= EP_RX_VALID;
1094       st103_set_rx_addr (ep_num, ep_rx_addr);
1095       st103_set_rx_buf_size (ep_num, ep_rx_buf_size);
1096     }
1097
1098   if (ep_tx_addr)
1099     {
1100       ep_rxtx_status |= EP_TX_NAK;
1101       st103_set_tx_addr (ep_num, ep_tx_addr);
1102     }
1103
1104   epreg_value ^= (EPRX_DTOG1 & ep_rxtx_status);
1105   epreg_value ^= (EPRX_DTOG2 & ep_rxtx_status);
1106   epreg_value ^= (EPTX_DTOG1 & ep_rxtx_status);
1107   epreg_value ^= (EPTX_DTOG2 & ep_rxtx_status);
1108
1109   st103_set_epreg (ep_num, epreg_value);
1110 }
1111
1112 void usb_lld_set_configuration (uint8_t config)
1113 {
1114   dev_p->current_configuration = config;
1115 }
1116
1117 uint8_t usb_lld_current_configuration (void)
1118 {
1119   return dev_p->current_configuration;
1120 }
1121
1122 void usb_lld_set_feature (uint8_t feature)
1123 {
1124   dev_p->current_feature = feature;
1125 }
1126
1127 void usb_lld_set_data_to_send (const void *p, size_t len)
1128 {
1129   data_p->addr = (uint8_t *)p;
1130   data_p->len = len;
1131 }
1132
1133 void usb_lld_to_pmabuf (const void *src, uint16_t addr, size_t n)
1134 {
1135   const uint8_t *s = (const uint8_t *)src;
1136   uint16_t *p;
1137   uint16_t w;
1138
1139   if (n == 0)
1140     return;
1141
1142   if ((addr & 1))
1143     {
1144       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1145       w = *p;
1146       w = (w & 0xff) | (*s++) << 8;
1147       *p = w;
1148       p += 2;
1149       n--;
1150     }
1151   else
1152     p = (uint16_t *)(PMA_ADDR + addr * 2);
1153
1154   while (n >= 2)
1155     {
1156       w = *s++;
1157       w |= (*s++) << 8;
1158       *p = w;
1159       p += 2;
1160       n -= 2;
1161     }
1162
1163   if (n > 0)
1164     {
1165       w = *s;
1166       *p = w;
1167     }
1168 }
1169
1170 void usb_lld_from_pmabuf (void *dst, uint16_t addr, size_t n)
1171 {
1172   uint8_t *d = (uint8_t *)dst;
1173   uint16_t *p;
1174   uint16_t w;
1175
1176   if (n == 0)
1177     return;
1178
1179   if ((addr & 1))
1180     {
1181       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1182       w = *p;
1183       *d++ = (w >> 8);
1184       p += 2;
1185       n--;
1186     }
1187   else
1188     p = (uint16_t *)(PMA_ADDR + addr * 2);
1189
1190   while (n >= 2)
1191     {
1192       w = *p;
1193       *d++ = (w & 0xff);
1194       *d++ = (w >> 8);
1195       p += 2;
1196       n -= 2;
1197     }
1198
1199   if (n > 0)
1200     {
1201       w = *p;
1202       *d = (w & 0xff);
1203     }
1204 }