4 * This file is part of BeRTOS.
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.
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.
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
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.
29 * Copyright 2010 Develer S.r.l. (http://www.develer.com/)
33 * \brief STM32 USB driver
35 * \author Andrea Righi <arighi@develer.com>
38 #include "cfg/cfg_usb.h"
40 #define LOG_LEVEL USB_LOG_LEVEL
41 #define LOG_FORMAT USB_LOG_FORMAT
44 #include <cfg/debug.h>
45 #include <cfg/macros.h>
46 #include <cfg/module.h>
49 #include <cpu/power.h>
51 #include <drv/irq_cm3.h>
52 #include <drv/gpio_stm32.h>
53 #include <drv/clock_stm32.h>
54 #include <drv/timer.h>
57 #include <string.h> /* memcpy() */
59 #include "usb_stm32.h"
61 #define ALIGN_UP(value, align) (((value) & ((align) - 1)) ? \
62 (((value) + ((align) - 1)) & ~((align) - 1)) : \
64 /* STM32 USB registers */
75 reg32_t __reserved[8];
83 /* Hardware registers */
84 static struct stm32_usb *usb = (struct stm32_usb *)USB_BASE_ADDR;
86 /* Endpoint descriptors: used for handling requests to use with endpoints */
87 static stm32_usb_ep_t ep_cnfg[ENP_MAX_NUMB];
89 /* USB EP0 control descriptor */
90 static const usb_endpoint_descriptor_t USB_CtrlEpDescr0 =
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,
100 /* USB EP1 control descriptor */
101 static const usb_endpoint_descriptor_t USB_CtrlEpDescr1 =
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,
111 /* USB setup packet */
112 static usb_ctrlrequest_t setup_packet;
114 /* USB device controller: max supported interfaces */
115 #define USB_MAX_INTERFACE 1
117 /* USB device controller features */
118 #define STM32_UDC_FEATURE_SELFPOWERED BV(0)
119 #define STM32_UDC_FEATURE_REMOTE_WAKEUP BV(1)
121 /* Hardware-specific USB device controller structure */
122 typedef struct stm32_udc
126 const usb_config_descriptor_t *cfg;
128 uint32_t alt[USB_MAX_INTERFACE];
131 } PACKED stm32_udc_t;
133 /* Hardware-specific USB Device Controller */
134 static stm32_udc_t udc;
136 /* Generic USB Device Controller structure */
137 static struct usb_device *usb_dev;
139 /* USB packet memory management: list of allocated chunks */
140 static pack_mem_slot_t *pPacketMemUse;
142 /* USB packet memory management: memory buffer metadata */
143 #define EP_MAX_SLOTS 16
144 static pack_mem_slot_t PacketMemBuff[EP_MAX_SLOTS];
146 /* Allocate a free block of the packet memory */
147 static pack_mem_slot_t *usb_malloc(void)
151 for (i = 0; i < countof(PacketMemBuff); i++)
152 if (PacketMemBuff[i].Size == 0)
153 return &PacketMemBuff[i];
157 /* Release a block of the packet memory */
158 static void usb_free(pack_mem_slot_t *pPntr)
163 /* Allocate a free chunk of the packet memory (inside a block) */
164 static bool USB_AllocateBuffer(uint16_t *pOffset, uint32_t *pPacketSize,
167 pack_mem_slot_t *pPacketMem = pPacketMemUse,
168 *pPacketMemNext, *pPacketMemUseNew;
169 uint32_t MaxPacketSize = *pPacketSize;
172 * Packet size alignment:
173 * - fine-granularity allocation: size alignment by 2;
174 * - coarse-granularity allocation: size alignment by 32.
176 if (MaxPacketSize < 62)
177 MaxPacketSize = ALIGN_UP(MaxPacketSize, 2);
179 MaxPacketSize = ALIGN_UP(MaxPacketSize, 32);
181 * Finding free memory chunks from the allocated blocks of the USB
185 while (pPacketMem != NULL)
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))
194 pPacketMem = pPacketMem->next;
196 /* Check for out-of-memory condition */
197 if ((*pOffset + MaxPacketSize) >= USB_BDT_OFFSET)
200 * Allocate a new memory block, next to the last allocated block.
202 pPacketMemUseNew = usb_malloc();
203 if (pPacketMemUseNew == NULL)
205 /* Insert the block to the list of allocated blocks */
206 if (pPacketMemUse == NULL)
208 pPacketMemUse = pPacketMemUseNew;
209 pPacketMemUse->next = NULL;
213 pPacketMemUseNew->next = pPacketMem->next;
214 pPacketMem->next = pPacketMemUseNew;
216 /* Update block's metadata */
217 pPacketMemUseNew->ep_addr = EndPoint;
218 pPacketMemUseNew->Start = *pOffset;
219 pPacketMemUseNew->Size = MaxPacketSize;
221 *pPacketSize = MaxPacketSize;
226 /* Release a chunk of the packet memory (inside a block) */
227 static void USB_ReleaseBuffer(int EndPoint)
229 pack_mem_slot_t *pPacketMem, *pPacketMemPrev = NULL;
230 pPacketMem = pPacketMemUse;
232 while (pPacketMem != NULL)
234 if (pPacketMem->ep_addr == EndPoint)
236 if (UNLIKELY(pPacketMemPrev == NULL))
238 /* Free the first element of the list */
239 pPacketMemUse = pPacketMemUse->next;
240 usb_free(pPacketMem);
241 pPacketMem = pPacketMemUse;
244 pPacketMemPrev->next = pPacketMem->next;
245 usb_free(pPacketMem);
248 pPacketMemPrev = pPacketMem;
249 pPacketMem = pPacketMemPrev->next;
253 /*-------------------------------------------------------------------------*/
255 /* Connect USB controller */
256 static void usb_connect(void)
258 stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE, 1 << 11, 0);
261 /* Set USB device address */
262 static void usb_set_address(uint32_t addr)
264 usb->DADDR = addr | 0x80;
267 /* Suspend USB controller */
268 static void usb_suspend(void)
270 usb->CNTR |= bmFSUSP | bmLPMODE;
273 /* Resume USB controller */
274 static void usb_resume(void)
276 uint32_t line_status;
278 line_status = usb->FNR & 0xc000;
281 /* check for noise and eventually return to sleep */
282 if (line_status == 0xc000)
285 usb->CNTR &= ~(bmFSUSP | bmLPMODE);
288 /* Convert logical EP address to physical EP address */
289 static int USB_EpLogToPhysAdd(uint8_t ep_addr)
291 int addr = (ep_addr & 0x0f) << 1;
292 return (ep_addr & 0x80) ? addr + 1 : addr;
296 static void EpCtrlSet_EA(reg32_t *reg, uint32_t val)
299 val |= *reg & 0x0700;
300 val |= USB_CTRL_CLEAR_ONLY_MASK;
304 /* Get EP IN status */
305 static uint32_t EpCtrlGet_STAT_TX(reg32_t *reg)
307 return (*reg & (0x3UL << 4)) >> 4;
310 /* Set EP IN state */
311 static void EpCtrlSet_STAT_TX(reg32_t *reg, ep_state_t val)
317 * The EP can change state between read and write operations from VALID
318 * to NAK and result of set operation will be invalid.
320 for (i = 0; i < 2; i++)
322 if (EpCtrlGet_STAT_TX(reg) == val)
327 state |= USB_CTRL_CLEAR_ONLY_MASK;
328 /* Clear the toggle bits without STAT_TX (4,5) */
334 /* Set EP DTOG_TX bit (IN) */
335 static void EpCtrlSet_DTOG_TX(reg32_t *reg, uint32_t val)
337 val = val ? (*reg ^ (1UL << 6)) : *reg;
338 /* Clear the toggle bits without DTOG_TX (6) */
340 val |= USB_CTRL_CLEAR_ONLY_MASK;
344 /* Clear EP CTR_TX bit (IN) */
345 static void EpCtrlClr_CTR_TX(reg32_t *reg)
349 val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 7);
355 /* Clear EP CTR_RX bit (OUT) */
356 static void EpCtrlClr_CTR_RX(reg32_t *reg)
359 val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 15);
365 /* Set EP KIND bit */
366 static void EpCtrlSet_EP_KIND(reg32_t *reg, uint32_t val)
368 val = val ? (1UL << 8) : 0;
369 val |= *reg & ~(USB_CTRL_TOGGLE_MASK | (1UL << 8));
370 val |= USB_CTRL_CLEAR_ONLY_MASK;
375 static int EpCtrlSet_EP_TYPE(reg32_t *reg, uint8_t val)
379 if (UNLIKELY(val >= EP_TYPE_MAX))
382 return USB_INVAL_ERROR;
386 type |= *reg & ~(USB_CTRL_TOGGLE_MASK | (0x3UL << 9));
387 type |= USB_CTRL_CLEAR_ONLY_MASK;
393 /* Get EP STAT_RX (OUT) */
394 static uint32_t EpCtrlGet_STAT_RX(reg32_t *reg)
396 uint32_t val = *reg & (0x3UL << 12);
400 /* Set EP STAT_RX (OUT) */
401 static void EpCtrlSet_STAT_RX(reg32_t *reg, ep_state_t val)
407 * The EP can change state between read and write operations from VALID
408 * to NAK and result of set operation will be invalid.
410 for (i = 0; i < 2; i++)
412 if (EpCtrlGet_STAT_RX(reg) == val)
417 state |= USB_CTRL_CLEAR_ONLY_MASK;
418 /* Clear the toggle bits without STAT_RX (12,13) */
424 /* Set DTOG_RX bit */
425 static void EpCtrlSet_DTOG_RX(reg32_t *reg, uint32_t val)
427 val = val ? (*reg ^ (1UL << 14)) : *reg;
428 /* Clear the toggle bits without DTOG_RX (14) */
430 val |= USB_CTRL_CLEAR_ONLY_MASK;
434 /* Get EP SETUP bit */
435 static uint32_t EpCtrlGet_SETUP(reg32_t *reg)
437 uint32_t val = *reg & (1UL << 11);
441 /* Core endpoint I/O function */
442 static void __usb_ep_io(int EP)
444 ssize_t Count, CountHold, Offset;
445 uint32_t *pDst, *pSrc, Data;
447 stm32_usb_ep_t *epd = &ep_cnfg[EP];
449 if (UNLIKELY(epd->hw == NULL))
451 LOG_ERR("%s: invalid endpoint (EP%d-%s)\n",
454 (EP & 0x01) ? "IN" : "OUT");
458 if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
464 Count = epd->size - epd->offset;
465 while (epd->avail_data)
467 if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
471 epd->status = BEGIN_SERVICED;
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;
478 CountHold = Count = MIN(Count, epd->max_size);
480 epd->flags |= STM32_USB_EP_ZERO_PACKET;
481 Offset = epd->offset;
482 epd->offset += Count;
483 CurrentBuffer = true;
486 case USB_ENDPOINT_XFER_CONTROL:
487 case USB_ENDPOINT_XFER_INT:
488 pDst = (uint32_t *)addr2usbmem(ReadEpDTB_AddrTx(EP >> 1));
490 case USB_ENDPOINT_XFER_BULK:
491 pDst = (uint32_t *)addr2usbmem(ReadEpDTB_AddrTx(EP >> 1));
493 case USB_ENDPOINT_XFER_ISOC:
494 LOG_ERR("%s: isochronous transfer not supported\n",
496 /* Fallback to default */
502 /* Write data to packet memory buffer */
505 Data = *(epd->write_buffer + Offset++);
508 Data |= (uint32_t)(*(epd->write_buffer + Offset++)) << 8;
515 WriteEpDTB_CountTx(EP >> 1, CountHold);
517 WriteEpDTB_CountRx(EP >> 1, CountHold);
519 EpCtrlSet_STAT_TX(epd->hw, EP_VALID);
521 --ep_cnfg[EP].avail_data;
522 Count = epd->size - epd->offset;
524 if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
526 epd->status = COMPLETE;
527 /* call callback function */
535 while (epd->avail_data)
537 /* Get data size and buffer pointer */
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));
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));
553 case USB_ENDPOINT_XFER_ISOC:
554 LOG_ERR("%s: isochronous transfer not supported\n",
556 /* Fallback to default */
562 if (Count > (epd->size - epd->offset))
564 epd->status = BUFFER_OVERRUN;
565 epd->size = ep_cnfg[EP].offset;
568 else if (Count < ep_cnfg[EP].max_size)
570 epd->status = BUFFER_UNDERRUN;
571 epd->size = ep_cnfg[EP].offset + Count;
574 epd->status = BEGIN_SERVICED;
576 Offset = epd->offset;
577 epd->offset += Count;
579 /* Read data from packet memory buffer */
583 *(epd->read_buffer + Offset++) = Data;
587 *(epd->read_buffer + Offset++) = Data;
592 EpCtrlSet_STAT_RX(epd->hw, EP_VALID);
594 --ep_cnfg[EP].avail_data;
596 if (*epd->hw & (1UL << 11))
598 ep_cnfg[EP].status = SETUP_OVERWRITE;
601 if (!(Count = (epd->size - epd->offset)))
603 epd->status = COMPLETE;
607 if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
609 /* call callback function */
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.
620 static size_t usb_size(size_t size, size_t host_size)
622 if (size < host_size)
624 ep_cnfg[CTRL_ENP_IN].flags |= STM32_USB_EP_ZERO_POSSIBLE;
630 /* Configure an EP descriptor before performing a I/O operation */
631 #define USB_EP_IO(__EP, __op, __buf, __size, __complete) \
634 stm32_usb_io_status_t ret; \
636 /* Fill EP descriptor */ \
637 IRQ_SAVE_DISABLE(flags); \
640 ep_cnfg[__EP].status = NOT_READY; \
641 ep_cnfg[__EP].complete = NULL; \
645 if (ep_cnfg[__EP].status == BEGIN_SERVICED) \
651 * NOTE: the write_buffer and read_buffer are actually the \
652 * same location in memory (it's a union). \
654 * We have to do this trick to silent a build warning by \
655 * casting the I/O buffer to (void *) or (const void *). \
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; \
662 ep_cnfg[__EP].flags = STM32_USB_EP_ZERO_PACKET; \
664 ep_cnfg[__EP].flags = 0; \
665 ep_cnfg[__EP].status = NO_SERVICED; \
667 /* Perform the I/O operation */ \
670 ret = ep_cnfg[__EP].status; \
672 IRQ_RESTORE(flags); \
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))
680 if (UNLIKELY(ep >= ENP_MAX_NUMB))
685 ASSERT(!(ep & 0x01));
686 return USB_EP_IO(ep, read, buffer, size, complete);
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))
693 if (UNLIKELY(ep >= ENP_MAX_NUMB))
699 return USB_EP_IO(ep, write, buffer, size, complete);
702 static void usb_ep_low_level_config(int ep, uint16_t offset, uint16_t size)
704 stm32_usb_ep_t *epc = &ep_cnfg[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);
716 /* Update EP description table */
717 WriteEpDTB_AddrTx(ep >> 1, offset);
718 WriteEpDTB_CountTx(ep >> 1, 0);
723 uint16_t rx_count = 0;
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) &
736 /* Update EP description table */
737 WriteEpDTB_AddrRx(ep >> 1, offset);
738 WriteEpDTB_CountRx(ep >> 1, rx_count);
742 /* Enable/Disable an endpoint */
743 static int usb_ep_configure(const usb_endpoint_descriptor_t *epd, bool enable)
746 stm32_usb_ep_t *ep_hw;
749 uint32_t MaxPacketSizeTmp;
751 EP = USB_EpLogToPhysAdd(epd->bEndpointAddress);
752 ep_hw = &ep_cnfg[EP];
757 * Allocate packet memory for EP buffer/s calculate actual size
758 * only for the OUT EPs.
760 MaxPacketSizeTmp = epd->wMaxPacketSize;
761 if (!USB_AllocateBuffer(&Offset, &MaxPacketSizeTmp, EP))
762 return -USB_MEMORY_FULL;
765 ep_hw->status = NOT_READY;
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;
775 ep_hw->avail_data = 1;
777 ep_hw->avail_data = 0;
778 hw = (reg32_t *)&usb->EP0R;
782 EpCtrlSet_EA(hw, EP >> 1);
785 /* Low-level endpoint configuration */
786 usb_ep_low_level_config(EP, Offset, MaxPacketSizeTmp);
788 /* Set EP Kind & enable */
791 case USB_ENDPOINT_XFER_CONTROL:
792 LOG_INFO("EP%d: CONTROL IN\n", EP >> 1);
793 EpCtrlSet_EP_TYPE(hw, EP_CTRL);
794 EpCtrlSet_EP_KIND(hw, 0);
796 case USB_ENDPOINT_XFER_INT:
797 LOG_INFO("EP%d: INTERRUPT IN\n", EP >> 1);
798 EpCtrlSet_EP_TYPE(hw, EP_INTERRUPT);
799 EpCtrlSet_EP_KIND(hw, 0);
801 case USB_ENDPOINT_XFER_BULK:
802 LOG_INFO("EP%d: BULK IN\n", EP >> 1);
803 EpCtrlSet_EP_TYPE(hw, EP_BULK);
804 EpCtrlSet_EP_KIND(hw, 0);
806 case USB_ENDPOINT_XFER_ISOC:
807 LOG_ERR("EP%d: ISOCHRONOUS IN: not supported\n", EP >> 1);
808 /* Fallback to default */
811 return -USB_NODEV_ERROR;
816 EpCtrlSet_STAT_TX(hw, EP_NAK);
817 /* Clear Correct Transfer for transmission flag */
818 EpCtrlClr_CTR_TX(hw);
823 EpCtrlSet_STAT_RX(hw, EP_VALID);
826 else if (ep_cnfg[EP].hw)
828 hw = (reg32_t *)&usb->EP0R;
835 EpCtrlSet_STAT_TX(hw, EP_DISABLED);
836 /* Clear Correct Transfer for reception flag */
837 EpCtrlClr_CTR_TX(hw);
843 EpCtrlSet_STAT_RX(hw, EP_DISABLED);
844 /* Clear Correct Transfer for reception flag */
845 EpCtrlClr_CTR_RX(hw);
848 USB_ReleaseBuffer(EP);
849 ep_cnfg[EP].hw = NULL;
854 /* Get EP stall/unstall */
855 static int USB_GetStallEP(int EP, bool *pStall)
857 if (ep_cnfg[EP].hw == NULL)
858 return -USB_NODEV_ERROR;
860 *pStall = (EP & 0x01) ?
861 (EpCtrlGet_STAT_TX(ep_cnfg[EP].hw) == EP_STALL): /* IN EP */
862 (EpCtrlGet_STAT_RX(ep_cnfg[EP].hw) == EP_STALL); /* OUT EP */
867 /* Set EP stall/unstall */
868 static int USB_SetStallEP(int EP, bool Stall)
870 if (ep_cnfg[EP].hw == NULL)
871 return -USB_NODEV_ERROR;
875 ep_cnfg[EP].status = STALLED;
879 EpCtrlSet_STAT_TX(ep_cnfg[EP].hw, EP_STALL);
880 ep_cnfg[EP].avail_data = 1;
885 EpCtrlSet_STAT_RX(ep_cnfg[EP].hw, EP_STALL);
886 ep_cnfg[EP].avail_data = 0;
891 ep_cnfg[EP].status = NOT_READY;
895 ep_cnfg[EP].avail_data = 1;
896 /* reset Data Toggle bit */
897 EpCtrlSet_DTOG_TX(ep_cnfg[EP].hw, 0);
898 EpCtrlSet_STAT_TX(ep_cnfg[EP].hw, EP_NAK);
903 ep_cnfg[EP].avail_data = 0;
904 /* reset Data Toggle bit */
905 EpCtrlSet_DTOG_RX(ep_cnfg[EP].hw, 0);
906 EpCtrlSet_STAT_RX(ep_cnfg[EP].hw, EP_VALID);
912 /* Stall both directions of the control EP */
913 static void USB_StallCtrlEP(void)
915 ep_cnfg[CTRL_ENP_IN].avail_data = 1;
916 ep_cnfg[CTRL_ENP_IN].status = STALLED;
917 ep_cnfg[CTRL_ENP_OUT].avail_data = 0;
918 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
920 USB_SetStallEP(CTRL_ENP_IN, true);
921 USB_SetStallEP(CTRL_ENP_OUT, true);
925 * Find the position of an interface descriptor inside the configuration
928 static int usb_find_interface(uint32_t num, uint32_t alt)
930 usb_interface_descriptor_t *id;
935 /* TODO: support more than one configuration per device */
936 id = (usb_interface_descriptor_t *)usb_dev->config[i];
939 if (id->bDescriptorType != USB_DT_INTERFACE)
941 if ((id->bInterfaceNumber == num) &&
942 (id->bAlternateSetting == alt))
945 return -USB_NODEV_ERROR;
949 * Configure/deconfigure EPs of a certain interface.
952 usb_configure_ep_interface(unsigned int num, unsigned int alt, bool enable)
954 usb_endpoint_descriptor_t *epd;
958 * Find the position of the interface descriptor (inside the
959 * configuration descriptor).
961 start = usb_find_interface(num, alt);
964 LOG_ERR("%s: interface (%u,%u) not found\n",
969 * Cycle over endpoint descriptors.
971 * NOTE: the first endpoint descriptor is placed next to the interface
972 * descriptor, so we need to add +1 to the position of the interface
973 * descriptor to find it.
975 for (i = start + 1; ; i++)
977 epd = (usb_endpoint_descriptor_t *)usb_dev->config[i];
978 if ((epd == NULL) || (epd->bDescriptorType != USB_DT_ENDPOINT))
980 if (UNLIKELY(usb_ep_configure(epd, enable) < 0))
982 LOG_ERR("%s: out of memory, can't initialize EP\n",
989 /* Set device state */
990 static void usb_set_device_state(int state)
994 LOG_INFO("%s: new state %d\n", __func__, state);
996 if (udc.state == USB_STATE_CONFIGURED)
998 /* Deconfigure device */
999 for (i = 0; i < udc.interfaces; ++i)
1000 usb_configure_ep_interface(i,
1005 case USB_STATE_ATTACHED:
1006 case USB_STATE_POWERED:
1007 case USB_STATE_DEFAULT:
1009 usb_dev->configured = false;
1010 udc.address = udc.cfg_id = 0;
1012 case USB_STATE_ADDRESS:
1015 case USB_STATE_CONFIGURED:
1016 /* Configure device */
1017 for (i = 0; i < udc.interfaces; ++i)
1018 usb_configure_ep_interface(i,
1022 /* Unknown state: disconnected or connection in progress */
1023 usb_dev->configured = false;
1031 /* Setup packet: set address status phase end handler */
1032 static void USB_AddStatusEndHandler(UNUSED_ARG(int, EP))
1036 w_value = usb_le16_to_cpu(setup_packet.wValue);
1037 udc.address = w_value & 0xff;
1038 usb_set_address(udc.address);
1041 usb_set_device_state(USB_STATE_ADDRESS);
1043 usb_set_device_state(USB_STATE_DEFAULT);
1045 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1046 __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1049 /* Prepare status phase */
1050 static void USB_StatusPhase(bool in)
1053 __usb_ep_write(CTRL_ENP_IN, NULL, 0, NULL);
1056 /* Setup packet: status phase end handler */
1057 static void USB_StatusEndHandler(UNUSED_ARG(int, EP))
1059 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1060 __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1063 /* Address status handler */
1064 static void USB_StatusHandler(UNUSED_ARG(int, EP))
1066 if (setup_packet.mRequestType & USB_DIR_IN)
1068 USB_StatusPhase(false);
1069 ep_cnfg[CTRL_ENP_OUT].complete = USB_StatusEndHandler;
1073 USB_StatusPhase(true);
1074 ep_cnfg[CTRL_ENP_IN].complete =
1075 (setup_packet.bRequest == USB_REQ_SET_ADDRESS) ?
1076 USB_AddStatusEndHandler :
1077 USB_StatusEndHandler;
1081 static bool rx_done;
1082 static size_t rx_size;
1084 static void usb_ep_read_complete(int ep)
1086 if (UNLIKELY(ep >= ENP_MAX_NUMB))
1091 ASSERT(!(ep & 0x01));
1094 rx_size = ep_cnfg[ep].size;
1097 ssize_t usb_ep_read(int ep, void *buffer, ssize_t size)
1099 int ep_num = USB_EpLogToPhysAdd(ep);
1101 if (UNLIKELY(!size))
1103 size = MIN(size, USB_RX_MAX_SIZE);
1107 /* Non-blocking read for EP0 */
1108 if (ep_num == CTRL_ENP_OUT)
1110 size = usb_size(size, setup_packet.wLength);
1111 __usb_ep_write(ep_num, buffer, size,
1116 __usb_ep_read(ep_num, buffer, size, usb_ep_read_complete);
1123 static bool tx_done;
1124 static size_t tx_size;
1126 static void usb_ep_write_complete(int ep)
1128 if (UNLIKELY(ep >= ENP_MAX_NUMB))
1136 tx_size = ep_cnfg[ep].size;
1139 ssize_t usb_ep_write(int ep, const void *buffer, ssize_t size)
1141 int ep_num = USB_EpLogToPhysAdd(ep);
1143 if (UNLIKELY(!size))
1145 size = MIN(size, USB_TX_MAX_SIZE);
1149 /* Non-blocking write for EP0 */
1150 if (ep_num == CTRL_ENP_IN)
1152 size = usb_size(size, setup_packet.wLength);
1153 __usb_ep_write(ep_num, buffer, size,
1157 /* Blocking write */
1158 __usb_ep_write(ep_num, buffer, size, usb_ep_write_complete);
1165 /* Global variable to handle the following non-blocking I/O operations */
1166 static uint32_t InData;
1168 /* Get device status */
1169 static int UsbDevStatus(uint16_t index)
1172 return -USB_NODEV_ERROR;
1174 InData = ((uint32_t)udc.feature) & 0xff;
1175 __usb_ep_write(CTRL_ENP_IN,
1176 (uint8_t *)&InData, sizeof(InData), USB_StatusHandler);
1181 /* Get interface status */
1182 static int UsbInterfaceStatus(UNUSED_ARG(uint16_t, index))
1185 __usb_ep_write(CTRL_ENP_IN,
1186 (uint8_t *)&InData, sizeof(InData), USB_StatusHandler);
1191 /* Get endpoint status */
1192 static int UsbEpStatus(uint16_t index)
1194 if ((index & 0x7F) > 16)
1195 return -USB_NODEV_ERROR;
1198 USB_GetStallEP(USB_EpLogToPhysAdd(index), (bool *)&InData);
1199 __usb_ep_write(CTRL_ENP_IN,
1200 (uint8_t *)&InData, sizeof(InData), USB_StatusHandler);
1205 /* USB setup packet: GET_STATUS request handler */
1206 static void USB_GetStatusHandler(void)
1208 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1209 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1210 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1212 /* GET_STATUS sanity checks */
1213 if (udc.state < USB_STATE_ADDRESS)
1215 LOG_WARN("%s: bad GET_STATUS request (State=%02x)\n",
1216 __func__, udc.state);
1217 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1222 LOG_WARN("%s: bad GET_STATUS request (wLength.Word=%02x)\n",
1223 __func__, w_length);
1224 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1227 if (!(setup_packet.mRequestType & USB_DIR_IN))
1229 LOG_WARN("%s: bad GET_STATUS request (mRequestType=%02x)\n",
1230 __func__, setup_packet.mRequestType);
1231 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1236 LOG_WARN("%s: bad GET_STATUS request (wValue=%02x)\n",
1238 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1242 /* Process GET_STATUS request */
1243 switch (setup_packet.mRequestType & USB_RECIP_MASK)
1245 case USB_RECIP_DEVICE:
1246 if (UsbDevStatus(w_index) < 0)
1248 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientDevice\n",
1250 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1253 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientDevice)\n",
1254 __func__, setup_packet.mRequestType);
1256 case USB_RECIP_INTERFACE:
1257 if (UsbInterfaceStatus(w_index) < 0)
1259 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientInterface\n",
1261 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1264 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientInterface)\n",
1265 __func__, setup_packet.mRequestType);
1267 case USB_RECIP_ENDPOINT:
1268 if (UsbEpStatus(w_index) < 0)
1270 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1272 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1275 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientEndpoint)\n",
1276 __func__, setup_packet.mRequestType);
1279 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1281 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1286 static int usb_get_device_descriptor(int id)
1289 return -USB_NODEV_ERROR;
1291 usb_dev->device->bMaxPacketSize0 = USB_EP0_MAX_SIZE;
1292 __usb_ep_write(CTRL_ENP_IN, (const uint8_t *)usb_dev->device,
1293 usb_size(usb_dev->device->bLength,
1294 setup_packet.wLength),
1299 #define USB_BUFSIZE (128)
1300 static uint8_t usb_cfg_buffer[USB_BUFSIZE];
1302 static int usb_get_configuration_descriptor(int id)
1304 const usb_config_descriptor_t **config =
1305 (const usb_config_descriptor_t **)usb_dev->config;
1306 uint8_t *p = usb_cfg_buffer;
1309 /* TODO: support more than one configuration per device */
1310 if (UNLIKELY(id > 0))
1311 return -USB_NODEV_ERROR;
1313 for (i = 0; config[i]; i++)
1315 memcpy(p, config[i], config[i]->bLength);
1316 p += config[i]->bLength;
1318 if (UNLIKELY((p - usb_cfg_buffer) > USB_BUFSIZE))
1321 return -USB_BUF_OVERFLOW;
1324 ((usb_config_descriptor_t *)usb_cfg_buffer)->wTotalLength =
1325 usb_cpu_to_le16(p - usb_cfg_buffer);
1326 __usb_ep_write(CTRL_ENP_IN,
1328 usb_size(p - usb_cfg_buffer,
1329 setup_packet.wLength),
1334 static int usb_get_string_descriptor(unsigned int id)
1336 usb_string_descriptor_t *lang_str;
1337 unsigned int lang_id, str_id;
1338 uint16_t w_index_lo = usb_le16_to_cpu(setup_packet.wIndex) & 0x00ff;
1339 uint16_t w_index_hi = (usb_le16_to_cpu(setup_packet.wIndex) & 0xff00) >> 8;
1341 ASSERT(usb_dev->strings != NULL);
1342 ASSERT(usb_dev->strings[0] != NULL);
1344 lang_str = usb_dev->strings[0];
1347 /* Find Language index */
1348 for (lang_id = 0; ; lang_id++)
1350 usb_string_descriptor_t *str = usb_dev->strings[lang_id];
1352 if (UNLIKELY(str == NULL))
1353 return -USB_NODEV_ERROR;
1354 if ((str->data[0] == w_index_lo) &&
1355 (str->data[1] == w_index_hi))
1358 /* Check buffer overflow to find string index */
1359 for (str_id = 0; str_id < id; str_id++)
1361 lang_str = usb_dev->strings[lang_id + 1 + str_id];
1362 if (lang_str == NULL)
1363 return -USB_NODEV_ERROR;
1366 __usb_ep_write(CTRL_ENP_IN,
1368 usb_size(lang_str->bLength, setup_packet.wLength),
1373 static void UsbGetDescriptor(void)
1375 uint16_t w_value_lo = usb_le16_to_cpu(setup_packet.wValue) & 0x00ff;
1376 uint16_t w_value_hi = (usb_le16_to_cpu(setup_packet.wValue) & 0xff00) >> 8;
1378 if (udc.state < USB_STATE_DEFAULT)
1380 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1386 LOG_INFO("%s: GET_DEVICE_DESCRIPTOR: id=%d, state=%d\n",
1390 if (usb_get_device_descriptor(w_value_lo) < 0)
1391 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1394 LOG_INFO("%s: GET_CONFIG_DESCRIPTOR: id=%d, state=%d\n",
1395 __func__, w_value_lo, udc.state);
1396 if (usb_get_configuration_descriptor(w_value_lo) < 0)
1397 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1400 LOG_INFO("%s: GET_STRING_DESCRIPTOR: id=%d, state=%d\n",
1401 __func__, w_value_lo, udc.state);
1402 if (usb_get_string_descriptor(w_value_lo) < 0)
1403 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1406 LOG_WARN("%s: GET_UNKNOWN_DESCRIPTOR: id=%d, state=%d\n",
1407 __func__, w_value_lo, udc.state);
1408 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1413 /* USB setup packet: class/vendor request handler */
1414 static void usb_event_handler(struct usb_device *dev)
1417 * TODO: get the appropriate usb_dev in function of the endpoint
1421 dev->event_cb(&setup_packet);
1424 /* USB setup packet: GET_DESCRIPTOR handler */
1425 static void UBS_GetDescriptorHandler(void)
1427 LOG_INFO("%s: GET_DESCRIPTOR: RECIP = %d\n",
1429 setup_packet.mRequestType & USB_RECIP_MASK);
1430 if ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1433 /* Getting descriptor for a device is a standard request */
1434 else if ((setup_packet.mRequestType & USB_DIR_MASK) == USB_DIR_IN)
1435 usb_event_handler(usb_dev);
1437 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1440 /* USB setup packet: SET_ADDRESS handler */
1441 static void USB_SetAddressHandler(void)
1443 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1444 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1445 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1447 LOG_INFO("%s: SET_ADDRESS: %d\n",
1448 __func__, usb_le16_to_cpu(setup_packet.wValue));
1449 if ((udc.state >= USB_STATE_DEFAULT) &&
1450 ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1451 USB_RECIP_DEVICE) &&
1452 (w_index == 0) && (w_length == 0) && (w_value < 128))
1453 USB_StatusHandler(CTRL_ENP_IN);
1455 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1458 /* USB setup packet: GET_CONFIGURATION handler */
1459 static void USB_GetConfigurationHandler(void)
1461 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1462 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1464 LOG_INFO("%s: GET_CONFIGURATION\n", __func__);
1465 if ((udc.state >= USB_STATE_ADDRESS) &&
1466 (w_value == 0) && (w_index == 0) && (w_value == 1))
1468 InData = udc.cfg_id;
1469 __usb_ep_write(CTRL_ENP_IN, (uint8_t *)&InData, 1, USB_StatusHandler);
1472 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1475 static const usb_config_descriptor_t *usb_find_configuration(int num)
1477 const usb_config_descriptor_t *cfg;
1482 cfg = (const usb_config_descriptor_t *)usb_dev->config[i];
1485 if (cfg->bDescriptorType != USB_DT_CONFIG)
1487 if (cfg->bConfigurationValue == num)
1493 static int UsbSetConfigurationState(uint32_t Configuration)
1495 const usb_config_descriptor_t *pCnfg;
1500 /* Find configuration descriptor */
1501 pCnfg = usb_find_configuration(Configuration);
1503 return -USB_NODEV_ERROR;
1505 /* Reset current configuration */
1506 usb_set_device_state(USB_STATE_ADDRESS);
1507 usb_dev->configured = false;
1510 /* Set Interface and Alternative Setting */
1511 udc.cfg_id = Configuration;
1512 /* Set self-powered state */
1513 if (pCnfg->bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1514 udc.feature |= STM32_UDC_FEATURE_SELFPOWERED;
1516 /* Configure all existing interfaces to alternative setting 0 */
1517 ASSERT(pCnfg->bNumInterfaces <= USB_MAX_INTERFACE);
1518 udc.interfaces = pCnfg->bNumInterfaces;
1519 for (i = 0; i < udc.interfaces; i++)
1521 usb_set_device_state(USB_STATE_CONFIGURED);
1522 usb_dev->configured = true;
1526 usb_dev->configured = false;
1527 usb_set_device_state(USB_STATE_ADDRESS);
1532 /* USB setup packet: SET_CONFIGURATION handler */
1533 static void USB_SetConfigurationHandler(void)
1535 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1536 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1537 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1539 LOG_INFO("%s: SET_CONFIGURATION: %d\n",
1541 if ((udc.state >= USB_STATE_ADDRESS) &&
1542 (w_index == 0) && (w_length == 0) &&
1543 (UsbSetConfigurationState(w_value & 0xff) == 0))
1544 USB_StatusHandler(CTRL_ENP_OUT);
1546 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1549 /* USB setup packet: standard request handler */
1550 static void USB_StandardRequestHandler(void)
1552 switch (setup_packet.bRequest)
1554 case USB_REQ_GET_STATUS:
1555 USB_GetStatusHandler();
1557 case USB_REQ_CLEAR_FEATURE:
1558 LOG_INFO("%s: bRequest=%d (CLEAR_FEATURE)\n",
1559 __func__, setup_packet.bRequest);
1561 case USB_REQ_SET_FEATURE:
1562 LOG_INFO("%s: bRequest=%d (SET_FEATURE)\n",
1563 __func__, setup_packet.bRequest);
1565 case USB_REQ_SET_ADDRESS:
1566 USB_SetAddressHandler();
1568 case USB_REQ_GET_DESCRIPTOR:
1569 UBS_GetDescriptorHandler();
1571 case USB_REQ_SET_DESCRIPTOR:
1572 LOG_INFO("%s: bRequest=%d (SET_DESCRIPTOR)\n",
1573 __func__, setup_packet.bRequest);
1575 case USB_REQ_GET_CONFIGURATION:
1576 USB_GetConfigurationHandler();
1578 case USB_REQ_SET_CONFIGURATION:
1579 USB_SetConfigurationHandler();
1581 case USB_REQ_GET_INTERFACE:
1582 LOG_INFO("%s: bRequest=%d (GET_INTERFACE)\n",
1583 __func__, setup_packet.bRequest);
1585 case USB_REQ_SET_INTERFACE:
1586 LOG_INFO("%s: bRequest=%d (SET_INTERFACE)\n",
1587 __func__, setup_packet.bRequest);
1589 case USB_REQ_SYNCH_FRAME:
1590 LOG_INFO("%s: bRequest=%d (SYNCH_FRAME)\n",
1591 __func__, setup_packet.bRequest);
1594 LOG_WARN("%s: bRequest=%d (Unknown)\n",
1595 __func__, setup_packet.bRequest);
1596 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1601 /* USB setup packet handler */
1602 static void USB_SetupHandler(void)
1604 switch (setup_packet.mRequestType & USB_TYPE_MASK)
1607 case USB_TYPE_STANDARD:
1608 LOG_INFO("%s: bmRequestType=%02x (Standard)\n",
1609 __func__, setup_packet.mRequestType);
1610 USB_StandardRequestHandler();
1613 case USB_TYPE_CLASS:
1614 LOG_INFO("%s: bmRequestType=%02x (Class)\n",
1615 __func__, setup_packet.mRequestType);
1616 usb_event_handler(usb_dev);
1619 case USB_TYPE_VENDOR:
1620 LOG_INFO("%s: bmRequestType=%02x (Vendor)\n",
1621 __func__, setup_packet.mRequestType);
1622 usb_event_handler(usb_dev);
1624 case USB_TYPE_RESERVED:
1625 LOG_INFO("%s: bmRequestType=%02x (Reserved)\n",
1626 __func__, setup_packet.mRequestType);
1630 LOG_WARN("%s: bmRequestType=%02x (Unknown)\n",
1631 __func__, setup_packet.mRequestType);
1632 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1637 /* USB: low-level hardware initialization */
1638 static void usb_hw_reset(void)
1643 /* Initialize endpoint descriptors */
1644 for (i = 0; i < countof(ep_cnfg); i++)
1645 ep_cnfg[i].hw = NULL;
1647 /* Initialize USB memory */
1648 for (i = 0; i < countof(PacketMemBuff); i++)
1649 PacketMemBuff[i].Size = 0;
1650 usb->BTABLE = USB_BDT_OFFSET;
1651 pPacketMemUse = NULL;
1653 /* Endpoint initialization */
1654 ret = usb_ep_configure(&USB_CtrlEpDescr0, true);
1655 if (UNLIKELY(ret < 0))
1657 LOG_WARN("%s: out of memory, cannot initialize EP0\n",
1661 ret = usb_ep_configure(&USB_CtrlEpDescr1, true);
1662 if (UNLIKELY(ret < 0))
1664 LOG_WARN("%s: out of memory, cannot initialize EP1\n",
1669 /* Set default address */
1672 /* Enable all the device interrupts */
1674 usb->CNTR = bmCTRM | bmRESETM | bmSOFM | bmERRM | bmPMAOVRM |
1677 /* XXX: disable frame interrupts for now (too much noise!) */
1678 usb->CNTR = bmCTRM | bmRESETM | bmERRM | bmPMAOVRM | bmSUSPM | bmWKUPM;
1682 /* Handle a correct transfer under ISR */
1683 static void usb_isr_correct_transfer(stm32_usb_irq_status_t interrupt)
1686 reg32_t *pReg = (reg32_t *)&usb->EP0R;
1688 /* Find corresponding EP */
1689 pReg += interrupt.EP_ID;
1690 EP = (int)(((*pReg & 0x0f) << 1) + (interrupt.DIR ? 0 : 1));
1691 ep_cnfg[EP].avail_data = 1;
1693 ASSERT(ep_cnfg[EP].hw);
1696 EpCtrlClr_CTR_TX(ep_cnfg[EP].hw);
1698 EpCtrlClr_CTR_RX(ep_cnfg[EP].hw);
1699 if (EP == CTRL_ENP_OUT)
1701 /* Determinate type of packet (only for control EP) */
1702 bool SetupPacket = EpCtrlGet_SETUP(ep_cnfg[CTRL_ENP_OUT].hw);
1706 ep_cnfg[CTRL_ENP_IN].avail_data = 1;
1707 /* init IO to receive Setup packet */
1708 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1709 __usb_ep_read(CTRL_ENP_OUT, &setup_packet,
1710 sizeof(setup_packet), NULL);
1712 /* reset EP IO ctrl */
1713 if (setup_packet.mRequestType & USB_DIR_IN)
1714 USB_StatusHandler(CTRL_ENP_OUT);
1716 if (ep_cnfg[CTRL_ENP_OUT].status == STALLED)
1721 if (ep_cnfg[CTRL_ENP_OUT].complete &&
1722 setup_packet.mRequestType & USB_DIR_IN)
1723 ep_cnfg[CTRL_ENP_OUT].complete(CTRL_ENP_OUT);
1728 else if (EP == CTRL_ENP_IN)
1730 if (ep_cnfg[CTRL_ENP_IN].complete &&
1731 !(setup_packet.mRequestType & USB_DIR_IN))
1732 ep_cnfg[CTRL_ENP_IN].complete(CTRL_ENP_IN);
1741 /* USB: interrupt service routine */
1742 static void usb_isr(void)
1744 stm32_usb_irq_status_t interrupt;
1746 /* Get masked interrupt flags */
1747 interrupt.status = usb->ISTR;
1748 interrupt.status &= usb->CNTR | 0x1f;
1750 if (interrupt.PMAOVR)
1752 LOG_WARN("%s: DMA overrun / underrun\n", __func__);
1753 usb->ISTR = ~bmPMAOVRM;
1757 LOG_WARN("%s: engine error\n", __func__);
1758 usb->ISTR = ~bmERRM;
1760 if (interrupt.RESET)
1762 LOG_INFO("%s: device reset\n", __func__);
1763 usb->ISTR = ~bmRESETM;
1765 usb_set_device_state(USB_STATE_DEFAULT);
1769 uint16_t frame_nr = usb->FNR & 0x0fff;
1771 LOG_INFO("%s: frame %#x\n", __func__, frame_nr);
1772 usb->ISTR = ~bmSOFM;
1776 LOG_INFO("%s: wake-up\n", __func__);
1777 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1782 LOG_INFO("%s: suspend\n", __func__);
1784 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1788 LOG_INFO("%s: expected frame\n", __func__);
1789 usb->ISTR = ~bmESOFM;
1793 usb_isr_correct_transfer(interrupt);
1797 /* USB: hardware initialization */
1798 static void usb_hw_init(void)
1800 /* Enable clocking on the required GPIO pins */
1801 RCC->APB2ENR |= RCC_APB2_GPIOA | RCC_APB2_GPIOC;
1803 /* Make sure that the CAN controller is disabled and held in reset */
1804 RCC->APB1ENR &= ~RCC_APB1_CAN;
1806 /* Configure USB_DM and USB_DP to work as USB lines */
1807 stm32_gpioPinConfig((struct stm32_gpio *)GPIOA_BASE,
1808 USB_DM_PIN | USB_DP_PIN,
1809 GPIO_MODE_AF_PP, GPIO_SPEED_50MHZ);
1810 /* Configure USB_DISC to work as USB disconnect */
1811 stm32_gpioPinConfig((struct stm32_gpio *)GPIOC_BASE,
1813 GPIO_MODE_OUT_PP, GPIO_SPEED_50MHZ);
1814 stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE,
1817 /* Ensure the USB clock is disabled before setting the prescaler */
1818 RCC->APB1ENR &= ~RCC_APB1_USB;
1820 /* Configure USB clock (48MHz) */
1821 *CFGR_USBPRE_BB &= ~RCC_USBCLK_PLLCLK_1DIV5;
1823 /* Activate USB clock */
1824 RCC->APB1ENR |= RCC_APB1_USB;
1826 /* Force USB reset and disable USB interrupts */
1830 /* Issue a USB reset */
1833 /* Clear spurious pending interrupt */
1836 /* Register interrupt handler */
1837 sysirq_setHandler(USB_LP_CAN_RX0_IRQHANDLER, usb_isr);
1839 /* Software connection enable */
1843 /* Initialize the USB controller */
1844 static void usb_init(void)
1846 udc.state = USB_STATE_NOTATTACHED;
1852 /* Register an upper layer USB device into the driver */
1853 int usb_device_register(struct usb_device *dev)
1860 while (!usb_dev->configured)