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