STM32: USB: device, interface and endpoint status is always uint16_t
[bertos.git] / bertos / cpu / cortex-m3 / drv / usb_stm32.c
1 /**
2  * \file
3  * <!--
4  * This file is part of BeRTOS.
5  *
6  * Bertos is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * As a special exception, you may use this file as part of a free software
21  * library without restriction.  Specifically, if other files instantiate
22  * templates or use macros or inline functions from this file, or you compile
23  * this file and link it with other files to produce an executable, this
24  * file does not by itself cause the resulting executable to be covered by
25  * the GNU General Public License.  This exception does not however
26  * invalidate any other reasons why the executable file might be covered by
27  * the GNU General Public License.
28  *
29  * Copyright 2010 Develer S.r.l. (http://www.develer.com/)
30  *
31  * -->
32  *
33  * \brief STM32 USB driver
34  *
35  * \author Andrea Righi <arighi@develer.com>
36  */
37
38 #include "cfg/cfg_usb.h"
39
40 #define LOG_LEVEL  USB_LOG_LEVEL
41 #define LOG_FORMAT USB_LOG_FORMAT
42
43 #include <cfg/log.h>
44 #include <cfg/debug.h>
45 #include <cfg/macros.h>
46 #include <cfg/module.h>
47
48 #include <cpu/irq.h>
49 #include <cpu/power.h>
50
51 #include <drv/irq_cm3.h>
52 #include <drv/gpio_stm32.h>
53 #include <drv/clock_stm32.h>
54 #include <drv/timer.h>
55 #include <drv/usb.h>
56
57 #include <string.h> /* memcpy() */
58
59 #include "usb_stm32.h"
60
61 #define ALIGN_UP(value, align)  (((value) & ((align) - 1)) ? \
62                                 (((value) + ((align) - 1)) & ~((align) - 1)) : \
63                                 (value))
64 /* STM32 USB registers */
65 struct stm32_usb
66 {
67         reg32_t EP0R;
68         reg32_t EP1R;
69         reg32_t EP2R;
70         reg32_t EP3R;
71         reg32_t EP4R;
72         reg32_t EP5R;
73         reg32_t EP6R;
74         reg32_t EP7R;
75         reg32_t __reserved[8];
76         reg32_t CNTR;
77         reg32_t ISTR;
78         reg32_t FNR;
79         reg32_t DADDR;
80         reg32_t BTABLE;
81 };
82
83 /* Hardware registers */
84 static struct stm32_usb *usb = (struct stm32_usb *)USB_BASE_ADDR;
85
86 /* Endpoint descriptors: used for handling requests to use with endpoints */
87 static stm32_usb_ep_t ep_cnfg[ENP_MAX_NUMB];
88
89 /* USB EP0 control descriptor */
90 static const usb_endpoint_descriptor_t USB_CtrlEpDescr0 =
91 {
92         .bLength = sizeof(USB_CtrlEpDescr0),
93         .bDescriptorType = USB_DT_ENDPOINT,
94         .bEndpointAddress = USB_DIR_OUT | 0,
95         .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
96         .wMaxPacketSize = USB_EP0_MAX_SIZE,
97         .bInterval = 0,
98 };
99
100 /* USB EP1 control descriptor */
101 static const usb_endpoint_descriptor_t USB_CtrlEpDescr1 =
102 {
103         .bLength = sizeof(USB_CtrlEpDescr1),
104         .bDescriptorType = USB_DT_ENDPOINT,
105         .bEndpointAddress = USB_DIR_IN | 0,
106         .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
107         .wMaxPacketSize = USB_EP0_MAX_SIZE,
108         .bInterval = 0,
109 };
110
111 /* USB setup packet */
112 static usb_ctrlrequest_t setup_packet;
113
114 /* USB device controller: max supported interfaces */
115 #define USB_MAX_INTERFACE       1
116
117 /* USB device controller features */
118 #define STM32_UDC_FEATURE_SELFPOWERED   BV(0)
119 #define STM32_UDC_FEATURE_REMOTE_WAKEUP BV(1)
120
121 /* Hardware-specific USB device controller structure */
122 typedef struct stm32_udc
123 {
124         uint8_t state;
125         uint32_t cfg_id;
126         const usb_config_descriptor_t *cfg;
127         uint32_t interfaces;
128         uint32_t alt[USB_MAX_INTERFACE];
129         uint32_t address;
130         uint8_t feature;
131 } PACKED stm32_udc_t;
132
133 /* Hardware-specific USB Device Controller */
134 static stm32_udc_t udc;
135
136 /* Generic USB Device Controller structure */
137 static struct usb_device *usb_dev;
138
139 /* USB packet memory management: list of allocated chunks */
140 static pack_mem_slot_t *pPacketMemUse;
141
142 /* USB packet memory management: memory buffer metadata */
143 #define EP_MAX_SLOTS    16
144 static pack_mem_slot_t PacketMemBuff[EP_MAX_SLOTS];
145
146 /* Allocate a free block of the packet memory */
147 static pack_mem_slot_t *usb_malloc(void)
148 {
149         unsigned int i;
150
151         for (i = 0; i < countof(PacketMemBuff); i++)
152                 if (PacketMemBuff[i].Size == 0)
153                         return &PacketMemBuff[i];
154         return NULL;
155 }
156
157 /* Release a block of the packet memory */
158 static void usb_free(pack_mem_slot_t *pPntr)
159 {
160         pPntr->Size = 0;
161 }
162
163 /* Allocate a free chunk of the packet memory (inside a block) */
164 static bool USB_AllocateBuffer(uint16_t *pOffset, uint32_t *pPacketSize,
165                             int EndPoint)
166 {
167         pack_mem_slot_t *pPacketMem = pPacketMemUse,
168                         *pPacketMemNext, *pPacketMemUseNew;
169         uint32_t MaxPacketSize = *pPacketSize;
170
171         /*
172          * Packet size alignment:
173          *  - fine-granularity allocation: size alignment by 2;
174          *  - coarse-granularity allocation: size alignment by 32.
175          */
176         if (MaxPacketSize < 62)
177                 MaxPacketSize = ALIGN_UP(MaxPacketSize, 2);
178         else
179                 MaxPacketSize = ALIGN_UP(MaxPacketSize, 32);
180         /*
181          * Finding free memory chunks from the allocated blocks of the USB
182          * packet memory.
183          */
184         *pOffset = 0;
185         while (pPacketMem != NULL)
186         {
187                 /* Offset alignment by 4 */
188                 *pOffset = ALIGN_UP(pPacketMem->Start + pPacketMem->Size, 4);
189                 pPacketMemNext = pPacketMem->next;
190                 if ((pPacketMem->next == NULL) ||
191                                 (pPacketMemNext->Start >=
192                                         *pOffset + MaxPacketSize))
193                         break;
194                 pPacketMem = pPacketMem->next;
195         }
196         /* Check for out-of-memory condition */
197         if ((*pOffset + MaxPacketSize) >= USB_BDT_OFFSET)
198                 return false;
199         /*
200          * Allocate a new memory block, next to the last allocated block.
201          */
202         pPacketMemUseNew = usb_malloc();
203         if (pPacketMemUseNew == NULL)
204                 return false;
205         /* Insert the block to the list of allocated blocks */
206         if (pPacketMemUse == NULL)
207         {
208                 pPacketMemUse = pPacketMemUseNew;
209                 pPacketMemUse->next = NULL;
210         }
211         else
212         {
213                 pPacketMemUseNew->next = pPacketMem->next;
214                 pPacketMem->next = pPacketMemUseNew;
215         }
216         /* Update block's metadata */
217         pPacketMemUseNew->ep_addr = EndPoint;
218         pPacketMemUseNew->Start = *pOffset;
219         pPacketMemUseNew->Size = MaxPacketSize;
220
221         *pPacketSize = MaxPacketSize;
222
223         return true;
224 }
225
226 /* Release a chunk of the packet memory (inside a block) */
227 static void USB_ReleaseBuffer(int EndPoint)
228 {
229         pack_mem_slot_t *pPacketMem, *pPacketMemPrev = NULL;
230         pPacketMem = pPacketMemUse;
231
232         while (pPacketMem != NULL)
233         {
234                 if (pPacketMem->ep_addr == EndPoint)
235                 {
236                         if (UNLIKELY(pPacketMemPrev == NULL))
237                         {
238                                 /* Free the first element of the list */
239                                 pPacketMemUse = pPacketMemUse->next;
240                                 usb_free(pPacketMem);
241                                 pPacketMem = pPacketMemUse;
242                                 continue;
243                         }
244                         pPacketMemPrev->next = pPacketMem->next;
245                         usb_free(pPacketMem);
246                 }
247                 else
248                         pPacketMemPrev = pPacketMem;
249                 pPacketMem = pPacketMemPrev->next;
250         }
251 }
252
253 /*-------------------------------------------------------------------------*/
254
255 /* Connect USB controller */
256 static void usb_connect(void)
257 {
258         stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE, 1 << 11, 0);
259 }
260
261 /* Set USB device address */
262 static void usb_set_address(uint32_t addr)
263 {
264         usb->DADDR = addr | 0x80;
265 }
266
267 /* Suspend USB controller */
268 static void usb_suspend(void)
269 {
270         usb->CNTR |= bmFSUSP | bmLPMODE;
271 }
272
273 /* Resume USB controller */
274 static void usb_resume(void)
275 {
276         uint32_t line_status;
277
278         line_status = usb->FNR & 0xc000;
279         if (!line_status)
280                 return;
281         /* check for noise and eventually return to sleep */
282         if (line_status == 0xc000)
283                 usb_suspend();
284         else
285                 usb->CNTR &= ~(bmFSUSP | bmLPMODE);
286 }
287
288 /* Convert logical EP address to physical EP address */
289 static int USB_EpLogToPhysAdd(uint8_t ep_addr)
290 {
291         int addr = (ep_addr & 0x0f) << 1;
292         return (ep_addr & 0x80) ? addr + 1 : addr;
293 }
294
295 /* Set EP address */
296 static void EpCtrlSet_EA(reg32_t *reg, uint32_t val)
297 {
298         val &= 0x0f;
299         val |= *reg & 0x0700;
300         val |= USB_CTRL_CLEAR_ONLY_MASK;
301         *reg = val;
302 }
303
304 /* Get EP IN status */
305 static uint32_t EpCtrlGet_STAT_TX(reg32_t *reg)
306 {
307         return (*reg & (0x3UL << 4)) >> 4;
308 }
309
310 /* Set EP IN state */
311 static void EpCtrlSet_STAT_TX(reg32_t *reg, ep_state_t val)
312 {
313         uint32_t state;
314         int i;
315
316         /*
317          * The EP can change state between read and write operations from VALID
318          * to NAK and result of set operation will be invalid.
319          */
320         for (i = 0; i < 2; i++)
321         {
322                 if (EpCtrlGet_STAT_TX(reg) == val)
323                         return;
324                 state = val;
325                 state <<= 4;
326                 state ^= *reg;
327                 state |= USB_CTRL_CLEAR_ONLY_MASK;
328                 /* Clear the toggle bits without STAT_TX (4,5) */
329                 state &= ~0x7040;
330                 *reg = state;
331         }
332 }
333
334 /* Set EP DTOG_TX bit (IN) */
335 static void EpCtrlSet_DTOG_TX(reg32_t *reg, uint32_t val)
336 {
337         val = val ? (*reg ^ (1UL << 6)) : *reg;
338         /* Clear the toggle bits without DTOG_TX (6) */
339         val &= ~0x7030;
340         val |= USB_CTRL_CLEAR_ONLY_MASK;
341         *reg = val;
342 }
343
344 /* Clear EP CTR_TX bit (IN) */
345 static void EpCtrlClr_CTR_TX(reg32_t *reg)
346 {
347         uint32_t val = *reg;
348
349         val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 7);
350         /* Set RX_CTR */
351         val |= 1UL << 15;
352         *reg = val;
353 }
354
355 /* Clear EP CTR_RX bit (OUT) */
356 static void EpCtrlClr_CTR_RX(reg32_t *reg)
357 {
358         uint32_t val = *reg;
359         val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 15);
360         /* Set TX_CTR */
361         val |= 1UL << 7;
362         *reg = val;
363 }
364
365 /* Set EP KIND bit */
366 static void EpCtrlSet_EP_KIND(reg32_t *reg, uint32_t val)
367 {
368         val = val ? (1UL << 8) : 0;
369         val |= *reg & ~(USB_CTRL_TOGGLE_MASK | (1UL << 8));
370         val |= USB_CTRL_CLEAR_ONLY_MASK;
371         *reg = val;
372 }
373
374 /* Set EP type */
375 static int EpCtrlSet_EP_TYPE(reg32_t *reg, uint8_t val)
376 {
377         uint32_t type;
378
379         if (UNLIKELY(val >= EP_TYPE_MAX))
380         {
381                 ASSERT(0);
382                 return USB_INVAL_ERROR;
383         }
384         type = val;
385         type <<= 9;
386         type |= *reg & ~(USB_CTRL_TOGGLE_MASK | (0x3UL << 9));
387         type |= USB_CTRL_CLEAR_ONLY_MASK;
388         *reg = type;
389
390         return USB_OK;
391 }
392
393 /* Get EP STAT_RX (OUT) */
394 static uint32_t EpCtrlGet_STAT_RX(reg32_t *reg)
395 {
396         uint32_t val = *reg & (0x3UL << 12);
397         return val >> 12;
398 }
399
400 /* Set EP STAT_RX (OUT) */
401 static void EpCtrlSet_STAT_RX(reg32_t *reg, ep_state_t val)
402 {
403         uint32_t state;
404         int i;
405
406         /*
407          * The EP can change state between read and write operations from VALID
408          * to NAK and result of set operation will be invalid.
409          */
410         for (i = 0; i < 2; i++)
411         {
412                 if (EpCtrlGet_STAT_RX(reg) == val)
413                         return;
414                 state = val;
415                 state <<= 12;
416                 state ^= *reg;
417                 state |= USB_CTRL_CLEAR_ONLY_MASK;
418                 /* Clear the toggle bits without STAT_RX (12,13) */
419                 state &= ~0x4070;
420                 *reg = state;
421         }
422 }
423
424 /* Set DTOG_RX bit */
425 static void EpCtrlSet_DTOG_RX(reg32_t *reg, uint32_t val)
426 {
427         val = val ? (*reg ^ (1UL << 14)) : *reg;
428         /* Clear the toggle bits without DTOG_RX (14) */
429         val &= ~0x3070;
430         val |= USB_CTRL_CLEAR_ONLY_MASK;
431         *reg = val;
432 }
433
434 /* Get EP SETUP bit */
435 static uint32_t EpCtrlGet_SETUP(reg32_t *reg)
436 {
437         uint32_t val = *reg & (1UL << 11);
438         return val ? 1 : 0;
439 }
440
441 /* Core endpoint I/O function */
442 static void __usb_ep_io(int EP)
443 {
444         ssize_t Count, CountHold, Offset;
445         uint32_t *pDst, *pSrc, Data;
446         bool CurrentBuffer;
447         stm32_usb_ep_t *epd = &ep_cnfg[EP];
448
449         if (UNLIKELY(epd->hw == NULL))
450         {
451                 LOG_ERR("%s: invalid endpoint (EP%d-%s)\n",
452                                 __func__,
453                                 EP >> 1,
454                                 (EP & 0x01) ? "IN" : "OUT");
455                 ASSERT(0);
456                 return;
457         }
458         if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
459                 return;
460
461         if (EP & 0x01)
462         {
463                 /* EP IN */
464                 Count = epd->size - epd->offset;
465                 while (epd->avail_data)
466                 {
467                         if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
468                                 break;
469
470                         /* Set Status */
471                         epd->status = BEGIN_SERVICED;
472                         /* Get data size */
473                         if ((epd->flags & STM32_USB_EP_ZERO_PACKET) &&
474                                         (Count == epd->max_size))
475                                 epd->flags |= STM32_USB_EP_ZERO_PACKET |
476                                                 STM32_USB_EP_ZERO_POSSIBLE;
477
478                         CountHold = Count = MIN(Count, epd->max_size);
479                         if (!Count)
480                                 epd->flags |= STM32_USB_EP_ZERO_PACKET;
481                         Offset = epd->offset;
482                         epd->offset += Count;
483                         CurrentBuffer = true;
484                         switch (epd->type)
485                         {
486                         case USB_ENDPOINT_XFER_CONTROL:
487                         case USB_ENDPOINT_XFER_INT:
488                                 pDst = (uint32_t *)addr2usbmem(ReadEpDTB_AddrTx(EP >> 1));
489                                 break;
490                         case USB_ENDPOINT_XFER_BULK:
491                                 pDst = (uint32_t *)addr2usbmem(ReadEpDTB_AddrTx(EP >> 1));
492                                 break;
493                         case USB_ENDPOINT_XFER_ISOC:
494                                 LOG_ERR("%s: isochronous transfer not supported\n",
495                                         __func__);
496                                 /* Fallback to default */
497                         default:
498                                 ASSERT(0);
499                                 return;
500                         }
501
502                         /* Write data to packet memory buffer */
503                         while (Count)
504                         {
505                                 Data = *(epd->write_buffer + Offset++);
506                                 if (--Count)
507                                 {
508                                         Data |= (uint32_t)(*(epd->write_buffer + Offset++)) << 8;
509                                         --Count;
510                                 }
511                                 *pDst++ = Data;
512                         }
513
514                         if (CurrentBuffer)
515                                 WriteEpDTB_CountTx(EP >> 1, CountHold);
516                         else
517                                 WriteEpDTB_CountRx(EP >> 1, CountHold);
518
519                         EpCtrlSet_STAT_TX(epd->hw, EP_VALID);
520
521                         --ep_cnfg[EP].avail_data;
522                         Count = epd->size - epd->offset;
523                 }
524                 if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
525                 {
526                         epd->status = COMPLETE;
527                         /* call callback function */
528                         if (epd->complete)
529                                 epd->complete(EP);
530                 }
531         }
532         else
533         {
534                 /* EP OUT */
535                 while (epd->avail_data)
536                 {
537                         /* Get data size and buffer pointer */
538                         switch (epd->type)
539                         {
540                         case USB_ENDPOINT_XFER_CONTROL:
541                         case USB_ENDPOINT_XFER_INT:
542                                 /* Get received bytes number */
543                                 Count = ReadEpDTB_CountRx(EP >> 1) & 0x3FF;
544                                 /* Get address of the USB packet buffer for corresponding EP */
545                                 pSrc = (uint32_t *)addr2usbmem(ReadEpDTB_AddrRx(EP >> 1));
546                                 break;
547                         case USB_ENDPOINT_XFER_BULK:
548                                 /* Get received bytes number */
549                                 Count = ReadEpDTB_CountRx(EP >> 1) & 0x3FF;
550                                 /* Get address of the USB packet buffer for corresponding EP */
551                                 pSrc = (uint32_t *)addr2usbmem(ReadEpDTB_AddrRx(EP >> 1));
552                                 break;
553                         case USB_ENDPOINT_XFER_ISOC:
554                                 LOG_ERR("%s: isochronous transfer not supported\n",
555                                         __func__);
556                                 /* Fallback to default */
557                         default:
558                                 ASSERT(0);
559                                 return;
560                         }
561
562                         if (Count > (epd->size - epd->offset))
563                         {
564                                 epd->status = BUFFER_OVERRUN;
565                                 epd->size = ep_cnfg[EP].offset;
566                                 break;
567                         }
568                         else if (Count < ep_cnfg[EP].max_size)
569                         {
570                                 epd->status = BUFFER_UNDERRUN;
571                                 epd->size = ep_cnfg[EP].offset + Count;
572                         }
573                         else
574                                 epd->status = BEGIN_SERVICED;
575
576                         Offset = epd->offset;
577                         epd->offset += Count;
578
579                         /* Read data from packet memory buffer */
580                         while (Count)
581                         {
582                                 Data = *pSrc++;
583                                 *(epd->read_buffer + Offset++) = Data;
584                                 if (--Count)
585                                 {
586                                         Data >>= 8;
587                                         *(epd->read_buffer + Offset++) = Data;
588                                         --Count;
589                                 }
590                         }
591
592                         EpCtrlSet_STAT_RX(epd->hw, EP_VALID);
593
594                         --ep_cnfg[EP].avail_data;
595
596                         if (*epd->hw & (1UL << 11))
597                         {
598                                 ep_cnfg[EP].status = SETUP_OVERWRITE;
599                                 return;
600                         }
601                         if (!(Count = (epd->size - epd->offset)))
602                         {
603                                 epd->status = COMPLETE;
604                                 break;
605                         }
606                 }
607                 if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
608                 {
609                         /* call callback function */
610                         if (epd->complete)
611                                 epd->complete(EP);
612                 }
613         }
614 }
615
616 /*
617  * Return the lower value from Host expected size and size and set a flag
618  * STM32_USB_EP_ZERO_POSSIBLE when size is lower that host expected size.
619  */
620 static size_t usb_size(size_t size, size_t host_size)
621 {
622         if (size < host_size)
623         {
624                 ep_cnfg[CTRL_ENP_IN].flags |= STM32_USB_EP_ZERO_POSSIBLE;
625                 return size;
626         }
627         return host_size;
628 }
629
630 /* Configure an EP descriptor before performing a I/O operation */
631 #define USB_EP_IO(__EP, __op, __buf, __size, __complete)                \
632 ({                                                                      \
633         cpu_flags_t flags;                                              \
634         stm32_usb_io_status_t ret;                                      \
635                                                                         \
636         /* Fill EP descriptor */                                        \
637         IRQ_SAVE_DISABLE(flags);                                        \
638         if (__size < 0)                                                 \
639         {                                                               \
640                 ep_cnfg[__EP].status = NOT_READY;                       \
641                 ep_cnfg[__EP].complete = NULL;                          \
642                 ret = NOT_READY;                                        \
643                 goto out;                                               \
644         }                                                               \
645         if (ep_cnfg[__EP].status == BEGIN_SERVICED)                     \
646         {                                                               \
647                 ret = NOT_READY;                                        \
648                 goto out;                                               \
649         }                                                               \
650         /*                                                              \
651          * NOTE: the write_buffer and read_buffer are actually the      \
652          * same location in memory (it's a union).                      \
653          *                                                              \
654          * We have to do this trick to silent a build warning by        \
655          * casting the I/O buffer to (void *) or (const void *).        \
656          */                                                             \
657         ep_cnfg[__EP].__op ## _buffer = __buf;                          \
658         ep_cnfg[__EP].offset = 0;                                       \
659         ep_cnfg[__EP].size = __size;                                    \
660         ep_cnfg[__EP].complete = __complete;                            \
661         if (!size)                                                      \
662                 ep_cnfg[__EP].flags = STM32_USB_EP_ZERO_PACKET;         \
663         else                                                            \
664                 ep_cnfg[__EP].flags = 0;                                \
665         ep_cnfg[__EP].status = NO_SERVICED;                             \
666                                                                         \
667         /* Perform the I/O operation */                                 \
668         __usb_ep_io(__EP);                                              \
669                                                                         \
670         ret = ep_cnfg[__EP].status;                                     \
671 out:                                                                    \
672         IRQ_RESTORE(flags);                                             \
673         ret;                                                            \
674 })
675
676 /* Configure and endponint and perform a read operation */
677 static stm32_usb_io_status_t
678 __usb_ep_read(int ep, void *buffer, ssize_t size, void (*complete)(int))
679 {
680         if (UNLIKELY(ep >= ENP_MAX_NUMB))
681         {
682                 ASSERT(0);
683                 return STALLED;
684         }
685         ASSERT(!(ep & 0x01));
686         return USB_EP_IO(ep, read, buffer, size, complete);
687 }
688
689 /* Configure and endponint and perform a write operation */
690 static stm32_usb_io_status_t
691 __usb_ep_write(int ep, const void *buffer, ssize_t size, void (*complete)(int))
692 {
693         if (UNLIKELY(ep >= ENP_MAX_NUMB))
694         {
695                 ASSERT(0);
696                 return STALLED;
697         }
698         ASSERT(ep & 0x01);
699         return USB_EP_IO(ep, write, buffer, size, complete);
700 }
701
702 static void usb_ep_low_level_config(int ep, uint16_t offset, uint16_t size)
703 {
704         stm32_usb_ep_t *epc = &ep_cnfg[ep];
705
706         /* IN EP */
707         if (ep & 0x01)
708         {
709                 /* Disable EP */
710                 EpCtrlSet_STAT_TX(epc->hw, EP_DISABLED);
711                 /* Clear Tx toggle */
712                 EpCtrlSet_DTOG_TX(epc->hw, 0);
713                 /* Clear Correct Transfer for transmission flag */
714                 EpCtrlClr_CTR_TX(epc->hw);
715
716                 /* Update EP description table */
717                 WriteEpDTB_AddrTx(ep >> 1, offset);
718                 WriteEpDTB_CountTx(ep >> 1, 0);
719         }
720         /* OUT EP */
721         else
722         {
723                 uint16_t rx_count = 0;
724
725                 /* Disable EP */
726                 EpCtrlSet_STAT_RX(epc->hw, EP_DISABLED);
727                 /* Clear Rx toggle */
728                 EpCtrlSet_DTOG_RX(epc->hw, 0);
729                 /* Clear Correct Transfer for reception flag */
730                 EpCtrlClr_CTR_RX(epc->hw);
731                 /* Descriptor block size field */
732                 rx_count |= (size > 62) << 15;
733                 /* Descriptor number of blocks field */
734                 rx_count |= (((size > 62) ?  (size >> 5) - 1 : size >> 1) &
735                                 0x1f) << 10;
736                 /* Update EP description table */
737                 WriteEpDTB_AddrRx(ep >> 1, offset);
738                 WriteEpDTB_CountRx(ep >> 1, rx_count);
739         }
740 }
741
742 /* Enable/Disable an endpoint */
743 static int usb_ep_configure(const usb_endpoint_descriptor_t *epd, bool enable)
744 {
745         int EP;
746         stm32_usb_ep_t *ep_hw;
747         reg32_t *hw;
748         uint16_t Offset;
749         uint32_t MaxPacketSizeTmp;
750
751         EP = USB_EpLogToPhysAdd(epd->bEndpointAddress);
752         ep_hw = &ep_cnfg[EP];
753
754         if (enable)
755         {
756                 /*
757                  * Allocate packet memory for EP buffer/s calculate actual size
758                  * only for the OUT EPs.
759                  */
760                 MaxPacketSizeTmp = epd->wMaxPacketSize;
761                 if (!USB_AllocateBuffer(&Offset, &MaxPacketSizeTmp, EP))
762                         return -USB_MEMORY_FULL;
763
764                 /* Set EP status */
765                 ep_hw->status  = NOT_READY;
766                 /* Init EP flags */
767                 ep_hw->flags = 0;
768
769                 /* Set endpoint type */
770                 ep_hw->type = usb_endpoint_type(epd);
771                 /* Init EP max packet size */
772                 ep_hw->max_size = epd->wMaxPacketSize;
773
774                 if (EP & 0x01)
775                         ep_hw->avail_data = 1;
776                 else
777                         ep_hw->avail_data = 0;
778                 hw = (reg32_t *)&usb->EP0R;
779                 hw += EP >> 1;
780
781                 /* Set Ep Address */
782                 EpCtrlSet_EA(hw, EP >> 1);
783                 ep_hw->hw = hw;
784                 LOG_INFO("%s: EP%d-%s configured\n",
785                                 __func__, EP >> 1, EP & 1 ? "IN" : "OUT");
786
787                 /* Low-level endpoint configuration */
788                 usb_ep_low_level_config(EP, Offset, MaxPacketSizeTmp);
789
790                 /* Set EP Kind & enable */
791                 switch (ep_hw->type)
792                 {
793                 case USB_ENDPOINT_XFER_CONTROL:
794                         LOG_INFO("EP%d: CONTROL IN\n", EP >> 1);
795                         EpCtrlSet_EP_TYPE(hw, EP_CTRL);
796                         EpCtrlSet_EP_KIND(hw, 0);
797                         break;
798                 case USB_ENDPOINT_XFER_INT:
799                         LOG_INFO("EP%d: INTERRUPT IN\n", EP >> 1);
800                         EpCtrlSet_EP_TYPE(hw, EP_INTERRUPT);
801                         EpCtrlSet_EP_KIND(hw, 0);
802                         break;
803                 case USB_ENDPOINT_XFER_BULK:
804                         LOG_INFO("EP%d: BULK IN\n", EP >> 1);
805                         EpCtrlSet_EP_TYPE(hw, EP_BULK);
806                         EpCtrlSet_EP_KIND(hw, 0);
807                         break;
808                 case USB_ENDPOINT_XFER_ISOC:
809                         LOG_ERR("EP%d: ISOCHRONOUS IN: not supported\n", EP >> 1);
810                         /* Fallback to default */
811                 default:
812                         ASSERT(0);
813                         return -USB_NODEV_ERROR;
814                 }
815                 if (EP & 0x01)
816                 {
817                         /* Enable EP */
818                         EpCtrlSet_STAT_TX(hw, EP_NAK);
819                         /* Clear Correct Transfer for transmission flag */
820                         EpCtrlClr_CTR_TX(hw);
821                 }
822                 else
823                 {
824                         /* Enable EP */
825                         EpCtrlSet_STAT_RX(hw, EP_VALID);
826                 }
827         }
828         else if (ep_cnfg[EP].hw)
829         {
830                 hw = (reg32_t *)&usb->EP0R;
831                 hw += EP >> 1;
832
833                 /* IN EP */
834                 if (EP & 0x01)
835                 {
836                         /* Disable IN EP */
837                         EpCtrlSet_STAT_TX(hw, EP_DISABLED);
838                         /* Clear Correct Transfer for reception flag */
839                         EpCtrlClr_CTR_TX(hw);
840                 }
841                 /* OUT EP */
842                 else
843                 {
844                         /* Disable OUT EP */
845                         EpCtrlSet_STAT_RX(hw, EP_DISABLED);
846                         /* Clear Correct Transfer for reception flag */
847                         EpCtrlClr_CTR_RX(hw);
848                 }
849                 /* Release buffer */
850                 USB_ReleaseBuffer(EP);
851                 ep_cnfg[EP].hw = NULL;
852         }
853         return 0;
854 }
855
856 /* Get EP stall/unstall */
857 static int USB_GetStallEP(int EP, bool *pStall)
858 {
859         if (ep_cnfg[EP].hw == NULL)
860                 return -USB_NODEV_ERROR;
861
862         *pStall = (EP & 0x01) ?
863                 (EpCtrlGet_STAT_TX(ep_cnfg[EP].hw) == EP_STALL):  /* IN EP  */
864                 (EpCtrlGet_STAT_RX(ep_cnfg[EP].hw) == EP_STALL);  /* OUT EP */
865
866         return USB_OK;
867 }
868
869 /* Set EP stall/unstall */
870 static int USB_SetStallEP(int EP, bool Stall)
871 {
872         if (ep_cnfg[EP].hw == NULL)
873                 return -USB_NODEV_ERROR;
874
875         if (Stall)
876         {
877                 ep_cnfg[EP].status = STALLED;
878                 if (EP & 0x01)
879                 {
880                         /* IN EP */
881                         EpCtrlSet_STAT_TX(ep_cnfg[EP].hw, EP_STALL);
882                         ep_cnfg[EP].avail_data = 1;
883                 }
884                 else
885                 {
886                         /* OUT EP */
887                         EpCtrlSet_STAT_RX(ep_cnfg[EP].hw, EP_STALL);
888                         ep_cnfg[EP].avail_data = 0;
889                 }
890         }
891         else
892         {
893                 ep_cnfg[EP].status = NOT_READY;
894                 if(EP & 0x01)
895                 {
896                         /* IN EP */
897                         ep_cnfg[EP].avail_data = 1;
898                         /* reset Data Toggle bit */
899                         EpCtrlSet_DTOG_TX(ep_cnfg[EP].hw, 0);
900                         EpCtrlSet_STAT_TX(ep_cnfg[EP].hw, EP_NAK);
901                 }
902                 else
903                 {
904                         /* OUT EP */
905                         ep_cnfg[EP].avail_data = 0;
906                         /* reset Data Toggle bit */
907                         EpCtrlSet_DTOG_RX(ep_cnfg[EP].hw, 0);
908                         EpCtrlSet_STAT_RX(ep_cnfg[EP].hw, EP_VALID);
909                 }
910         }
911         return USB_OK;
912 }
913
914 /* Stall both directions of the control EP */
915 static void USB_StallCtrlEP(void)
916 {
917         ep_cnfg[CTRL_ENP_IN].avail_data = 1;
918         ep_cnfg[CTRL_ENP_IN].status = STALLED;
919         ep_cnfg[CTRL_ENP_OUT].avail_data = 0;
920         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
921
922         USB_SetStallEP(CTRL_ENP_IN, true);
923         USB_SetStallEP(CTRL_ENP_OUT, true);
924 }
925
926 /*
927  * Find the position of an interface descriptor inside the configuration
928  * descriptor.
929  */
930 static int usb_find_interface(uint32_t num, uint32_t alt)
931 {
932         const usb_interface_descriptor_t *id;
933         int i;
934
935         for (i = 0; ; i++)
936         {
937                 /* TODO: support more than one configuration per device */
938                 id = (const usb_interface_descriptor_t *)usb_dev->config[i];
939                 if (id == NULL)
940                         break;
941                 if (id->bDescriptorType != USB_DT_INTERFACE)
942                         continue;
943                 if ((id->bInterfaceNumber == num) &&
944                                 (id->bAlternateSetting == alt))
945                         return i;
946         }
947         return -USB_NODEV_ERROR;
948 }
949
950 /*
951  * Configure/deconfigure EPs of a certain interface.
952  */
953 static void
954 usb_configure_ep_interface(unsigned int num, unsigned int alt, bool enable)
955 {
956         const usb_endpoint_descriptor_t *epd;
957         int i, start;
958
959         /*
960          * Find the position of the interface descriptor (inside the
961          * configuration descriptor).
962          */
963         start = usb_find_interface(num, alt);
964         if (start < 0)
965         {
966                 LOG_ERR("%s: interface (%u,%u) not found\n",
967                         __func__, num, alt);
968                 return;
969         }
970         /*
971          * Cycle over endpoint descriptors.
972          *
973          * NOTE: the first endpoint descriptor is placed next to the interface
974          * descriptor, so we need to add +1 to the position of the interface
975          * descriptor to find it.
976          */
977         for (i = start + 1; ; i++)
978         {
979                 epd = (const usb_endpoint_descriptor_t *)usb_dev->config[i];
980                 if ((epd == NULL) || (epd->bDescriptorType == USB_DT_INTERFACE))
981                         break;
982                 if (epd->bDescriptorType != USB_DT_ENDPOINT)
983                         continue;
984                 if (UNLIKELY(usb_ep_configure(epd, enable) < 0))
985                 {
986                         LOG_ERR("%s: out of memory, can't initialize EP\n",
987                                 __func__);
988                         return;
989                 }
990         }
991 }
992
993 /* Set device state */
994 static void usb_set_device_state(int state)
995 {
996         unsigned int i;
997
998         LOG_INFO("%s: new state %d\n", __func__, state);
999
1000         if (udc.state == USB_STATE_CONFIGURED)
1001         {
1002                 /* Deconfigure device */
1003                 for (i = 0; i < udc.interfaces; ++i)
1004                         usb_configure_ep_interface(i,
1005                                 udc.alt[i], false);
1006         }
1007         switch (state)
1008         {
1009         case USB_STATE_ATTACHED:
1010         case USB_STATE_POWERED:
1011         case USB_STATE_DEFAULT:
1012                 usb_set_address(0);
1013                 usb_dev->configured = false;
1014                 udc.address = udc.cfg_id = 0;
1015                 break;
1016         case USB_STATE_ADDRESS:
1017                 udc.cfg_id = 0;
1018                 break;
1019         case USB_STATE_CONFIGURED:
1020                 /* Configure device */
1021                 for (i = 0; i < udc.interfaces; ++i)
1022                         usb_configure_ep_interface(i,
1023                                 udc.alt[i], true);
1024                 break;
1025         default:
1026                 /* Unknown state: disconnected or connection in progress */
1027                 usb_dev->configured = false;
1028                 udc.address = 0;
1029                 udc.cfg_id = 0;
1030                 break;
1031         }
1032         udc.state = state;
1033 }
1034
1035 /* Setup packet: set address status phase end handler */
1036 static void USB_AddStatusEndHandler(UNUSED_ARG(int, EP))
1037 {
1038         uint16_t w_value;
1039
1040         w_value = usb_le16_to_cpu(setup_packet.wValue);
1041         udc.address = w_value & 0xff;
1042         usb_set_address(udc.address);
1043
1044         if (udc.address)
1045                 usb_set_device_state(USB_STATE_ADDRESS);
1046         else
1047                 usb_set_device_state(USB_STATE_DEFAULT);
1048
1049         __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1050         __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1051 }
1052
1053 /* Prepare status phase */
1054 static void USB_StatusPhase(bool in)
1055 {
1056         if (in)
1057                 __usb_ep_write(CTRL_ENP_IN, NULL, 0, NULL);
1058 }
1059
1060 /* Setup packet: status phase end handler */
1061 static void USB_StatusEndHandler(UNUSED_ARG(int, EP))
1062 {
1063         __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1064         __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1065 }
1066
1067 /* Address status handler */
1068 static void USB_StatusHandler(UNUSED_ARG(int, EP))
1069 {
1070         if (setup_packet.mRequestType & USB_DIR_IN)
1071         {
1072                 USB_StatusPhase(false);
1073                 ep_cnfg[CTRL_ENP_OUT].complete = USB_StatusEndHandler;
1074         }
1075         else
1076         {
1077                 USB_StatusPhase(true);
1078                 ep_cnfg[CTRL_ENP_IN].complete =
1079                         (setup_packet.bRequest == USB_REQ_SET_ADDRESS) ?
1080                                 USB_AddStatusEndHandler :
1081                                 USB_StatusEndHandler;
1082         }
1083 }
1084
1085 static bool rx_done;
1086 static size_t rx_size;
1087
1088 static void usb_ep_read_complete(int ep)
1089 {
1090         if (UNLIKELY(ep >= ENP_MAX_NUMB))
1091         {
1092                 ASSERT(0);
1093                 return;
1094         }
1095         ASSERT(!(ep & 0x01));
1096
1097         rx_done = true;
1098         rx_size = ep_cnfg[ep].size;
1099 }
1100
1101 ssize_t usb_ep_read(int ep, void *buffer, ssize_t size)
1102 {
1103         int ep_num = USB_EpLogToPhysAdd(ep);
1104
1105         /* Non-blocking read for EP0 */
1106         if (ep_num == CTRL_ENP_OUT)
1107         {
1108                 size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
1109                 if (!size)
1110                         USB_StatusHandler(ep_num);
1111                 else
1112                         __usb_ep_read(ep_num, buffer, size,
1113                                         USB_StatusHandler);
1114                 return size;
1115         }
1116         if (UNLIKELY(!size))
1117                 return 0;
1118         size = MIN(size, USB_RX_MAX_SIZE);
1119         rx_done = false;
1120         rx_size = 0;
1121
1122         /* Blocking read */
1123         __usb_ep_read(ep_num, buffer, size, usb_ep_read_complete);
1124         while (!rx_done)
1125                 cpu_relax();
1126
1127         return rx_size;
1128 }
1129
1130 static bool tx_done;
1131 static size_t tx_size;
1132
1133 static void usb_ep_write_complete(int ep)
1134 {
1135         if (UNLIKELY(ep >= ENP_MAX_NUMB))
1136         {
1137                 ASSERT(0);
1138                 return;
1139         }
1140         ASSERT(ep & 0x01);
1141
1142         tx_done = true;
1143         tx_size = ep_cnfg[ep].size;
1144 }
1145
1146 ssize_t usb_ep_write(int ep, const void *buffer, ssize_t size)
1147 {
1148         int ep_num = USB_EpLogToPhysAdd(ep);
1149
1150         /* Non-blocking write for EP0 */
1151         if (ep_num == CTRL_ENP_IN)
1152         {
1153                 size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
1154                 if (!size)
1155                         USB_StatusHandler(ep_num);
1156                 else
1157                         __usb_ep_write(ep_num, buffer, size,
1158                                         USB_StatusHandler);
1159                 return size;
1160         }
1161         if (UNLIKELY(!size))
1162                 return 0;
1163         size = MIN(size, USB_TX_MAX_SIZE);
1164         tx_done = false;
1165         tx_size = 0;
1166
1167         /* Blocking write */
1168         __usb_ep_write(ep_num, buffer, size, usb_ep_write_complete);
1169         while (!tx_done)
1170                 cpu_relax();
1171
1172         return tx_size;
1173 }
1174
1175 /* Global variable to handle the following non-blocking I/O operations */
1176 static uint32_t InData;
1177
1178 /* Get device status */
1179 static int UsbDevStatus(uint16_t index)
1180 {
1181         if (index)
1182                 return -USB_NODEV_ERROR;
1183
1184         InData = ((uint32_t)udc.feature) & 0xff;
1185         __usb_ep_write(CTRL_ENP_IN,
1186                         (uint8_t *)&InData, sizeof(uint16_t),
1187                         USB_StatusHandler);
1188         return 0;
1189 }
1190
1191 /* Get interface status */
1192 static int UsbInterfaceStatus(UNUSED_ARG(uint16_t, index))
1193 {
1194         InData = 0;
1195         __usb_ep_write(CTRL_ENP_IN,
1196                         (uint8_t *)&InData, sizeof(uint16_t),
1197                         USB_StatusHandler);
1198         return 0;
1199 }
1200
1201 /* Get endpoint status */
1202 static int UsbEpStatus(uint16_t index)
1203 {
1204         if ((index & 0x7F) > 16)
1205                 return -USB_NODEV_ERROR;
1206
1207         InData = 0;
1208         USB_GetStallEP(USB_EpLogToPhysAdd(index), (bool *)&InData);
1209         __usb_ep_write(CTRL_ENP_IN,
1210                         (uint8_t *)&InData, sizeof(uint16_t),
1211                         USB_StatusHandler);
1212         return 0;
1213 }
1214
1215 /* USB setup packet: GET_STATUS request handler */
1216 static void USB_GetStatusHandler(void)
1217 {
1218         uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1219         uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1220         uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1221
1222         /* GET_STATUS sanity checks */
1223         if (udc.state < USB_STATE_ADDRESS)
1224         {
1225                 LOG_WARN("%s: bad GET_STATUS request (State=%02x)\n",
1226                                 __func__, udc.state);
1227                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1228                 return;
1229         }
1230         if (w_length != 2)
1231         {
1232                 LOG_WARN("%s: bad GET_STATUS request (wLength.Word=%02x)\n",
1233                                 __func__, w_length);
1234                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1235                 return;
1236         }
1237         if (!(setup_packet.mRequestType & USB_DIR_IN))
1238         {
1239                 LOG_WARN("%s: bad GET_STATUS request (mRequestType=%02x)\n",
1240                                 __func__, setup_packet.mRequestType);
1241                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1242                 return;
1243         }
1244         if (w_value)
1245         {
1246                 LOG_WARN("%s: bad GET_STATUS request (wValue=%02x)\n",
1247                                 __func__, w_value);
1248                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1249                 return;
1250         }
1251
1252         /* Process GET_STATUS request */
1253         switch (setup_packet.mRequestType & USB_RECIP_MASK)
1254         {
1255         case USB_RECIP_DEVICE:
1256                 if (UsbDevStatus(w_index) < 0)
1257                 {
1258                         LOG_WARN("%s: GET_STATUS: invalid UsbRecipientDevice\n",
1259                                         __func__);
1260                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1261                         return;
1262                 }
1263                 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientDevice)\n",
1264                                 __func__, setup_packet.mRequestType);
1265                 break;
1266         case USB_RECIP_INTERFACE:
1267                 if (UsbInterfaceStatus(w_index) < 0)
1268                 {
1269                         LOG_WARN("%s: GET_STATUS: invalid UsbRecipientInterface\n",
1270                                         __func__);
1271                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1272                         return;
1273                 }
1274                 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientInterface)\n",
1275                                 __func__, setup_packet.mRequestType);
1276                 break;
1277         case USB_RECIP_ENDPOINT:
1278                 if (UsbEpStatus(w_index) < 0)
1279                 {
1280                         LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1281                                         __func__);
1282                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1283                         return;
1284                 }
1285                 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientEndpoint)\n",
1286                                 __func__, setup_packet.mRequestType);
1287                 break;
1288         default:
1289                 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1290                                 __func__);
1291                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1292                 break;
1293         }
1294 }
1295
1296 static int usb_get_device_descriptor(int id)
1297 {
1298         if (id)
1299                 return -USB_NODEV_ERROR;
1300
1301         usb_dev->device->bMaxPacketSize0 = USB_EP0_MAX_SIZE;
1302         __usb_ep_write(CTRL_ENP_IN, (const uint8_t *)usb_dev->device,
1303                         usb_size(usb_dev->device->bLength,
1304                                 usb_le16_to_cpu(setup_packet.wLength)),
1305                         USB_StatusHandler);
1306         return 0;
1307 }
1308
1309 #define USB_BUFSIZE (128)
1310 static uint8_t usb_cfg_buffer[USB_BUFSIZE];
1311
1312 static int usb_get_configuration_descriptor(int id)
1313 {
1314         const usb_config_descriptor_t **config =
1315                         (const usb_config_descriptor_t **)usb_dev->config;
1316         uint8_t *p = usb_cfg_buffer;
1317         int i;
1318
1319         /* TODO: support more than one configuration per device */
1320         if (UNLIKELY(id > 0))
1321                 return -USB_NODEV_ERROR;
1322
1323         for (i = 0; config[i]; i++)
1324         {
1325                 memcpy(p, config[i], config[i]->bLength);
1326                 p += config[i]->bLength;
1327
1328                 if (UNLIKELY((p - usb_cfg_buffer) > USB_BUFSIZE))
1329                 {
1330                         ASSERT(0);
1331                         return -USB_BUF_OVERFLOW;
1332                 }
1333         }
1334         ((usb_config_descriptor_t *)usb_cfg_buffer)->wTotalLength =
1335                                         usb_cpu_to_le16(p - usb_cfg_buffer);
1336         __usb_ep_write(CTRL_ENP_IN,
1337                         usb_cfg_buffer,
1338                         usb_size(p - usb_cfg_buffer,
1339                                 usb_le16_to_cpu(setup_packet.wLength)),
1340                         USB_StatusHandler);
1341         return 0;
1342 }
1343
1344 static int usb_get_string_descriptor(unsigned int id)
1345 {
1346         const usb_string_descriptor_t *lang_str;
1347         unsigned int lang_id, str_id;
1348         uint16_t w_index_lo = usb_le16_to_cpu(setup_packet.wIndex) & 0x00ff;
1349         uint16_t w_index_hi = (usb_le16_to_cpu(setup_packet.wIndex) &
1350                                                 0xff00) >> 8;
1351
1352         ASSERT(usb_dev->strings != NULL);
1353         ASSERT(usb_dev->strings[0] != NULL);
1354
1355         lang_str = usb_dev->strings[0];
1356         if (id)
1357         {
1358                 /* Find Language index */
1359                 for (lang_id = 0; ; lang_id++)
1360                 {
1361                         const usb_string_descriptor_t *str =
1362                                                 usb_dev->strings[lang_id];
1363                         if (UNLIKELY(str == NULL))
1364                                 return -USB_NODEV_ERROR;
1365                         if ((str->data[0] == w_index_lo) &&
1366                                         (str->data[1] == w_index_hi))
1367                                 break;
1368                 }
1369                 /* Check buffer overflow to find string index */
1370                 for (str_id = 0; str_id < id; str_id++)
1371                 {
1372                         lang_str = usb_dev->strings[lang_id + 1 + str_id];
1373                         if (lang_str == NULL)
1374                                 return -USB_NODEV_ERROR;
1375                 }
1376         }
1377         __usb_ep_write(CTRL_ENP_IN,
1378                         lang_str,
1379                         usb_size(lang_str->bLength,
1380                                 usb_le16_to_cpu(setup_packet.wLength)),
1381                         USB_StatusHandler);
1382         return 0;
1383 }
1384
1385 static void UsbGetDescriptor(void)
1386 {
1387         uint16_t w_value_lo = usb_le16_to_cpu(setup_packet.wValue) & 0x00ff;
1388         uint16_t w_value_hi = (usb_le16_to_cpu(setup_packet.wValue) & 0xff00) >> 8;
1389
1390         if (udc.state < USB_STATE_DEFAULT)
1391         {
1392                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1393                 return;
1394         }
1395         switch (w_value_hi)
1396         {
1397         case USB_DT_DEVICE:
1398                 LOG_INFO("%s: GET_DEVICE_DESCRIPTOR: id=%d, state=%d\n",
1399                                 __func__,
1400                                 w_value_lo,
1401                                 udc.state);
1402                 if (usb_get_device_descriptor(w_value_lo) < 0)
1403                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1404                 break;
1405         case USB_DT_CONFIG:
1406                 LOG_INFO("%s: GET_CONFIG_DESCRIPTOR: id=%d, state=%d\n",
1407                                 __func__, w_value_lo, udc.state);
1408                 if (usb_get_configuration_descriptor(w_value_lo) < 0)
1409                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1410                 break;
1411         case USB_DT_STRING:
1412                 LOG_INFO("%s: GET_STRING_DESCRIPTOR: id=%d, state=%d\n",
1413                                 __func__, w_value_lo, udc.state);
1414                 if (usb_get_string_descriptor(w_value_lo) < 0)
1415                         ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1416                 break;
1417         default:
1418                 LOG_WARN("%s: GET_UNKNOWN_DESCRIPTOR: id=%d, state=%d\n",
1419                                 __func__, w_value_lo, udc.state);
1420                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1421                 break;
1422         }
1423 }
1424
1425 /* USB setup packet: class/vendor request handler */
1426 static void usb_event_handler(struct usb_device *dev)
1427 {
1428         /*
1429          * TODO: get the appropriate usb_dev in function of the endpoint
1430          * address.
1431          */
1432         if (dev->event_cb)
1433                 dev->event_cb(&setup_packet);
1434 }
1435
1436 /* USB setup packet: GET_DESCRIPTOR handler */
1437 static void UBS_GetDescriptorHandler(void)
1438 {
1439         LOG_INFO("%s: GET_DESCRIPTOR: RECIP = %d\n",
1440                         __func__,
1441                         setup_packet.mRequestType & USB_RECIP_MASK);
1442         if ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1443                         USB_RECIP_DEVICE)
1444                 UsbGetDescriptor();
1445         /* Getting descriptor for a device is a standard request */
1446         else if ((setup_packet.mRequestType & USB_DIR_MASK) == USB_DIR_IN)
1447                 usb_event_handler(usb_dev);
1448         else
1449                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1450 }
1451
1452 /* USB setup packet: SET_ADDRESS handler */
1453 static void USB_SetAddressHandler(void)
1454 {
1455         uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1456         uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1457         uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1458
1459         LOG_INFO("%s: SET_ADDRESS: %d\n",
1460                         __func__, usb_le16_to_cpu(setup_packet.wValue));
1461         if ((udc.state >= USB_STATE_DEFAULT) &&
1462                         ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1463                                         USB_RECIP_DEVICE) &&
1464                         (w_index == 0) && (w_length == 0) && (w_value < 128))
1465                 USB_StatusHandler(CTRL_ENP_IN);
1466         else
1467                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1468 }
1469
1470 /* USB setup packet: GET_CONFIGURATION handler */
1471 static void USB_GetConfigurationHandler(void)
1472 {
1473         uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1474         uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1475
1476         LOG_INFO("%s: GET_CONFIGURATION\n", __func__);
1477         if ((udc.state >= USB_STATE_ADDRESS) &&
1478                         (w_value == 0) && (w_index == 0) && (w_value == 1))
1479         {
1480                 InData = udc.cfg_id;
1481                 __usb_ep_write(CTRL_ENP_IN, (uint8_t *)&InData, 1, USB_StatusHandler);
1482         }
1483         else
1484                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1485 }
1486
1487 static const usb_config_descriptor_t *usb_find_configuration(int num)
1488 {
1489         const usb_config_descriptor_t *cfg;
1490         int i;
1491
1492         for (i = 0; ; i++)
1493         {
1494                 cfg = (const usb_config_descriptor_t *)usb_dev->config[i];
1495                 if (cfg == NULL)
1496                         break;
1497                 if (cfg->bDescriptorType != USB_DT_CONFIG)
1498                         continue;
1499                 if (cfg->bConfigurationValue == num)
1500                         return cfg;
1501         }
1502         return NULL;
1503 }
1504
1505 static int UsbSetConfigurationState(uint32_t Configuration)
1506 {
1507         const usb_config_descriptor_t *pCnfg;
1508         unsigned int i;
1509
1510         if (Configuration)
1511         {
1512                 /* Find configuration descriptor */
1513                 pCnfg = usb_find_configuration(Configuration);
1514                 if (pCnfg == NULL)
1515                         return -USB_NODEV_ERROR;
1516
1517                 /* Reset current configuration */
1518                 usb_set_device_state(USB_STATE_ADDRESS);
1519                 usb_dev->configured = false;
1520                 udc.cfg = pCnfg;
1521
1522                 /* Set Interface and Alternative Setting */
1523                 udc.cfg_id = Configuration;
1524                 /* Set self-powered state */
1525                 if (pCnfg->bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1526                         udc.feature |= STM32_UDC_FEATURE_SELFPOWERED;
1527
1528                 /* Configure all existing interfaces to alternative setting 0 */
1529                 ASSERT(pCnfg->bNumInterfaces <= USB_MAX_INTERFACE);
1530                 udc.interfaces = pCnfg->bNumInterfaces;
1531                 for (i = 0; i < udc.interfaces; i++)
1532                         udc.alt[i] = 0;
1533                 usb_set_device_state(USB_STATE_CONFIGURED);
1534                 usb_dev->configured = true;
1535         }
1536         else
1537         {
1538                 usb_dev->configured = false;
1539                 usb_set_device_state(USB_STATE_ADDRESS);
1540         }
1541         return 0;
1542 }
1543
1544 /* USB setup packet: SET_CONFIGURATION handler */
1545 static void USB_SetConfigurationHandler(void)
1546 {
1547         uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1548         uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1549         uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1550
1551         LOG_INFO("%s: SET_CONFIGURATION: %d\n",
1552                         __func__, w_value);
1553         if ((udc.state >= USB_STATE_ADDRESS) &&
1554                         (w_index == 0) && (w_length == 0) &&
1555                         (UsbSetConfigurationState(w_value & 0xff) == 0))
1556                 USB_StatusHandler(CTRL_ENP_OUT);
1557         else
1558                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1559 }
1560
1561 /* USB setup packet: standard request handler */
1562 static void USB_StandardRequestHandler(void)
1563 {
1564         switch (setup_packet.bRequest)
1565         {
1566         case USB_REQ_GET_STATUS:
1567                 USB_GetStatusHandler();
1568                 break;
1569         case USB_REQ_CLEAR_FEATURE:
1570                 LOG_INFO("%s: bRequest=%d (CLEAR_FEATURE)\n",
1571                                 __func__, setup_packet.bRequest);
1572                 break;
1573         case USB_REQ_SET_FEATURE:
1574                 LOG_INFO("%s: bRequest=%d (SET_FEATURE)\n",
1575                                 __func__, setup_packet.bRequest);
1576                 break;
1577         case USB_REQ_SET_ADDRESS:
1578                 USB_SetAddressHandler();
1579                 break;
1580         case USB_REQ_GET_DESCRIPTOR:
1581                 UBS_GetDescriptorHandler();
1582                 break;
1583         case USB_REQ_SET_DESCRIPTOR:
1584                 LOG_INFO("%s: bRequest=%d (SET_DESCRIPTOR)\n",
1585                                 __func__, setup_packet.bRequest);
1586                 break;
1587         case USB_REQ_GET_CONFIGURATION:
1588                 USB_GetConfigurationHandler();
1589                 break;
1590         case USB_REQ_SET_CONFIGURATION:
1591                 USB_SetConfigurationHandler();
1592                 break;
1593         case USB_REQ_GET_INTERFACE:
1594                 LOG_INFO("%s: bRequest=%d (GET_INTERFACE)\n",
1595                                 __func__, setup_packet.bRequest);
1596                 break;
1597         case USB_REQ_SET_INTERFACE:
1598                 LOG_INFO("%s: bRequest=%d (SET_INTERFACE)\n",
1599                                 __func__, setup_packet.bRequest);
1600                 break;
1601         case USB_REQ_SYNCH_FRAME:
1602                 LOG_INFO("%s: bRequest=%d (SYNCH_FRAME)\n",
1603                                 __func__, setup_packet.bRequest);
1604                 break;
1605         default:
1606                 LOG_WARN("%s: bRequest=%d (Unknown)\n",
1607                                 __func__, setup_packet.bRequest);
1608                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1609                 break;
1610         }
1611 }
1612
1613 /* USB setup packet handler */
1614 static void USB_SetupHandler(void)
1615 {
1616         switch (setup_packet.mRequestType & USB_TYPE_MASK)
1617         {
1618         /* Standard */
1619         case USB_TYPE_STANDARD:
1620                 LOG_INFO("%s: bmRequestType=%02x (Standard)\n",
1621                                 __func__, setup_packet.mRequestType);
1622                 USB_StandardRequestHandler();
1623                 break;
1624         /* Class */
1625         case USB_TYPE_CLASS:
1626                 LOG_INFO("%s: bmRequestType=%02x (Class)\n",
1627                                 __func__, setup_packet.mRequestType);
1628                 usb_event_handler(usb_dev);
1629                 break;
1630         /* Vendor */
1631         case USB_TYPE_VENDOR:
1632                 LOG_INFO("%s: bmRequestType=%02x (Vendor)\n",
1633                                 __func__, setup_packet.mRequestType);
1634                 usb_event_handler(usb_dev);
1635                 break;
1636         case USB_TYPE_RESERVED:
1637                 LOG_INFO("%s: bmRequestType=%02x (Reserved)\n",
1638                                 __func__, setup_packet.mRequestType);
1639                 break;
1640         /* Other */
1641         default:
1642                 LOG_WARN("%s: bmRequestType=%02x (Unknown)\n",
1643                                 __func__, setup_packet.mRequestType);
1644                 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1645                 break;
1646         }
1647 }
1648
1649 /* USB: low-level hardware initialization */
1650 static void usb_hw_reset(void)
1651 {
1652         unsigned int i;
1653         int ret;
1654
1655         /* Initialize endpoint descriptors */
1656         for (i = 0; i < countof(ep_cnfg); i++)
1657                 ep_cnfg[i].hw = NULL;
1658
1659         /* Initialize USB memory */
1660         for (i = 0; i < countof(PacketMemBuff); i++)
1661                 PacketMemBuff[i].Size = 0;
1662         usb->BTABLE = USB_BDT_OFFSET;
1663         pPacketMemUse = NULL;
1664
1665         /* Endpoint initialization */
1666         ret = usb_ep_configure(&USB_CtrlEpDescr0, true);
1667         if (UNLIKELY(ret < 0))
1668         {
1669                 LOG_WARN("%s: out of memory, cannot initialize EP0\n",
1670                                 __func__);
1671                 return;
1672         }
1673         ret = usb_ep_configure(&USB_CtrlEpDescr1, true);
1674         if (UNLIKELY(ret < 0))
1675         {
1676                 LOG_WARN("%s: out of memory, cannot initialize EP1\n",
1677                                 __func__);
1678                 return;
1679         }
1680
1681         /* Set default address */
1682         usb_set_address(0);
1683
1684         /* Enable all the device interrupts */
1685         usb->CNTR = bmCTRM | bmRESETM | bmSOFM | bmERRM | bmPMAOVRM |
1686                         bmSUSPM | bmWKUPM;
1687 }
1688
1689 /* Handle a correct transfer under ISR */
1690 static void usb_isr_correct_transfer(stm32_usb_irq_status_t interrupt)
1691 {
1692         int EP;
1693         reg32_t *pReg = (reg32_t *)&usb->EP0R;
1694
1695         /* Find corresponding EP */
1696         pReg += interrupt.EP_ID;
1697         EP = (int)(((*pReg & 0x0f) << 1) + (interrupt.DIR ? 0 : 1));
1698         ep_cnfg[EP].avail_data = 1;
1699
1700         ASSERT(ep_cnfg[EP].hw);
1701         /* IN EP */
1702         if (EP & 0x01)
1703                 EpCtrlClr_CTR_TX(ep_cnfg[EP].hw);
1704         else
1705                 EpCtrlClr_CTR_RX(ep_cnfg[EP].hw);
1706         if (EP == CTRL_ENP_OUT)
1707         {
1708                 /* Determinate type of packet (only for control EP) */
1709                 bool SetupPacket = EpCtrlGet_SETUP(ep_cnfg[CTRL_ENP_OUT].hw);
1710
1711                 if (SetupPacket)
1712                 {
1713                         ep_cnfg[CTRL_ENP_IN].avail_data = 1;
1714                         /* init IO to receive Setup packet */
1715                         __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1716                         __usb_ep_read(CTRL_ENP_OUT, &setup_packet,
1717                                         sizeof(setup_packet), NULL);
1718
1719                         /* reset EP IO ctrl */
1720                         if (setup_packet.mRequestType & USB_DIR_IN)
1721                                 USB_StatusHandler(CTRL_ENP_OUT);
1722                         USB_SetupHandler();
1723                         if (ep_cnfg[CTRL_ENP_OUT].status == STALLED)
1724                                 USB_StallCtrlEP();
1725                 }
1726                 else
1727                 {
1728                         if (ep_cnfg[CTRL_ENP_OUT].complete &&
1729                                         setup_packet.mRequestType & USB_DIR_IN)
1730                                 ep_cnfg[CTRL_ENP_OUT].complete(CTRL_ENP_OUT);
1731                         else
1732                                 __usb_ep_io(EP);
1733                 }
1734         }
1735         else if (EP == CTRL_ENP_IN)
1736         {
1737                 if (ep_cnfg[CTRL_ENP_IN].complete &&
1738                                 !(setup_packet.mRequestType & USB_DIR_IN))
1739                         ep_cnfg[CTRL_ENP_IN].complete(CTRL_ENP_IN);
1740                 else
1741                         __usb_ep_io(EP);
1742
1743         }
1744         else
1745                 __usb_ep_io(EP);
1746 }
1747
1748 /* USB: interrupt service routine */
1749 static void usb_isr(void)
1750 {
1751         stm32_usb_irq_status_t interrupt;
1752
1753         /* Get masked interrupt flags */
1754         interrupt.status = usb->ISTR;
1755         interrupt.status &= usb->CNTR | 0x1f;
1756
1757         if (interrupt.PMAOVR)
1758         {
1759                 LOG_WARN("%s: DMA overrun / underrun\n", __func__);
1760                 usb->ISTR = ~bmPMAOVRM;
1761         }
1762         if (interrupt.ERR)
1763         {
1764                 LOG_WARN("%s: engine error\n", __func__);
1765                 usb->ISTR = ~bmERRM;
1766         }
1767         if (interrupt.RESET)
1768         {
1769                 LOG_INFO("%s: device reset\n", __func__);
1770                 usb->ISTR = ~bmRESETM;
1771                 usb_hw_reset();
1772                 usb_set_device_state(USB_STATE_DEFAULT);
1773         }
1774         if (interrupt.SOF)
1775         {
1776 #if 0
1777                 /*
1778                  * XXX: disable logging of frame interrupts (too much noise!)
1779                  */
1780                 uint16_t frame_nr = usb->FNR & 0x0fff;
1781                 LOG_INFO("%s: frame %#x\n", __func__, frame_nr);
1782 #endif
1783                 usb->ISTR = ~bmSOFM;
1784         }
1785         if (interrupt.WKUP)
1786         {
1787                 LOG_INFO("%s: wake-up\n", __func__);
1788                 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1789                 usb_resume();
1790         }
1791         if (interrupt.SUSP)
1792         {
1793                 LOG_INFO("%s: suspend\n", __func__);
1794                 usb_suspend();
1795                 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1796         }
1797         if (interrupt.ESOF)
1798         {
1799                 LOG_INFO("%s: expected frame\n", __func__);
1800                 usb->ISTR = ~bmESOFM;
1801         }
1802         if (interrupt.CTR)
1803         {
1804                 usb_isr_correct_transfer(interrupt);
1805         }
1806 }
1807
1808 /* USB: hardware initialization */
1809 static void usb_hw_init(void)
1810 {
1811         /* Enable clocking on the required GPIO pins */
1812         RCC->APB2ENR |= RCC_APB2_GPIOA | RCC_APB2_GPIOC;
1813
1814         /* Make sure that the CAN controller is disabled and held in reset */
1815         RCC->APB1ENR &= ~RCC_APB1_CAN;
1816
1817         /* Configure USB_DM and USB_DP to work as USB lines */
1818         stm32_gpioPinConfig((struct stm32_gpio *)GPIOA_BASE,
1819                         USB_DM_PIN | USB_DP_PIN,
1820                         GPIO_MODE_AF_PP, GPIO_SPEED_50MHZ);
1821         /* Configure USB_DISC to work as USB disconnect */
1822         stm32_gpioPinConfig((struct stm32_gpio *)GPIOC_BASE,
1823                         USB_DISC_PIN,
1824                         GPIO_MODE_OUT_PP, GPIO_SPEED_50MHZ);
1825         stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE,
1826                                 USB_DISC_PIN, 1);
1827
1828         /* Ensure the USB clock is disabled before setting the prescaler */
1829         RCC->APB1ENR &= ~RCC_APB1_USB;
1830
1831         /* Configure USB clock (48MHz) */
1832         *CFGR_USBPRE_BB &= ~RCC_USBCLK_PLLCLK_1DIV5;
1833
1834         /* Activate USB clock */
1835         RCC->APB1ENR |= RCC_APB1_USB;
1836
1837         /* Force USB reset and disable USB interrupts */
1838         usb->CNTR = bmFRES;
1839         timer_delayHp(1);
1840
1841         /* Issue a USB reset */
1842         usb_hw_reset();
1843
1844         /* Clear spurious pending interrupt */
1845         usb->ISTR = 0;
1846
1847         /* Register interrupt handler */
1848         sysirq_setHandler(USB_LP_CAN_RX0_IRQHANDLER, usb_isr);
1849
1850         /* Software connection enable */
1851         usb_connect();
1852 }
1853
1854 /* Initialize the USB controller */
1855 static void usb_init(void)
1856 {
1857         udc.state = USB_STATE_NOTATTACHED;
1858         udc.feature = 0;
1859
1860         usb_hw_init();
1861 }
1862
1863 /* Register an upper layer USB device into the driver */
1864 int usb_device_register(struct usb_device *dev)
1865 {
1866 #if CONFIG_KERN
1867         MOD_CHECK(proc);
1868 #endif
1869         usb_dev = dev;
1870         usb_init();
1871         while (!usb_dev->configured)
1872                 cpu_relax();
1873         return 0;
1874 }