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