USB driver update
[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   uint8_t rcp = req & RECIPIENT;
492   uint16_t status_info = 0;
493
494   if (value != 0 || length != 2 || (index >> 8) != 0
495       || (req & REQUEST_DIR) == 0)
496     return USB_UNSUPPORT;
497
498   if (rcp == DEVICE_RECIPIENT)
499     {
500       if (index == 0)
501         {
502           /* Get Device Status */
503           uint8_t feature = dev_p->current_feature;
504
505           /* Remote Wakeup enabled */
506           if ((feature & (1 << 5)))
507             status_info |= 2;
508           else
509             status_info &= ~2;
510
511           /* Bus-powered */
512           if ((feature & (1 << 6)))
513             status_info |= 1;
514           else /* Self-powered */
515             status_info &= ~1;
516
517           return usb_lld_answer_control (&status_info, 2);
518         }
519     }
520   else if (rcp == INTERFACE_RECIPIENT)
521     {
522       int r;
523
524       if (dev_p->current_configuration == 0)
525         return USB_UNSUPPORT;
526
527       r = usb_cb_interface (USB_QUERY_INTERFACE, index, 0);
528       if (r != USB_SUCCESS)
529         return USB_UNSUPPORT;
530
531       return usb_lld_answer_control (&status_info, 2);
532     }
533   else if (rcp == ENDPOINT_RECIPIENT)
534     {
535       uint8_t endpoint = (index & 0x0f);
536       uint16_t status;
537
538       if ((index & 0x70) || endpoint == ENDP0)
539         return USB_UNSUPPORT;
540
541       if ((index & 0x80))
542         {
543           status = st103_ep_get_tx_status (endpoint);
544           if (status == 0)              /* Disabled */
545             return USB_UNSUPPORT;
546           else if (status == EP_TX_STALL)
547             status_info |= 1; /* IN Endpoint stalled */
548         }
549       else
550         {
551           status = st103_ep_get_rx_status (endpoint);
552           if (status == 0)              /* Disabled */
553             return USB_UNSUPPORT;
554           else if (status == EP_RX_STALL)
555             status_info |= 1; /* OUT Endpoint stalled */
556         }
557
558       return usb_lld_answer_control (&status_info, 2);
559     }
560
561   return USB_UNSUPPORT;
562 }
563
564 static int std_clear_feature (uint8_t req, uint16_t value,
565                               uint16_t index, uint16_t length)
566 {
567   uint8_t rcp = req & RECIPIENT;
568
569   if ((req & REQUEST_DIR) == 1)
570     return USB_UNSUPPORT;
571
572   if (rcp == DEVICE_RECIPIENT)
573     {
574       if (length != 0 || index != 0)
575         return USB_UNSUPPORT;
576
577       if (value == DEVICE_REMOTE_WAKEUP)
578         {
579           dev_p->current_feature &= ~(1 << 5);
580           return USB_SUCCESS;
581         }
582     }
583   else if (rcp == ENDPOINT_RECIPIENT)
584     {
585       uint8_t endpoint = (index & 0x0f);
586       uint16_t status;
587
588       if (dev_p->current_configuration == 0)
589         return USB_UNSUPPORT;
590
591       if (length != 0 || (index >> 8) != 0 || value != ENDPOINT_STALL
592           || endpoint == ENDP0)
593         return USB_UNSUPPORT;
594
595       if ((index & 0x80))
596         status = st103_ep_get_tx_status (endpoint);
597       else
598         status = st103_ep_get_rx_status (endpoint);
599
600       if (status == 0)          /* Disabled */
601         return USB_UNSUPPORT;
602
603       if (index & 0x80)         /* IN endpoint */
604         st103_ep_clear_dtog_tx (endpoint);
605       else                      /* OUT endpoint */
606         st103_ep_clear_dtog_rx (endpoint);
607
608       // event??
609       return USB_SUCCESS;
610     }
611
612   return USB_UNSUPPORT;
613 }
614
615 static int std_set_feature (uint8_t req, uint16_t value,
616                             uint16_t index, uint16_t length)
617 {
618   uint8_t rcp = req & RECIPIENT;
619
620   if ((req & REQUEST_DIR) == 1)
621     return USB_UNSUPPORT;
622
623   if (rcp == DEVICE_RECIPIENT)
624     {
625       if (length != 0 || index != 0)
626         return USB_UNSUPPORT;
627
628       if (value == DEVICE_REMOTE_WAKEUP)
629         {
630           dev_p->current_feature |= 1 << 5;
631           // event??
632           return USB_SUCCESS;
633         }
634     }
635   else if (rcp == ENDPOINT_RECIPIENT)
636     {
637       uint8_t endpoint = (index & 0x0f);
638       uint32_t status;
639
640       if (dev_p->current_configuration == 0)
641         return USB_UNSUPPORT;
642
643       if (length != 0 || (index >> 8) != 0 || value != 0 || endpoint == ENDP0)
644         return USB_UNSUPPORT;
645
646       if ((index & 0x80))
647         status = st103_ep_get_tx_status (endpoint);
648       else
649         status = st103_ep_get_rx_status (endpoint);
650
651       if (status == 0)          /* Disabled */
652         return USB_UNSUPPORT;
653
654       if (index & 0x80)
655         /* IN endpoint */
656         st103_ep_set_tx_status (endpoint, EP_TX_STALL);
657       else
658         /* OUT endpoint */
659         st103_ep_set_rx_status (endpoint, EP_RX_STALL);
660
661       // event??
662       return USB_SUCCESS;
663     }
664
665   return USB_UNSUPPORT;
666 }
667
668 static int std_set_address (uint8_t req, uint16_t value,
669                             uint16_t index, uint16_t length)
670 {
671   uint8_t rcp = req & RECIPIENT;
672
673   if ((req & REQUEST_DIR) == 1)
674     return USB_UNSUPPORT;
675
676   if (rcp == DEVICE_RECIPIENT)
677     {
678       if (length == 0 && value <= 127 && index == 0
679           && dev_p->current_configuration == 0)
680         return USB_SUCCESS;
681     }
682
683   return USB_UNSUPPORT;
684 }
685
686 static int std_get_descriptor (uint8_t req, uint16_t value,
687                                uint16_t index, uint16_t length)
688 {
689   uint8_t rcp = req & RECIPIENT;
690
691   if ((req & REQUEST_DIR) == 0)
692     return USB_UNSUPPORT;
693
694   (void)length;
695   return usb_cb_get_descriptor (rcp, (value >> 8), (value & 0xff),
696                                 index, length);
697 }
698
699 static int std_get_configuration (uint8_t req, uint16_t value,
700                                   uint16_t index, uint16_t length)
701 {
702   uint8_t rcp = req & RECIPIENT;
703
704   if ((req & REQUEST_DIR) == 0)
705     return USB_UNSUPPORT;
706
707   (void)value;  (void)index;  (void)length;
708   if (rcp == DEVICE_RECIPIENT)
709     return usb_lld_answer_control (&dev_p->current_configuration, 1);
710
711   return USB_UNSUPPORT;
712 }
713
714 static int std_set_configuration (uint8_t req, uint16_t value,
715                                   uint16_t index, uint16_t length)
716 {
717   uint8_t rcp = req & RECIPIENT;
718
719   if ((req & REQUEST_DIR) == 1)
720     return USB_UNSUPPORT;
721
722   if (rcp == DEVICE_RECIPIENT && index == 0 && length == 0)
723     {
724       int r;
725
726       r = usb_cb_handle_event (USB_EVENT_CONFIG, value);
727       if (r == USB_SUCCESS)
728         return USB_SUCCESS;
729     }
730
731   return USB_UNSUPPORT;
732 }
733
734 static int std_get_interface (uint8_t req, uint16_t value,
735                               uint16_t index, uint16_t length)
736 {
737   uint8_t rcp = req & RECIPIENT;
738
739   if ((req & REQUEST_DIR) == 0)
740     return USB_UNSUPPORT;
741
742   if (rcp == INTERFACE_RECIPIENT)
743     {
744       if (value != 0 || (index >> 8) != 0 || length != 1)
745         return USB_UNSUPPORT;
746
747       if (dev_p->current_configuration == 0)
748         return USB_UNSUPPORT;
749
750       return usb_cb_interface (USB_GET_INTERFACE, index, 0);
751     }
752
753   return USB_UNSUPPORT;
754 }
755
756 static int std_set_interface (uint8_t req, uint16_t value,
757                               uint16_t index, uint16_t length)
758 {
759   uint8_t rcp = req & RECIPIENT;
760
761   if ((req & REQUEST_DIR) == 1)
762     return USB_UNSUPPORT;
763
764   if (rcp == INTERFACE_RECIPIENT)
765     {
766       int r;
767
768       if (length != 0 || (index >> 8) != 0 || (value >> 8) != 0)
769         return  USB_UNSUPPORT;
770
771       if (dev_p->current_configuration != 0)
772         return USB_UNSUPPORT;
773
774       r = usb_cb_interface (USB_SET_INTERFACE, index, value);
775       if (r == USB_SUCCESS)
776         return USB_SUCCESS;
777     }
778
779   return USB_UNSUPPORT;
780 }
781
782
783 static void handle_setup0 (void)
784 {
785   const uint16_t *pw;
786   uint16_t w;
787   uint8_t req;
788   int r = USB_UNSUPPORT;
789   HANDLER handler;
790
791   pw = (uint16_t *)(PMA_ADDR + (uint8_t *)(st103_get_rx_addr (ENDP0) * 2));
792   w = *pw++;
793
794   ctrl_p->bmRequestType = w & 0xff;
795   ctrl_p->bRequest = req = w >> 8;
796   pw++;
797   ctrl_p->wValue = *pw++;
798   pw++;
799   ctrl_p->wIndex  = *pw++;
800   pw++;
801   ctrl_p->wLength = *pw;
802
803   data_p->addr = NULL;
804   data_p->len = 0;
805   data_p->offset = 0;
806
807   if ((ctrl_p->bmRequestType & REQUEST_TYPE) == STANDARD_REQUEST)
808     {
809       if (req < TOTAL_REQUEST)
810         {
811           switch (req)
812             {
813             case 0: handler = std_get_status;  break;
814             case 1: handler = std_clear_feature;  break;
815             case 3: handler = std_set_feature;  break;
816             case 5: handler = std_set_address;  break;
817             case 6: handler = std_get_descriptor;  break;
818             case 8: handler = std_get_configuration;  break;
819             case 9: handler = std_set_configuration;  break;
820             case 10: handler = std_get_interface;  break;
821             case 11: handler = std_set_interface;  break;
822             default: handler = std_none;  break;
823             }
824
825           r = (*handler) (ctrl_p->bmRequestType,
826                           ctrl_p->wValue, ctrl_p->wIndex, ctrl_p->wLength);
827         }
828     }
829   else
830     r = usb_cb_setup (ctrl_p->bmRequestType, req,
831                       ctrl_p->wValue, ctrl_p->wIndex, ctrl_p->wLength);
832
833   if (r != USB_SUCCESS)
834     dev_p->state = STALLED;
835   else
836     {
837       if (USB_SETUP_GET (ctrl_p->bmRequestType))
838         ;
839       else if (ctrl_p->wLength == 0)
840         {
841           dev_p->state = WAIT_STATUS_IN;
842           st103_set_tx_count (ENDP0, 0);
843           st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_VALID);
844         }
845       else
846         {
847           dev_p->state = OUT_DATA;
848           st103_ep_set_rx_status (ENDP0, EP_RX_VALID);
849         }
850     }
851 }
852
853 static void handle_in0 (void)
854 {
855   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
856     handle_datastage_in ();
857   else if (dev_p->state == WAIT_STATUS_IN)
858     {
859       if ((ctrl_p->bRequest == SET_ADDRESS) &&
860           ((ctrl_p->bmRequestType & (REQUEST_TYPE | RECIPIENT))
861            == (STANDARD_REQUEST | DEVICE_RECIPIENT)))
862         {
863           st103_set_daddr (ctrl_p->wValue);
864           usb_cb_handle_event (USB_EVENT_ADDRESS, ctrl_p->wValue);
865         }
866       else
867         usb_cb_ctrl_write_finish  (ctrl_p->bmRequestType,
868                                    ctrl_p->bRequest, ctrl_p->wValue,
869                                    ctrl_p->wIndex, ctrl_p->wLength);
870
871       dev_p->state = STALLED;
872     }
873   else
874     dev_p->state = STALLED;
875 }
876
877 static void handle_out0 (void)
878 {
879   if (dev_p->state == IN_DATA || dev_p->state == LAST_IN_DATA)
880     /* host aborts the transfer before finish */
881     dev_p->state = STALLED;
882   else if (dev_p->state == OUT_DATA)
883     handle_datastage_out ();
884   else if (dev_p->state == WAIT_STATUS_OUT)
885     dev_p->state = STALLED;
886   /* Unexpect state, STALL the endpoint */
887   else
888     dev_p->state = STALLED;
889 }
890 \f
891 static void nop_proc (void)
892 {
893 }
894
895 #define WEAK __attribute__ ((weak, alias ("nop_proc")))
896 void WEAK EP1_IN_Callback (void);
897 void WEAK EP2_IN_Callback (void);
898 void WEAK EP3_IN_Callback (void);
899 void WEAK EP4_IN_Callback (void);
900 void WEAK EP5_IN_Callback (void);
901 void WEAK EP6_IN_Callback (void);
902 void WEAK EP7_IN_Callback (void);
903
904 void WEAK EP1_OUT_Callback (void);
905 void WEAK EP2_OUT_Callback (void);
906 void WEAK EP3_OUT_Callback (void);
907 void WEAK EP4_OUT_Callback (void);
908 void WEAK EP5_OUT_Callback (void);
909 void WEAK EP6_OUT_Callback (void);
910 void WEAK EP7_OUT_Callback (void);
911
912 static void
913 usb_handle_transfer (uint16_t istr_value)
914 {
915   uint16_t ep_value = 0;
916   uint8_t ep_index;
917
918   ep_index = (istr_value & ISTR_EP_ID);
919   /* Decode and service non control endpoints interrupt  */
920   /* process related endpoint register */
921   ep_value = st103_get_epreg (ep_index);
922
923   if (ep_index == 0)
924     {
925       if ((ep_value & EP_CTR_TX))
926         {
927           st103_ep_clear_ctr_tx (ep_index);
928           handle_in0 ();
929         }
930
931       if ((ep_value & EP_CTR_RX))
932         {
933           st103_ep_clear_ctr_rx (ep_index);
934
935           if ((ep_value & EP_SETUP))
936             handle_setup0 ();
937           else
938             handle_out0 ();
939         }
940
941       if (dev_p->state == STALLED)
942         st103_ep_set_rxtx_status (ENDP0, EP_RX_STALL, EP_TX_STALL);
943     }
944   else
945     {
946       if ((ep_value & EP_CTR_RX))
947         {
948           st103_ep_clear_ctr_rx (ep_index);
949           switch ((ep_index - 1))
950             {
951             case 0: EP1_OUT_Callback ();  break;
952             case 1: EP2_OUT_Callback ();  break;
953             case 2: EP3_OUT_Callback ();  break;
954             case 3: EP4_OUT_Callback ();  break;
955             case 4: EP5_OUT_Callback ();  break;
956             case 5: EP6_OUT_Callback ();  break;
957             case 6: EP7_OUT_Callback ();  break;
958             }
959         }
960
961       if ((ep_value & EP_CTR_TX))
962         {
963           st103_ep_clear_ctr_tx (ep_index);
964           switch ((ep_index - 1))
965             {
966             case 0: EP1_IN_Callback ();  break;
967             case 1: EP2_IN_Callback ();  break;
968             case 2: EP3_IN_Callback ();  break;
969             case 3: EP4_IN_Callback ();  break;
970             case 4: EP5_IN_Callback ();  break;
971             case 5: EP6_IN_Callback ();  break;
972             case 6: EP7_IN_Callback ();  break;
973             }
974         }
975     }
976 }
977 \f
978 void usb_lld_reset (void)
979 {
980   st103_set_btable ();
981   st103_set_daddr (0);
982 }
983
984 void usb_lld_txcpy (const void *src,
985                     int ep_num, int offset, size_t len)
986 {
987   usb_lld_to_pmabuf (src, st103_get_tx_addr (ep_num) + offset, len);
988 }
989
990 void usb_lld_write (uint8_t ep_num, const void *buf, size_t len)
991 {
992   usb_lld_to_pmabuf (buf, st103_get_tx_addr (ep_num), len);
993   st103_set_tx_count (ep_num, len);
994   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
995 }
996
997 void usb_lld_rxcpy (uint8_t *dst,
998                     int ep_num, int offset, size_t len)
999 {
1000   usb_lld_from_pmabuf (dst, st103_get_rx_addr (ep_num) + offset, len);
1001 }
1002
1003 void usb_lld_tx_enable (int ep_num, size_t len)
1004 {
1005   st103_set_tx_count (ep_num, len);
1006   st103_ep_set_tx_status (ep_num, EP_TX_VALID);
1007 }
1008
1009 int usb_lld_tx_data_len (int ep_num)
1010 {
1011   return st103_get_tx_count (ep_num);
1012 }
1013
1014 int usb_lld_rx_data_len (int ep_num)
1015 {
1016   return st103_get_rx_count (ep_num);
1017 }
1018
1019 void usb_lld_stall_tx (int ep_num)
1020 {
1021   st103_ep_set_tx_status (ep_num, EP_TX_STALL);
1022 }
1023
1024 void usb_lld_stall_rx (int ep_num)
1025 {
1026   st103_ep_set_rx_status (ep_num, EP_RX_STALL);
1027 }
1028
1029 void usb_lld_rx_enable (int ep_num)
1030 {
1031   st103_ep_set_rx_status (ep_num, EP_RX_VALID);
1032 }
1033
1034 void usb_lld_setup_endpoint (int ep_num, int ep_type, int ep_kind,
1035                              int ep_rx_addr, int ep_tx_addr,
1036                              int ep_rx_buf_size)
1037 {
1038   uint16_t epreg_value = st103_get_epreg (ep_num);
1039   uint16_t ep_rxtx_status = 0;  /* Both disabled */
1040
1041   /* Clear: Write 1 if 1: EP_DTOG_RX, EP_DTOG_TX */
1042   /* Set: Write:          EP_T_FIELD, EP_KIND, EPADDR_FIELD */
1043   /* Set: Toggle:         EPRX_STAT, EPTX_STAT */
1044   epreg_value &= (EPRX_STAT | EP_SETUP | EPTX_STAT | EP_DTOG_RX | EP_DTOG_TX);
1045 #if USB_KEEP_CORRECT_TRANSFER_FLAGS
1046   /* Keep: Write 1:       EP_CTR_RX, EP_CTR_TX */
1047   epreg_value |= (EP_CTR_RX|EP_CTR_TX);
1048 #else
1049   /* Clear: Write 0:      EP_CTR_RX, EP_CTR_TX */
1050 #endif
1051   epreg_value |= ep_type;
1052   epreg_value |= ep_kind;
1053   epreg_value |= ep_num;
1054
1055   if (ep_rx_addr)
1056     {
1057       ep_rxtx_status |= EP_RX_VALID;
1058       st103_set_rx_addr (ep_num, ep_rx_addr);
1059       st103_set_rx_buf_size (ep_num, ep_rx_buf_size);
1060     }
1061
1062   if (ep_tx_addr)
1063     {
1064       ep_rxtx_status |= EP_TX_NAK;
1065       st103_set_tx_addr (ep_num, ep_tx_addr);
1066     }
1067
1068   epreg_value ^= (EPRX_DTOG1 & ep_rxtx_status);
1069   epreg_value ^= (EPRX_DTOG2 & ep_rxtx_status);
1070   epreg_value ^= (EPTX_DTOG1 & ep_rxtx_status);
1071   epreg_value ^= (EPTX_DTOG2 & ep_rxtx_status);
1072
1073   st103_set_epreg (ep_num, epreg_value);
1074 }
1075
1076 void usb_lld_set_configuration (uint8_t config)
1077 {
1078   dev_p->current_configuration = config;
1079 }
1080
1081 uint8_t usb_lld_current_configuration (void)
1082 {
1083   return dev_p->current_configuration;
1084 }
1085
1086 void usb_lld_set_feature (uint8_t feature)
1087 {
1088   dev_p->current_feature = feature;
1089 }
1090
1091 void usb_lld_set_data_to_recv (const void *p, size_t len)
1092 {
1093   data_p->addr = (uint8_t *)p;
1094   data_p->len = len;
1095 }
1096
1097 void usb_lld_to_pmabuf (const void *src, uint16_t addr, size_t n)
1098 {
1099   const uint8_t *s = (const uint8_t *)src;
1100   uint16_t *p;
1101   uint16_t w;
1102
1103   if (n == 0)
1104     return;
1105
1106   if ((addr & 1))
1107     {
1108       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1109       w = *p;
1110       w = (w & 0xff) | (*s++) << 8;
1111       *p = w;
1112       p += 2;
1113       n--;
1114     }
1115   else
1116     p = (uint16_t *)(PMA_ADDR + addr * 2);
1117
1118   while (n >= 2)
1119     {
1120       w = *s++;
1121       w |= (*s++) << 8;
1122       *p = w;
1123       p += 2;
1124       n -= 2;
1125     }
1126
1127   if (n > 0)
1128     {
1129       w = *s;
1130       *p = w;
1131     }
1132 }
1133
1134 void usb_lld_from_pmabuf (void *dst, uint16_t addr, size_t n)
1135 {
1136   uint8_t *d = (uint8_t *)dst;
1137   uint16_t *p;
1138   uint16_t w;
1139
1140   if (n == 0)
1141     return;
1142
1143   if ((addr & 1))
1144     {
1145       p = (uint16_t *)(PMA_ADDR + (addr - 1) * 2);
1146       w = *p;
1147       *d++ = (w >> 8);
1148       p += 2;
1149       n--;
1150     }
1151   else
1152     p = (uint16_t *)(PMA_ADDR + addr * 2);
1153
1154   while (n >= 2)
1155     {
1156       w = *p;
1157       *d++ = (w & 0xff);
1158       *d++ = (w >> 8);
1159       p += 2;
1160       n -= 2;
1161     }
1162
1163   if (n > 0)
1164     {
1165       w = *p;
1166       *d = (w & 0xff);
1167     }
1168 }
1169
1170
1171 /*
1172  * BUF: Pointer to data memory.  Data memory should not be allocated
1173  *      on stack when BUFLEN > USB_MAX_PACKET_SIZE.
1174  *
1175  * BUFLEN: size of the data.
1176  */
1177 int
1178 usb_lld_answer_control (const void *buf, size_t buflen)
1179 {
1180   uint32_t len_asked = ctrl_p->wLength;
1181   uint32_t len;
1182
1183   data_p->addr = (void *)buf;
1184   data_p->len = buflen;
1185
1186   /* Restrict the data length to be the one host asks for */
1187   if (data_p->len > len_asked)
1188     data_p->len = len_asked;
1189
1190   if (data_p->len != 0 && (data_p->len % USB_MAX_PACKET_SIZE) == 0)
1191     data_p->require_zlp = TRUE;
1192   else
1193     data_p->require_zlp = FALSE;
1194
1195   if (data_p->len < USB_MAX_PACKET_SIZE)
1196     {
1197       len = data_p->len;
1198       dev_p->state = LAST_IN_DATA;
1199     }
1200   else
1201     {
1202       len = USB_MAX_PACKET_SIZE;
1203       dev_p->state = IN_DATA;
1204     }
1205
1206   if (len)
1207     {
1208       usb_lld_to_pmabuf (data_p->addr, st103_get_tx_addr (ENDP0), len);
1209       data_p->len -= len;
1210       data_p->offset += len;
1211     }
1212
1213   st103_set_tx_count (ENDP0, len);
1214   st103_ep_set_tx_status (ENDP0, EP_TX_VALID);
1215   return USB_SUCCESS;
1216 }