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