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