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