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