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