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)) : \
65 /* XXX: redefine this to make it usable within C expression */
66 #define _MIN(a,b) (((a) < (b)) ? (a) : (b))
68 /* STM32 USB registers */
79 reg32_t __reserved[8];
87 /* Hardware registers */
88 static struct stm32_usb *usb = (struct stm32_usb *)USB_BASE_ADDR;
90 /* Endpoint descriptors: used for handling requests to use with endpoints */
91 static stm32_UsbEp ep_cnfg[ENP_MAX_NUMB];
93 /* USB EP0 control descriptor */
94 static const UsbEndpointDesc USB_CtrlEpDescr0 =
96 .bLength = sizeof(USB_CtrlEpDescr0),
97 .bDescriptorType = USB_DT_ENDPOINT,
98 .bEndpointAddress = USB_DIR_OUT | 0,
99 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
100 .wMaxPacketSize = USB_EP0_MAX_SIZE,
104 /* USB EP1 control descriptor */
105 static const UsbEndpointDesc USB_CtrlEpDescr1 =
107 .bLength = sizeof(USB_CtrlEpDescr1),
108 .bDescriptorType = USB_DT_ENDPOINT,
109 .bEndpointAddress = USB_DIR_IN | 0,
110 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
111 .wMaxPacketSize = USB_EP0_MAX_SIZE,
115 /* USB setup packet */
116 static UsbCtrlRequest setup_packet;
118 /* USB device controller: max supported interfaces */
119 #define USB_MAX_INTERFACE 1
121 /* USB device controller features */
122 #define STM32_UDC_FEATURE_SELFPOWERED BV(0)
123 #define STM32_UDC_FEATURE_REMOTE_WAKEUP BV(1)
125 /* Hardware-specific USB device controller structure */
126 typedef struct stm32_udc
130 const UsbConfigDesc *cfg;
132 uint32_t alt[USB_MAX_INTERFACE];
135 } PACKED stm32_udc_t;
137 /* Hardware-specific USB Device Controller */
138 static stm32_udc_t udc;
140 /* Generic USB Device Controller structure */
141 static UsbDevice *usb_dev;
143 /* USB packet memory management: list of allocated chunks */
144 static stm32_UsbMemSlot *mem_use;
146 /* USB packet memory management: memory buffer metadata */
147 #define EP_MAX_SLOTS 16
148 static stm32_UsbMemSlot memory_buffer[EP_MAX_SLOTS];
150 /* Allocate a free block of the packet memory */
151 static stm32_UsbMemSlot *usb_malloc(void)
155 for (i = 0; i < countof(memory_buffer); i++)
156 if (memory_buffer[i].Size == 0)
157 return &memory_buffer[i];
161 /* Release a block of the packet memory */
162 static void usb_free(stm32_UsbMemSlot *pPntr)
167 /* Allocate a free chunk of the packet memory (inside a block) */
168 static bool usb_alloc_buffer(uint16_t *pOffset, uint32_t *size,
171 stm32_UsbMemSlot *mem = mem_use,
172 *memNext, *mem_useNew;
173 uint32_t max_size = *size;
176 * Packet size alignment:
177 * - fine-granularity allocation: size alignment by 2;
178 * - coarse-granularity allocation: size alignment by 32.
181 max_size = ALIGN_UP(max_size, 2);
183 max_size = ALIGN_UP(max_size, 32);
185 * Finding free memory chunks from the allocated blocks of the USB
191 /* Offset alignment by 4 */
192 *pOffset = ALIGN_UP(mem->Start + mem->Size, 4);
194 if ((mem->next == NULL) ||
196 *pOffset + max_size))
200 /* Check for out-of-memory condition */
201 if ((*pOffset + max_size) >= USB_BDT_OFFSET)
204 * Allocate a new memory block, next to the last allocated block.
206 mem_useNew = usb_malloc();
207 if (mem_useNew == NULL)
209 /* Insert the block to the list of allocated blocks */
212 mem_use = mem_useNew;
213 mem_use->next = NULL;
217 mem_useNew->next = mem->next;
218 mem->next = mem_useNew;
220 /* Update block's metadata */
221 mem_useNew->ep_addr = EndPoint;
222 mem_useNew->Start = *pOffset;
223 mem_useNew->Size = max_size;
230 /* Release a chunk of the packet memory (inside a block) */
231 static void usb_free_buffer(int EndPoint)
233 stm32_UsbMemSlot *mem, *memPrev = NULL;
238 if (mem->ep_addr == EndPoint)
240 if (UNLIKELY(memPrev == NULL))
242 /* Free the first element of the list */
243 mem_use = mem_use->next;
248 memPrev->next = mem->next;
257 /*-------------------------------------------------------------------------*/
259 /* Connect USB controller */
260 static void usb_connect(void)
262 stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE, 1 << 11, 0);
265 /* Set USB device address */
266 static void usb_set_address(uint32_t addr)
268 usb->DADDR = addr | 0x80;
271 /* Suspend USB controller */
272 static void usb_suspend(void)
274 usb->CNTR |= bmFSUSP | bmLPMODE;
277 /* Resume USB controller */
278 static void usb_resume(void)
280 uint32_t line_status;
282 line_status = usb->FNR & 0xc000;
285 /* check for noise and eventually return to sleep */
286 if (line_status == 0xc000)
289 usb->CNTR &= ~(bmFSUSP | bmLPMODE);
292 /* Convert logical EP address to physical EP address */
293 static int usb_ep_logical_to_hw(uint8_t ep_addr)
295 int addr = (ep_addr & 0x0f) << 1;
296 return (ep_addr & 0x80) ? addr + 1 : addr;
300 static void ep_ctrl_set_ea(reg32_t *reg, uint32_t val)
303 val |= *reg & 0x0700;
304 val |= USB_CTRL_CLEAR_ONLY_MASK;
308 /* Get EP IN status */
309 static uint32_t ep_ctrl_get_stat_tx(reg32_t *reg)
311 return (*reg & (0x3UL << 4)) >> 4;
314 /* Set EP IN state */
315 static void ep_ctrl_set_stat_tx(reg32_t *reg, stm32_UsbEpState val)
321 * The EP can change state between read and write operations from VALID
322 * to NAK and result of set operation will be invalid.
324 for (i = 0; i < 2; i++)
326 if (ep_ctrl_get_stat_tx(reg) == val)
331 state |= USB_CTRL_CLEAR_ONLY_MASK;
332 /* Clear the toggle bits without STAT_TX (4,5) */
338 /* Set EP DTOG_TX bit (IN) */
339 static void ep_ctrl_set_dtog_tx(reg32_t *reg, uint32_t val)
341 val = val ? (*reg ^ (1UL << 6)) : *reg;
342 /* Clear the toggle bits without DTOG_TX (6) */
344 val |= USB_CTRL_CLEAR_ONLY_MASK;
348 /* Clear EP CTR_TX bit (IN) */
349 static void ep_ctrl_clr_ctr_tx(reg32_t *reg)
353 val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 7);
359 /* Clear EP CTR_RX bit (OUT) */
360 static void ep_ctrl_clr_ctr_rx(reg32_t *reg)
363 val &= ~(USB_CTRL_TOGGLE_MASK | 1UL << 15);
369 /* Set EP KIND bit */
370 static void ep_ctrl_set_ep_kind(reg32_t *reg, uint32_t val)
372 val = val ? (1UL << 8) : 0;
373 val |= *reg & ~(USB_CTRL_TOGGLE_MASK | (1UL << 8));
374 val |= USB_CTRL_CLEAR_ONLY_MASK;
379 static int ep_ctrl_set_ep_type(reg32_t *reg, uint8_t val)
383 if (UNLIKELY(val >= EP_TYPE_MAX))
386 return USB_INVAL_ERROR;
390 type |= *reg & ~(USB_CTRL_TOGGLE_MASK | (0x3UL << 9));
391 type |= USB_CTRL_CLEAR_ONLY_MASK;
397 /* Get EP STAT_RX (OUT) */
398 static uint32_t ep_ctrl_get_stat_rx(reg32_t *reg)
400 uint32_t val = *reg & (0x3UL << 12);
404 /* Set EP STAT_RX (OUT) */
405 static void ep_ctrl_set_stat_rx(reg32_t *reg, stm32_UsbEpState val)
411 * The EP can change state between read and write operations from VALID
412 * to NAK and result of set operation will be invalid.
414 for (i = 0; i < 2; i++)
416 if (ep_ctrl_get_stat_rx(reg) == val)
421 state |= USB_CTRL_CLEAR_ONLY_MASK;
422 /* Clear the toggle bits without STAT_RX (12,13) */
428 /* Set DTOG_RX bit */
429 static void ep_ctrl_set_dtog_rx(reg32_t *reg, uint32_t val)
431 val = val ? (*reg ^ (1UL << 14)) : *reg;
432 /* Clear the toggle bits without DTOG_RX (14) */
434 val |= USB_CTRL_CLEAR_ONLY_MASK;
438 /* Get EP SETUP bit */
439 static uint32_t ep_ctrl_get_setup(reg32_t *reg)
441 uint32_t val = *reg & (1UL << 11);
445 /* Core endpoint I/O function */
446 static void __usb_ep_io(int EP)
448 ssize_t Count, CountHold, Offset;
449 uint32_t *pDst, *pSrc, Data;
450 stm32_UsbEp *epd = &ep_cnfg[EP];
452 if (UNLIKELY(epd->hw == NULL))
454 LOG_ERR("%s: invalid endpoint (EP%d-%s)\n",
457 (EP & 0x01) ? "IN" : "OUT");
461 if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
467 Count = epd->size - epd->offset;
468 while (epd->avail_data)
470 if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
474 epd->status = BEGIN_SERVICED;
476 if ((epd->flags & STM32_USB_EP_ZERO_PACKET) &&
477 (Count == epd->max_size))
478 epd->flags |= STM32_USB_EP_ZERO_PACKET |
479 STM32_USB_EP_ZERO_POSSIBLE;
481 CountHold = Count = MIN(Count, epd->max_size);
483 epd->flags |= STM32_USB_EP_ZERO_PACKET;
484 Offset = epd->offset;
485 epd->offset += Count;
488 case USB_ENDPOINT_XFER_CONTROL:
489 case USB_ENDPOINT_XFER_INT:
490 pDst = (uint32_t *)USB_MEM_ADDR(EP_DTB_READ(EP >> 1, ADDR_TX_OFFSET));
492 case USB_ENDPOINT_XFER_BULK:
493 pDst = (uint32_t *)USB_MEM_ADDR(EP_DTB_READ(EP >> 1, ADDR_TX_OFFSET));
495 case USB_ENDPOINT_XFER_ISOC:
496 LOG_ERR("%s: isochronous transfer not supported\n",
498 /* Fallback to default */
504 /* Write data to packet memory buffer */
507 Data = *(epd->write_buffer + Offset++);
510 Data |= (uint32_t)(*(epd->write_buffer + Offset++)) << 8;
516 EP_DTB_WRITE(EP >> 1, COUNT_TX_OFFSET, CountHold);
517 ep_ctrl_set_stat_tx(epd->hw, EP_VALID);
519 --ep_cnfg[EP].avail_data;
520 Count = epd->size - epd->offset;
522 if (!Count && !(epd->flags & STM32_USB_EP_ZERO_PACKET))
524 epd->status = COMPLETE;
525 /* call callback function */
533 while (epd->avail_data)
535 /* Get data size and buffer pointer */
538 case USB_ENDPOINT_XFER_CONTROL:
539 case USB_ENDPOINT_XFER_INT:
540 /* Get received bytes number */
541 Count = EP_DTB_READ(EP >> 1, COUNT_RX_OFFSET) & 0x3FF;
542 /* Get address of the USB packet buffer for corresponding EP */
543 pSrc = (uint32_t *)USB_MEM_ADDR(EP_DTB_READ(EP >> 1, ADDR_RX_OFFSET));
545 case USB_ENDPOINT_XFER_BULK:
546 /* Get received bytes number */
547 Count = EP_DTB_READ(EP >> 1, COUNT_RX_OFFSET) & 0x3FF;
548 /* Get address of the USB packet buffer for corresponding EP */
549 pSrc = (uint32_t *)USB_MEM_ADDR(EP_DTB_READ(EP >> 1, ADDR_RX_OFFSET));
551 case USB_ENDPOINT_XFER_ISOC:
552 LOG_ERR("%s: isochronous transfer not supported\n",
554 /* Fallback to default */
560 if (Count > (epd->size - epd->offset))
562 epd->status = BUFFER_OVERRUN;
563 epd->size = ep_cnfg[EP].offset;
566 else if (Count < ep_cnfg[EP].max_size)
568 epd->status = BUFFER_UNDERRUN;
569 epd->size = ep_cnfg[EP].offset + Count;
572 epd->status = BEGIN_SERVICED;
574 Offset = epd->offset;
575 epd->offset += Count;
577 /* Read data from packet memory buffer */
581 *(epd->read_buffer + Offset++) = Data;
585 *(epd->read_buffer + Offset++) = Data;
590 ep_ctrl_set_stat_rx(epd->hw, EP_VALID);
592 --ep_cnfg[EP].avail_data;
594 if (*epd->hw & (1UL << 11))
596 ep_cnfg[EP].status = SETUP_OVERWRITE;
599 if (!(Count = (epd->size - epd->offset)))
601 epd->status = COMPLETE;
605 if (epd->status != BEGIN_SERVICED && epd->status != NO_SERVICED)
607 /* call callback function */
615 * Return the lower value from Host expected size and size and set a flag
616 * STM32_USB_EP_ZERO_POSSIBLE when size is lower that host expected size.
618 static size_t usb_size(size_t size, size_t host_size)
620 if (size < host_size)
622 ep_cnfg[CTRL_ENP_IN].flags |= STM32_USB_EP_ZERO_POSSIBLE;
628 /* Configure an EP descriptor before performing a I/O operation */
629 #define USB_EP_IO(__EP, __op, __buf, __size, __complete) \
632 stm32_UsbIoStatus ret; \
634 /* Fill EP descriptor */ \
635 IRQ_SAVE_DISABLE(flags); \
638 ep_cnfg[__EP].status = NOT_READY; \
639 ep_cnfg[__EP].complete = NULL; \
643 if (ep_cnfg[__EP].status == BEGIN_SERVICED) \
649 * NOTE: the write_buffer and read_buffer are actually the \
650 * same location in memory (it's a union). \
652 * We have to do this trick to silent a build warning by \
653 * casting the I/O buffer to (void *) or (const void *). \
655 ep_cnfg[__EP].__op ## _buffer = __buf; \
656 ep_cnfg[__EP].offset = 0; \
657 ep_cnfg[__EP].size = __size; \
658 ep_cnfg[__EP].complete = __complete; \
660 ep_cnfg[__EP].flags = STM32_USB_EP_ZERO_PACKET; \
662 ep_cnfg[__EP].flags = 0; \
663 ep_cnfg[__EP].status = NO_SERVICED; \
665 /* Perform the I/O operation */ \
668 ret = ep_cnfg[__EP].status; \
670 IRQ_RESTORE(flags); \
674 /* Configure and endponint and perform a read operation */
675 static stm32_UsbIoStatus
676 __usb_ep_read(int ep, void *buffer, ssize_t size, void (*complete)(int))
678 if (UNLIKELY(ep >= ENP_MAX_NUMB))
683 ASSERT(!(ep & 0x01));
684 return USB_EP_IO(ep, read, buffer, size, complete);
687 /* Configure and endponint and perform a write operation */
688 static stm32_UsbIoStatus
689 __usb_ep_write(int ep, const void *buffer, ssize_t size, void (*complete)(int))
691 if (UNLIKELY(ep >= ENP_MAX_NUMB))
697 return USB_EP_IO(ep, write, buffer, size, complete);
700 static void usb_ep_low_level_config(int ep, uint16_t offset, uint16_t size)
702 stm32_UsbEp *epc = &ep_cnfg[ep];
708 ep_ctrl_set_stat_tx(epc->hw, EP_DISABLED);
709 /* Clear Tx toggle */
710 ep_ctrl_set_dtog_tx(epc->hw, 0);
711 /* Clear Correct Transfer for transmission flag */
712 ep_ctrl_clr_ctr_tx(epc->hw);
714 /* Update EP description table */
715 EP_DTB_WRITE(ep >> 1, ADDR_TX_OFFSET, offset);
716 EP_DTB_WRITE(ep >> 1, COUNT_TX_OFFSET, 0);
721 uint16_t rx_count = 0;
724 ep_ctrl_set_stat_rx(epc->hw, EP_DISABLED);
725 /* Clear Rx toggle */
726 ep_ctrl_set_dtog_rx(epc->hw, 0);
727 /* Clear Correct Transfer for reception flag */
728 ep_ctrl_clr_ctr_rx(epc->hw);
729 /* Descriptor block size field */
730 rx_count |= (size > 62) << 15;
731 /* Descriptor number of blocks field */
732 rx_count |= (((size > 62) ? (size >> 5) - 1 : size >> 1) &
734 /* Update EP description table */
735 EP_DTB_WRITE(ep >> 1, ADDR_RX_OFFSET, offset);
736 EP_DTB_WRITE(ep >> 1, COUNT_RX_OFFSET, rx_count);
740 /* Enable/Disable an endpoint */
741 static int usb_ep_configure(const UsbEndpointDesc *epd, bool enable)
749 EP = usb_ep_logical_to_hw(epd->bEndpointAddress);
750 ep_hw = &ep_cnfg[EP];
755 * Allocate packet memory for EP buffer/s calculate actual size
756 * only for the OUT EPs.
758 size = epd->wMaxPacketSize;
759 if (!usb_alloc_buffer(&Offset, &size, EP))
760 return -USB_MEMORY_FULL;
763 ep_hw->status = NOT_READY;
767 /* Set endpoint type */
768 ep_hw->type = usb_endpointType(epd);
769 /* Init EP max packet size */
770 ep_hw->max_size = epd->wMaxPacketSize;
773 ep_hw->avail_data = 1;
775 ep_hw->avail_data = 0;
776 hw = (reg32_t *)&usb->EP0R;
780 ep_ctrl_set_ea(hw, EP >> 1);
782 LOG_INFO("%s: EP%d-%s configured\n",
783 __func__, EP >> 1, EP & 1 ? "IN" : "OUT");
785 /* Low-level endpoint configuration */
786 usb_ep_low_level_config(EP, Offset, size);
788 /* Set EP Kind & enable */
791 case USB_ENDPOINT_XFER_CONTROL:
792 LOG_INFO("EP%d: CONTROL IN\n", EP >> 1);
793 ep_ctrl_set_ep_type(hw, EP_CTRL);
794 ep_ctrl_set_ep_kind(hw, 0);
796 case USB_ENDPOINT_XFER_INT:
797 LOG_INFO("EP%d: INTERRUPT IN\n", EP >> 1);
798 ep_ctrl_set_ep_type(hw, EP_INTERRUPT);
799 ep_ctrl_set_ep_kind(hw, 0);
801 case USB_ENDPOINT_XFER_BULK:
802 LOG_INFO("EP%d: BULK IN\n", EP >> 1);
803 ep_ctrl_set_ep_type(hw, EP_BULK);
804 ep_ctrl_set_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 ep_ctrl_set_stat_tx(hw, EP_NAK);
817 /* Clear Correct Transfer for transmission flag */
818 ep_ctrl_clr_ctr_tx(hw);
823 ep_ctrl_set_stat_rx(hw, EP_VALID);
826 else if (ep_cnfg[EP].hw)
828 hw = (reg32_t *)&usb->EP0R;
835 ep_ctrl_set_stat_tx(hw, EP_DISABLED);
836 /* Clear Correct Transfer for reception flag */
837 ep_ctrl_clr_ctr_tx(hw);
843 ep_ctrl_set_stat_rx(hw, EP_DISABLED);
844 /* Clear Correct Transfer for reception flag */
845 ep_ctrl_clr_ctr_rx(hw);
849 ep_cnfg[EP].hw = NULL;
854 /* Get EP stall/unstall */
855 static int usb_ep_get_stall(int EP, bool *pStall)
857 if (ep_cnfg[EP].hw == NULL)
858 return -USB_NODEV_ERROR;
860 *pStall = (EP & 0x01) ?
861 (ep_ctrl_get_stat_tx(ep_cnfg[EP].hw) == EP_STALL): /* IN EP */
862 (ep_ctrl_get_stat_rx(ep_cnfg[EP].hw) == EP_STALL); /* OUT EP */
867 /* Set EP stall/unstall */
868 static int usb_ep_set_stall(int EP, bool Stall)
870 if (ep_cnfg[EP].hw == NULL)
871 return -USB_NODEV_ERROR;
875 ep_cnfg[EP].status = STALLED;
879 ep_ctrl_set_stat_tx(ep_cnfg[EP].hw, EP_STALL);
880 ep_cnfg[EP].avail_data = 1;
885 ep_ctrl_set_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 ep_ctrl_set_dtog_tx(ep_cnfg[EP].hw, 0);
898 ep_ctrl_set_stat_tx(ep_cnfg[EP].hw, EP_NAK);
903 ep_cnfg[EP].avail_data = 0;
904 /* reset Data Toggle bit */
905 ep_ctrl_set_dtog_rx(ep_cnfg[EP].hw, 0);
906 ep_ctrl_set_stat_rx(ep_cnfg[EP].hw, EP_VALID);
912 /* Stall both directions of the control EP */
913 static void usb_ep_set_stall_ctrl(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_ep_set_stall(CTRL_ENP_IN, true);
921 usb_ep_set_stall(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 const UsbInterfaceDesc *id;
935 /* TODO: support more than one configuration per device */
936 id = (const UsbInterfaceDesc *)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 const UsbEndpointDesc *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 = (const UsbEndpointDesc *)usb_dev->config[i];
978 if ((epd == NULL) || (epd->bDescriptorType == USB_DT_INTERFACE))
980 if (epd->bDescriptorType != USB_DT_ENDPOINT)
982 if (UNLIKELY(usb_ep_configure(epd, enable) < 0))
984 LOG_ERR("%s: out of memory, can't initialize EP\n",
991 /* Set device state */
992 static void usb_set_device_state(int state)
996 LOG_INFO("%s: new state %d\n", __func__, state);
998 if (udc.state == USB_STATE_CONFIGURED)
1000 /* Deconfigure device */
1001 for (i = 0; i < udc.interfaces; ++i)
1002 usb_configure_ep_interface(i,
1007 case USB_STATE_ATTACHED:
1008 case USB_STATE_POWERED:
1009 case USB_STATE_DEFAULT:
1011 usb_dev->configured = false;
1012 udc.address = udc.cfg_id = 0;
1014 case USB_STATE_ADDRESS:
1017 case USB_STATE_CONFIGURED:
1018 /* Configure device */
1019 for (i = 0; i < udc.interfaces; ++i)
1020 usb_configure_ep_interface(i,
1024 /* Unknown state: disconnected or connection in progress */
1025 usb_dev->configured = false;
1033 /* Setup packet: set address status phase end handler */
1034 static void usb_add_status_handler_end(UNUSED_ARG(int, EP))
1038 w_value = usb_le16_to_cpu(setup_packet.wValue);
1039 udc.address = w_value & 0xff;
1040 usb_set_address(udc.address);
1043 usb_set_device_state(USB_STATE_ADDRESS);
1045 usb_set_device_state(USB_STATE_DEFAULT);
1047 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1048 __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1051 /* Prepare status phase */
1052 static void usb_status_phase(bool in)
1055 __usb_ep_write(CTRL_ENP_IN, NULL, 0, NULL);
1058 /* Setup packet: status phase end handler */
1059 static void usb_status_handler_end(UNUSED_ARG(int, EP))
1061 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1062 __usb_ep_read(CTRL_ENP_OUT, NULL, -1, NULL);
1065 /* Address status handler */
1066 static void usb_status_handler(UNUSED_ARG(int, EP))
1068 if (setup_packet.mRequestType & USB_DIR_IN)
1070 usb_status_phase(false);
1071 ep_cnfg[CTRL_ENP_OUT].complete = usb_status_handler_end;
1075 usb_status_phase(true);
1076 ep_cnfg[CTRL_ENP_IN].complete =
1077 (setup_packet.bRequest == USB_REQ_SET_ADDRESS) ?
1078 usb_add_status_handler_end :
1079 usb_status_handler_end;
1083 static bool rx_done;
1084 static size_t rx_size;
1085 static uint8_t rx_buffer[_MIN(CONFIG_USB_RXBUFSIZE, USB_RX_MAX_SIZE)]
1086 __attribute__ ((__aligned__(4)));
1088 static void usb_endpointRead_complete(int ep)
1090 if (UNLIKELY(ep >= ENP_MAX_NUMB))
1095 ASSERT(!(ep & 0x01));
1098 rx_size = ep_cnfg[ep].size;
1101 ssize_t usb_endpointRead(int ep, void *buffer, ssize_t size)
1103 int ep_num = usb_ep_logical_to_hw(ep);
1104 ssize_t max_size = sizeof(rx_buffer);
1106 if (UNLIKELY((size_t)buffer & 0x03))
1108 LOG_ERR("unaligned buffer @ %p\n", buffer);
1112 /* Non-blocking read for EP0 */
1113 if (ep_num == CTRL_ENP_OUT)
1115 size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
1116 if (UNLIKELY(size > max_size))
1118 LOG_ERR("%s: rx_buffer exceeded, try to enlarge CONFIG_USB_RXBUFSIZE\n",
1121 return -USB_BUF_OVERFLOW;
1124 usb_status_handler(ep_num);
1127 __usb_ep_read(ep_num, rx_buffer, size,
1128 usb_status_handler);
1129 memcpy(buffer, rx_buffer, size);
1133 if (UNLIKELY(!size))
1135 size = MIN(size, max_size);
1140 __usb_ep_read(ep_num, rx_buffer, size, usb_endpointRead_complete);
1143 memcpy(buffer, rx_buffer, rx_size);
1148 static bool tx_done;
1149 static size_t tx_size;
1150 static uint8_t tx_buffer[_MIN(CONFIG_USB_TXBUFSIZE, USB_TX_MAX_SIZE)]
1151 __attribute__ ((__aligned__(4)));
1153 static void usb_endpointWrite_complete(int ep)
1155 if (UNLIKELY(ep >= ENP_MAX_NUMB))
1163 tx_size = ep_cnfg[ep].size;
1166 ssize_t usb_endpointWrite(int ep, const void *buffer, ssize_t size)
1168 int ep_num = usb_ep_logical_to_hw(ep);
1169 ssize_t max_size = sizeof(tx_buffer);
1171 if (UNLIKELY((size_t)buffer & 0x03))
1173 LOG_ERR("unaligned buffer @ %p\n", buffer);
1177 /* Non-blocking write for EP0 */
1178 if (ep_num == CTRL_ENP_IN)
1180 size = usb_size(size, usb_le16_to_cpu(setup_packet.wLength));
1181 if (UNLIKELY(size > max_size))
1183 LOG_ERR("%s: tx_buffer exceeded, try to enlarge CONFIG_USB_TXBUFSIZE\n",
1186 return -USB_BUF_OVERFLOW;
1189 usb_status_handler(ep_num);
1192 memcpy(tx_buffer, buffer, size);
1193 __usb_ep_write(ep_num, tx_buffer, size,
1194 usb_status_handler);
1198 if (UNLIKELY(!size))
1200 size = MIN(size, max_size);
1204 /* Blocking write */
1205 memcpy(tx_buffer, buffer, size);
1206 __usb_ep_write(ep_num, tx_buffer, size, usb_endpointWrite_complete);
1213 /* Global variable to handle the following non-blocking I/O operations */
1214 static uint32_t InData;
1216 /* Get device status */
1217 static int usb_send_device_status(uint16_t index)
1220 return -USB_NODEV_ERROR;
1222 InData = ((uint32_t)udc.feature) & 0xff;
1223 __usb_ep_write(CTRL_ENP_IN,
1224 (uint8_t *)&InData, sizeof(uint16_t),
1225 usb_status_handler);
1229 /* Get interface status */
1230 static int usb_send_interface_status(UNUSED_ARG(uint16_t, index))
1233 __usb_ep_write(CTRL_ENP_IN,
1234 (uint8_t *)&InData, sizeof(uint16_t),
1235 usb_status_handler);
1239 /* Get endpoint status */
1240 static int usb_send_ep_status(uint16_t index)
1242 if ((index & 0x7F) > 16)
1243 return -USB_NODEV_ERROR;
1246 usb_ep_get_stall(usb_ep_logical_to_hw(index), (bool *)&InData);
1247 __usb_ep_write(CTRL_ENP_IN,
1248 (uint8_t *)&InData, sizeof(uint16_t),
1249 usb_status_handler);
1253 /* USB setup packet: GET_STATUS request handler */
1254 static void usb_get_status_handler(void)
1256 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1257 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1258 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1260 /* GET_STATUS sanity checks */
1261 if (udc.state < USB_STATE_ADDRESS)
1263 LOG_WARN("%s: bad GET_STATUS request (State=%02x)\n",
1264 __func__, udc.state);
1265 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1270 LOG_WARN("%s: bad GET_STATUS request (wLength.Word=%02x)\n",
1271 __func__, w_length);
1272 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1275 if (!(setup_packet.mRequestType & USB_DIR_IN))
1277 LOG_WARN("%s: bad GET_STATUS request (mRequestType=%02x)\n",
1278 __func__, setup_packet.mRequestType);
1279 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1284 LOG_WARN("%s: bad GET_STATUS request (wValue=%02x)\n",
1286 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1290 /* Process GET_STATUS request */
1291 switch (setup_packet.mRequestType & USB_RECIP_MASK)
1293 case USB_RECIP_DEVICE:
1294 if (usb_send_device_status(w_index) < 0)
1296 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientDevice\n",
1298 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1301 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientDevice)\n",
1302 __func__, setup_packet.mRequestType);
1304 case USB_RECIP_INTERFACE:
1305 if (usb_send_interface_status(w_index) < 0)
1307 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientInterface\n",
1309 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1312 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientInterface)\n",
1313 __func__, setup_packet.mRequestType);
1315 case USB_RECIP_ENDPOINT:
1316 if (usb_send_ep_status(w_index) < 0)
1318 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1320 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1323 LOG_INFO("%s: GET_STATUS: mRequestType=%02x (UsbRecipientEndpoint)\n",
1324 __func__, setup_packet.mRequestType);
1327 LOG_WARN("%s: GET_STATUS: invalid UsbRecipientEndpoint\n",
1329 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1334 static int usb_get_device_descriptor(int id)
1337 return -USB_NODEV_ERROR;
1339 usb_dev->device->bMaxPacketSize0 = USB_EP0_MAX_SIZE;
1340 __usb_ep_write(CTRL_ENP_IN, (const uint8_t *)usb_dev->device,
1341 usb_size(usb_dev->device->bLength,
1342 usb_le16_to_cpu(setup_packet.wLength)),
1343 usb_status_handler);
1348 * TODO: refactor this part to remove this temporary buffer.
1350 * It would be better to define all the USB descriptors in the right order and
1351 * send them as a contiguous buffer directly from the flash / rodata memory.
1353 #define USB_BUFSIZE (128)
1354 static uint8_t usb_cfg_buffer[USB_BUFSIZE];
1355 STATIC_ASSERT(USB_BUFSIZE < (1 << (sizeof(uint16_t) * 8)));
1357 static int usb_get_configuration_descriptor(int id)
1359 const UsbConfigDesc **config =
1360 (const UsbConfigDesc **)usb_dev->config;
1361 uint8_t *p = usb_cfg_buffer;
1364 /* TODO: support more than one configuration per device */
1365 if (UNLIKELY(id > 0))
1366 return -USB_NODEV_ERROR;
1368 for (i = 0; config[i]; i++)
1370 memcpy(p, config[i], config[i]->bLength);
1371 p += config[i]->bLength;
1373 if (UNLIKELY((p - usb_cfg_buffer) > USB_BUFSIZE))
1376 return -USB_BUF_OVERFLOW;
1379 ((UsbConfigDesc *)usb_cfg_buffer)->wTotalLength =
1380 usb_cpu_to_le16((uint16_t)(p - usb_cfg_buffer));
1381 __usb_ep_write(CTRL_ENP_IN,
1383 usb_size(p - usb_cfg_buffer,
1384 usb_le16_to_cpu(setup_packet.wLength)),
1385 usb_status_handler);
1389 static int usb_get_string_descriptor(unsigned int id)
1391 const UsbStringDesc *lang_str;
1392 unsigned int lang_id, str_id;
1393 uint16_t w_index_lo = usb_le16_to_cpu(setup_packet.wIndex) & 0x00ff;
1394 uint16_t w_index_hi = (usb_le16_to_cpu(setup_packet.wIndex) &
1397 ASSERT(usb_dev->strings != NULL);
1398 ASSERT(usb_dev->strings[0] != NULL);
1400 lang_str = usb_dev->strings[0];
1403 /* Find Language index */
1404 for (lang_id = 0; ; lang_id++)
1406 const UsbStringDesc *str =
1407 usb_dev->strings[lang_id];
1408 if (UNLIKELY(str == NULL))
1409 return -USB_NODEV_ERROR;
1410 if ((str->data[0] == w_index_lo) &&
1411 (str->data[1] == w_index_hi))
1414 /* Check buffer overflow to find string index */
1415 for (str_id = 0; str_id < id; str_id++)
1417 lang_str = usb_dev->strings[lang_id + 1 + str_id];
1418 if (lang_str == NULL)
1419 return -USB_NODEV_ERROR;
1422 __usb_ep_write(CTRL_ENP_IN,
1424 usb_size(lang_str->bLength,
1425 usb_le16_to_cpu(setup_packet.wLength)),
1426 usb_status_handler);
1430 static void usb_get_descriptor(void)
1432 uint16_t w_value_lo = usb_le16_to_cpu(setup_packet.wValue) & 0x00ff;
1433 uint16_t w_value_hi = (usb_le16_to_cpu(setup_packet.wValue) & 0xff00) >> 8;
1435 if (udc.state < USB_STATE_DEFAULT)
1437 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1443 LOG_INFO("%s: GET_DEVICE_DESCRIPTOR: id=%d, state=%d\n",
1447 if (usb_get_device_descriptor(w_value_lo) < 0)
1448 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1451 LOG_INFO("%s: GET_CONFIG_DESCRIPTOR: id=%d, state=%d\n",
1452 __func__, w_value_lo, udc.state);
1453 if (usb_get_configuration_descriptor(w_value_lo) < 0)
1454 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1457 LOG_INFO("%s: GET_STRING_DESCRIPTOR: id=%d, state=%d\n",
1458 __func__, w_value_lo, udc.state);
1459 if (usb_get_string_descriptor(w_value_lo) < 0)
1460 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1463 LOG_WARN("%s: GET_UNKNOWN_DESCRIPTOR: id=%d, state=%d\n",
1464 __func__, w_value_lo, udc.state);
1465 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1470 /* USB setup packet: class/vendor request handler */
1471 static void usb_event_handler(UsbDevice *dev)
1474 * TODO: get the appropriate usb_dev in function of the endpoint
1478 dev->event_cb(&setup_packet);
1481 /* USB setup packet: GET_DESCRIPTOR handler */
1482 static void usb_get_descriptor_handler(void)
1484 LOG_INFO("%s: GET_DESCRIPTOR: RECIP = %d\n",
1486 setup_packet.mRequestType & USB_RECIP_MASK);
1487 if ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1489 usb_get_descriptor();
1490 /* Getting descriptor for a device is a standard request */
1491 else if ((setup_packet.mRequestType & USB_DIR_MASK) == USB_DIR_IN)
1492 usb_event_handler(usb_dev);
1494 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1497 /* USB setup packet: SET_ADDRESS handler */
1498 static void usb_set_address_handler(void)
1500 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1501 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1502 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1504 LOG_INFO("%s: SET_ADDRESS: %d\n",
1505 __func__, usb_le16_to_cpu(setup_packet.wValue));
1506 if ((udc.state >= USB_STATE_DEFAULT) &&
1507 ((setup_packet.mRequestType & USB_RECIP_MASK) ==
1508 USB_RECIP_DEVICE) &&
1509 (w_index == 0) && (w_length == 0) && (w_value < 128))
1510 usb_status_handler(CTRL_ENP_IN);
1512 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1515 /* USB setup packet: GET_CONFIGURATION handler */
1516 static void usb_get_config_handler(void)
1518 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1519 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1521 LOG_INFO("%s: GET_CONFIGURATION\n", __func__);
1522 if ((udc.state >= USB_STATE_ADDRESS) &&
1523 (w_value == 0) && (w_index == 0) && (w_value == 1))
1525 InData = udc.cfg_id;
1526 __usb_ep_write(CTRL_ENP_IN, (uint8_t *)&InData, 1, usb_status_handler);
1529 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1532 static const UsbConfigDesc *usb_find_configuration(int num)
1534 const UsbConfigDesc *cfg;
1539 cfg = (const UsbConfigDesc *)usb_dev->config[i];
1542 if (cfg->bDescriptorType != USB_DT_CONFIG)
1544 if (cfg->bConfigurationValue == num)
1550 static int usb_set_config_state(uint32_t conf)
1552 const UsbConfigDesc *pCnfg;
1557 /* Find configuration descriptor */
1558 pCnfg = usb_find_configuration(conf);
1560 return -USB_NODEV_ERROR;
1562 /* Reset current configuration */
1563 usb_set_device_state(USB_STATE_ADDRESS);
1564 usb_dev->configured = false;
1567 /* Set Interface and Alternative Setting */
1569 /* Set self-powered state */
1570 if (pCnfg->bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1571 udc.feature |= STM32_UDC_FEATURE_SELFPOWERED;
1573 /* Configure all existing interfaces to alternative setting 0 */
1574 ASSERT(pCnfg->bNumInterfaces <= USB_MAX_INTERFACE);
1575 udc.interfaces = pCnfg->bNumInterfaces;
1576 for (i = 0; i < udc.interfaces; i++)
1578 usb_set_device_state(USB_STATE_CONFIGURED);
1579 usb_dev->configured = true;
1580 LOG_INFO("%s: device configured\n", __func__);
1584 usb_dev->configured = false;
1585 usb_set_device_state(USB_STATE_ADDRESS);
1590 /* USB setup packet: SET_CONFIGURATION handler */
1591 static void usb_set_config_handler(void)
1593 uint16_t w_value = usb_le16_to_cpu(setup_packet.wValue);
1594 uint16_t w_index = usb_le16_to_cpu(setup_packet.wIndex);
1595 uint16_t w_length = usb_le16_to_cpu(setup_packet.wLength);
1597 LOG_INFO("%s: SET_CONFIGURATION: %d\n",
1599 if ((udc.state >= USB_STATE_ADDRESS) &&
1600 (w_index == 0) && (w_length == 0) &&
1601 (usb_set_config_state(w_value & 0xff) == 0))
1602 usb_status_handler(CTRL_ENP_OUT);
1604 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1607 /* USB setup packet: standard request handler */
1608 static void usb_standard_request_handler(void)
1610 switch (setup_packet.bRequest)
1612 case USB_REQ_GET_STATUS:
1613 usb_get_status_handler();
1615 case USB_REQ_CLEAR_FEATURE:
1616 LOG_INFO("%s: bRequest=%d (CLEAR_FEATURE)\n",
1617 __func__, setup_packet.bRequest);
1619 case USB_REQ_SET_FEATURE:
1620 LOG_INFO("%s: bRequest=%d (SET_FEATURE)\n",
1621 __func__, setup_packet.bRequest);
1623 case USB_REQ_SET_ADDRESS:
1624 usb_set_address_handler();
1626 case USB_REQ_GET_DESCRIPTOR:
1627 usb_get_descriptor_handler();
1629 case USB_REQ_SET_DESCRIPTOR:
1630 LOG_INFO("%s: bRequest=%d (SET_DESCRIPTOR)\n",
1631 __func__, setup_packet.bRequest);
1633 case USB_REQ_GET_CONFIGURATION:
1634 usb_get_config_handler();
1636 case USB_REQ_SET_CONFIGURATION:
1637 usb_set_config_handler();
1639 case USB_REQ_GET_INTERFACE:
1640 LOG_INFO("%s: bRequest=%d (GET_INTERFACE)\n",
1641 __func__, setup_packet.bRequest);
1643 case USB_REQ_SET_INTERFACE:
1644 LOG_INFO("%s: bRequest=%d (SET_INTERFACE)\n",
1645 __func__, setup_packet.bRequest);
1647 case USB_REQ_SYNCH_FRAME:
1648 LOG_INFO("%s: bRequest=%d (SYNCH_FRAME)\n",
1649 __func__, setup_packet.bRequest);
1652 LOG_WARN("%s: bRequest=%d (Unknown)\n",
1653 __func__, setup_packet.bRequest);
1654 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1659 /* USB setup packet handler */
1660 static void usb_setup_handler(void)
1662 switch (setup_packet.mRequestType & USB_TYPE_MASK)
1665 case USB_TYPE_STANDARD:
1666 LOG_INFO("%s: bmRequestType=%02x (Standard)\n",
1667 __func__, setup_packet.mRequestType);
1668 usb_standard_request_handler();
1671 case USB_TYPE_CLASS:
1672 LOG_INFO("%s: bmRequestType=%02x (Class)\n",
1673 __func__, setup_packet.mRequestType);
1674 usb_event_handler(usb_dev);
1677 case USB_TYPE_VENDOR:
1678 LOG_INFO("%s: bmRequestType=%02x (Vendor)\n",
1679 __func__, setup_packet.mRequestType);
1680 usb_event_handler(usb_dev);
1682 case USB_TYPE_RESERVED:
1683 LOG_INFO("%s: bmRequestType=%02x (Reserved)\n",
1684 __func__, setup_packet.mRequestType);
1688 LOG_WARN("%s: bmRequestType=%02x (Unknown)\n",
1689 __func__, setup_packet.mRequestType);
1690 ep_cnfg[CTRL_ENP_OUT].status = STALLED;
1695 /* USB: low-level hardware initialization */
1696 static void usb_hw_reset(void)
1701 /* Initialize endpoint descriptors */
1702 for (i = 0; i < countof(ep_cnfg); i++)
1703 ep_cnfg[i].hw = NULL;
1705 /* Initialize USB memory */
1706 for (i = 0; i < countof(memory_buffer); i++)
1707 memory_buffer[i].Size = 0;
1708 usb->BTABLE = USB_BDT_OFFSET;
1711 /* Endpoint initialization */
1712 ret = usb_ep_configure(&USB_CtrlEpDescr0, true);
1713 if (UNLIKELY(ret < 0))
1715 LOG_WARN("%s: out of memory, cannot initialize EP0\n",
1719 ret = usb_ep_configure(&USB_CtrlEpDescr1, true);
1720 if (UNLIKELY(ret < 0))
1722 LOG_WARN("%s: out of memory, cannot initialize EP1\n",
1727 /* Set default address */
1730 /* Enable all the device interrupts */
1731 usb->CNTR = bmCTRM | bmRESETM | bmSOFM | bmERRM | bmPMAOVRM |
1735 /* Handle a correct transfer under ISR */
1736 static void usb_isr_correct_transfer(stm32_usb_irq_status_t interrupt)
1739 reg32_t *pReg = (reg32_t *)&usb->EP0R;
1741 /* Find corresponding EP */
1742 pReg += interrupt.EP_ID;
1743 EP = (int)(((*pReg & 0x0f) << 1) + (interrupt.DIR ? 0 : 1));
1744 ep_cnfg[EP].avail_data = 1;
1746 ASSERT(ep_cnfg[EP].hw);
1749 ep_ctrl_clr_ctr_tx(ep_cnfg[EP].hw);
1751 ep_ctrl_clr_ctr_rx(ep_cnfg[EP].hw);
1752 if (EP == CTRL_ENP_OUT)
1754 /* Determinate type of packet (only for control EP) */
1755 bool SetupPacket = ep_ctrl_get_setup(ep_cnfg[CTRL_ENP_OUT].hw);
1759 ep_cnfg[CTRL_ENP_IN].avail_data = 1;
1760 /* init IO to receive Setup packet */
1761 __usb_ep_write(CTRL_ENP_IN, NULL, -1, NULL);
1762 __usb_ep_read(CTRL_ENP_OUT, &setup_packet,
1763 sizeof(setup_packet), NULL);
1765 /* reset EP IO ctrl */
1766 if (setup_packet.mRequestType & USB_DIR_IN)
1767 usb_status_handler(CTRL_ENP_OUT);
1768 usb_setup_handler();
1769 if (ep_cnfg[CTRL_ENP_OUT].status == STALLED)
1770 usb_ep_set_stall_ctrl();
1774 if (ep_cnfg[CTRL_ENP_OUT].complete &&
1775 setup_packet.mRequestType & USB_DIR_IN)
1776 ep_cnfg[CTRL_ENP_OUT].complete(CTRL_ENP_OUT);
1781 else if (EP == CTRL_ENP_IN)
1783 if (ep_cnfg[CTRL_ENP_IN].complete &&
1784 !(setup_packet.mRequestType & USB_DIR_IN))
1785 ep_cnfg[CTRL_ENP_IN].complete(CTRL_ENP_IN);
1794 /* USB: interrupt service routine */
1795 static void usb_isr(void)
1797 stm32_usb_irq_status_t interrupt;
1799 /* Get masked interrupt flags */
1800 interrupt.status = usb->ISTR;
1801 interrupt.status &= usb->CNTR | 0x1f;
1803 if (interrupt.PMAOVR)
1805 LOG_WARN("%s: DMA overrun / underrun\n", __func__);
1806 usb->ISTR = ~bmPMAOVRM;
1810 LOG_WARN("%s: engine error\n", __func__);
1811 usb->ISTR = ~bmERRM;
1813 if (interrupt.RESET)
1815 LOG_INFO("%s: device reset\n", __func__);
1816 usb->ISTR = ~bmRESETM;
1818 usb_set_device_state(USB_STATE_DEFAULT);
1824 * XXX: disable logging of frame interrupts (too much noise!)
1826 uint16_t frame_nr = usb->FNR & 0x0fff;
1827 LOG_INFO("%s: frame %#x\n", __func__, frame_nr);
1829 usb->ISTR = ~bmSOFM;
1833 LOG_INFO("%s: wake-up\n", __func__);
1834 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1839 LOG_INFO("%s: suspend\n", __func__);
1841 usb->ISTR = ~(bmSUSPM | bmWKUPM);
1845 LOG_INFO("%s: expected frame\n", __func__);
1846 usb->ISTR = ~bmESOFM;
1850 usb_isr_correct_transfer(interrupt);
1854 /* USB: hardware initialization */
1855 static void usb_hw_init(void)
1857 /* Enable clocking on the required GPIO pins */
1858 RCC->APB2ENR |= RCC_APB2_GPIOA | RCC_APB2_GPIOC;
1860 /* Make sure that the CAN controller is disabled and held in reset */
1861 RCC->APB1ENR &= ~RCC_APB1_CAN;
1863 /* Configure USB_DM and USB_DP to work as USB lines */
1864 stm32_gpioPinConfig((struct stm32_gpio *)GPIOA_BASE,
1865 USB_DM_PIN | USB_DP_PIN,
1866 GPIO_MODE_AF_PP, GPIO_SPEED_50MHZ);
1867 /* Configure USB_DISC to work as USB disconnect */
1868 stm32_gpioPinConfig((struct stm32_gpio *)GPIOC_BASE,
1870 GPIO_MODE_OUT_PP, GPIO_SPEED_50MHZ);
1871 stm32_gpioPinWrite((struct stm32_gpio *)GPIOC_BASE,
1874 /* Ensure the USB clock is disabled before setting the prescaler */
1875 RCC->APB1ENR &= ~RCC_APB1_USB;
1877 /* Configure USB clock (48MHz) */
1878 *CFGR_USBPRE_BB &= ~RCC_USBCLK_PLLCLK_1DIV5;
1880 /* Activate USB clock */
1881 RCC->APB1ENR |= RCC_APB1_USB;
1883 /* Force USB reset and disable USB interrupts */
1887 /* Issue a USB reset */
1890 /* Clear spurious pending interrupt */
1893 /* Register interrupt handler */
1894 sysirq_setHandler(USB_LP_CAN_RX0_IRQHANDLER, usb_isr);
1896 /* Software connection enable */
1900 /* Initialize the USB controller */
1901 static void usb_init(void)
1903 udc.state = USB_STATE_NOTATTACHED;
1909 /* Register an upper layer USB device into the driver */
1910 int usb_deviceRegister(UsbDevice *dev)
1917 while (!usb_dev->configured)