Src/usb.c

   1 #include "stm32f1xx.h"
   2 #include "stm32f1xx_hal.h"
   3
   4 #include "util.h"
   5 #include "usb.h"
   6
   7 #include <string.h>
   8
   9 void _Error_Handler(char * file, int line);     // FIXME
  10
  11 #define DESC_U16(x) ((x) & 0xff), ((x) >> 8)
  12
  13 enum desc_string {
  14   DESC_STR_NONE = 0,
  15   DESC_STR_MANUFACTURER,
  16   DESC_STR_PRODUCT,
  17   DESC_STR_SERIAL,
  18   DESC_STR_CONFIGURATION,
  19   DESC_STR_INTERFACE,
  20 };
  21
  22 static const byte desc_device[] = {
  23   18,                           // bLength
  24   USB_DESC_TYPE_DEVICE,         // bDescriptorType
  25   DESC_U16(0x0200),             // bcdUSB
  26   0x00,                         // bDeviceClass
  27   0x00,                         // bDeviceSubClass
  28   0x00,                         // bDeviceProtocol
  29   USB_MAX_EP0_SIZE,             // bMaxPacketSize
  30   DESC_U16(0x4242),             // idVendor
  31   DESC_U16(0x0001),             // idProduct
  32   DESC_U16(0x0200),             // bcdDevice
  33   DESC_STR_MANUFACTURER,        // iManufacturer
  34   DESC_STR_PRODUCT,             // iProduct
  35   DESC_STR_SERIAL,              // iSerialNumber
  36   USB_NUM_CONFIGURATIONS,       // bNumConfigurations
  37 };
  38
  39 static const byte desc_config[] = {
  40   // Configuration descriptor
  41   9,                            // bLength
  42   USB_DESC_TYPE_CONFIGURATION,  // bDescriptorType
  43   32,                           // wTotalLength
  44   0,
  45   0x01,                         // bNumInterfaces
  46   0x01,                         // bConfigurationValue
  47   DESC_STR_CONFIGURATION,       // iConfiguration
  48   0xc0,                         // bmAttributes: bus-powered, supports remote wakeup
  49   0x32,                         // Max power: 100 mA
  50   // Interface descriptor
  51   9,                            // bLength
  52   USB_DESC_TYPE_INTERFACE,      // bDescriptorType
  53   0x00,                         // bInterfaceNumber
  54   0x00,                         // bAlternateSetting
  55   0x01,                         // bNumEndpoints
  56   0xff,                         // bInterfaceClass: vendor-defined
  57   0x00,                         // bInterfaceSubClass
  58   0x00,                         // nInterfaceProtocol
  59   DESC_STR_INTERFACE,           // iInterface
  60   // End-point descriptor
  61   7,                            // bLength
  62   USB_DESC_TYPE_ENDPOINT,       // bDescriptorType
  63   0x01,                         // bEndpointAddress
  64   USB_EP_TYPE_BULK,             // bmAttributes
  65   0x40, 0x00,                   // wMaxPacketSize
  66   0x00,                         // bInterval: unused
  67   // End-point descriptor
  68   7,                            // bLength
  69   USB_DESC_TYPE_ENDPOINT,       // bDescriptorType
  70   0x81,                         // bEndpointAddress
  71   USB_EP_TYPE_BULK,             // bmAttributes
  72   0x40, 0x00,                   // wMaxPacketSize
  73   0x00,                         // bInterval: unused
  74 };
  75
  76 static const char * const desc_string[] = {
  77   "",                           // DESC_STR_NONE
  78   "United Computer Wizards",    // DESC_STR_MANUFACTURER
  79   "Mysterious Gadget",          // DESC_STR_PRODUCT
  80   "00000042",                   // DESC_STR_SERIAL
  81   "Default Configuration",      // DESC_STR_CONFIGURATION
  82   "Default Interface",          // DESC_STR_INTERFACE
  83 };
  84
  85 void usb_init(struct usb *usb, PCD_HandleTypeDef *hpcd)
  86 {
  87   memset(usb, 0, sizeof(*usb));
  88   usb->hpcd = hpcd;
  89   usb->state = USB_STATE_DEFAULT;
  90   usb->ep0_state = USB_EP0_IDLE;
  91   hpcd->pData = usb;
  92 }
  93
  94 void usb_start(struct usb *usb)
  95 {
  96   HAL_PCDEx_PMAConfig(usb->hpcd, 0x00, PCD_SNG_BUF, 0x18);
  97   HAL_PCDEx_PMAConfig(usb->hpcd, 0x80, PCD_SNG_BUF, 0x58);
  98
  99   HAL_PCD_Start(usb->hpcd);
 100 }
 101
 102 static inline uint get_u16(byte *p)
 103 {
 104   return (p[1] << 8) | p[0];
 105 }
 106
 107 static inline void put_u16(byte *p, u16 x)
 108 {
 109   p[0] = x;
 110   p[1] = x >> 8;
 111 }
 112
 113 static void usb_ctl_send_status(struct usb *usb)
 114 {
 115   usb_debug("Control send: status\n");
 116   usb->ep0_state = USB_EP0_STATUS_IN;
 117   usb_ep_transmit(usb, 0x00, NULL, 0);
 118 }
 119
 120 #if 0  // FIXME
 121 static void usb_ctl_recv_status(struct usb *usb)
 122 {
 123   usb->ep0_state = USB_EP0_STATUS_OUT;
 124   usb_ep_receive(usb, 0x00, NULL, 0);
 125 }
 126 #endif
 127
 128 static void usb_ctl_send_data(struct usb *usb, const byte *data, uint len)
 129 {
 130   usb_debug("Control send: %u bytes\n", len);
 131   usb->ep0_state = USB_EP0_DATA_IN;
 132   usb->ep0_total_length = len;
 133   usb->ep0_remaining_length = len;
 134   usb_ep_transmit(usb, 0x00, data, len);
 135 }
 136
 137 #if 0  // FIXME
 138 static void usb_ctl_recv_data(struct usb *usb, byte *data, uint len)
 139 {
 140   usb_debug("Control recv: %u bytes\n", len);
 141   usb->ep0_state = USB_EP0_DATA_OUT;
 142   usb->ep0_total_length = len;
 143   usb->ep0_remaining_length = len;
 144   usb_ep_transmit(usb, 0x00, data, len);
 145 }
 146 #endif
 147
 148 static void usb_ctl_send_byte(struct usb *usb, byte data)
 149 {
 150   usb->ep0_buf[0] = data;
 151   usb_ctl_send_data(usb, usb->ep0_buf, 1);
 152 }
 153
 154 static void usb_ctl_send_u16(struct usb *usb, u16 data)
 155 {
 156   put_u16(usb->ep0_buf, data);
 157   usb_ctl_send_data(usb, usb->ep0_buf, 2);
 158 }
 159
 160 static void usb_ctl_error(struct usb *usb)
 161 {
 162   usb_debug("Control packet error\n");
 163   usb_ep_stall(usb, 0x00);
 164   usb_ep_stall(usb, 0x80);
 165 }
 166
 167 struct setup_request {
 168   byte bmRequest;
 169   byte bRequest;
 170   u16 wValue;
 171   u16 wIndex;
 172   u16 wLength;
 173 };
 174
 175 static void usb_ctl_setup_error(struct usb *usb, struct setup_request *setup)
 176 {
 177   usb_debug("Setup packet error\n");
 178   usb_ep_stall(usb, setup->bmRequest & USB_REQ_DIRECTION);
 179 }
 180
 181 static void dev_get_status(struct usb *usb, struct setup_request *setup)
 182 {
 183   if ((usb->state != USB_STATE_ADDRESSED && usb->state != USB_STATE_CONFIGURED) ||
 184       setup->wValue || setup->wIndex || setup->wLength != 2)
 185     return usb_ctl_error(usb);
 186
 187   uint stat = 0;
 188 #ifdef USB_SELF_POWERED
 189   stat |= USB_DEV_STATUS_SELF_POWERED;
 190 #endif
 191   if (usb->remote_wakeup)
 192     stat |= USB_DEV_STATUS_REMOTE_WAKEUP;
 193   usb_ctl_send_u16(usb, stat);
 194 }
 195
 196 static void dev_clear_feature(struct usb *usb, struct setup_request *setup)
 197 {
 198   if (setup->wIndex || setup->wLength)
 199     return usb_ctl_error(usb);
 200
 201   if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
 202     {
 203       usb->remote_wakeup = 0;
 204       usb_ctl_send_status(usb);
 205     }
 206   else
 207     usb_ctl_error(usb);
 208 }
 209
 210 static void dev_set_feature(struct usb *usb, struct setup_request *setup)
 211 {
 212   if (setup->wIndex || setup->wLength)
 213     return usb_ctl_error(usb);
 214
 215   if (setup->wValue == USB_FEATURE_REMOTE_WAKEUP)
 216     {
 217       usb->remote_wakeup = 1;
 218       usb_ctl_send_status(usb);
 219     }
 220   else
 221     usb_ctl_error(usb);
 222 }
 223
 224 static void dev_set_address(struct usb *usb, struct setup_request *setup)
 225 {
 226   if (setup->wIndex || setup->wLength)
 227     return usb_ctl_error(usb);
 228
 229   uint addr = setup->wValue & 0x7f;
 230   if (usb->state == USB_STATE_CONFIGURED)
 231     usb_ctl_error(usb);
 232   else
 233     {
 234       usb->address = addr;
 235       HAL_PCD_SetAddress(usb->hpcd, addr);
 236       usb_ctl_send_status(usb);
 237       usb->state = addr ? USB_STATE_ADDRESSED : USB_STATE_DEFAULT;
 238     }
 239 }
 240
 241 static void dev_desc_send(struct usb *usb, struct setup_request *setup, const byte *desc, uint len)
 242 {
 243   len = MIN(len, setup->wLength);
 244   if (len)
 245     usb_ctl_send_data(usb, desc, len);
 246 }
 247
 248 static void dev_desc_send_string(struct usb *usb, struct setup_request *setup, const char *str)
 249 {
 250   byte *buf = usb->ep0_buf;
 251   uint len = strlen(str);
 252   uint i = 0;
 253
 254   buf[i++] = 2*len + 2;
 255   buf[i++] = USB_DESC_TYPE_STRING;
 256
 257   while (i <= USB_EP0_BUF_SIZE - 2 && *str)
 258     {
 259       buf[i++] = *str++;
 260       buf[i++] = 0;
 261     }
 262
 263   dev_desc_send(usb, setup, buf, i);
 264 }
 265
 266 static void dev_get_descriptor(struct usb *usb, struct setup_request *setup)
 267 {
 268   byte desc_type = setup->wValue >> 8;
 269   byte desc_index = setup->wValue & 0xff;
 270
 271   switch (desc_type)
 272     {
 273     case USB_DESC_TYPE_DEVICE:
 274       return dev_desc_send(usb, setup, desc_device, sizeof(desc_device));
 275     case USB_DESC_TYPE_CONFIGURATION:
 276       return dev_desc_send(usb, setup, desc_config, sizeof(desc_config));
 277     case USB_DESC_TYPE_STRING:
 278       if (desc_index < sizeof(desc_string) / sizeof(desc_string[0]))
 279         return dev_desc_send_string(usb, setup, desc_string[desc_index]);
 280       break;
 281     case USB_DESC_TYPE_DEVICE_QUALIFIER:
 282       // FIXME
 283     case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
 284       // FIXME
 285       // if (usb->hpcd->Init.speed == PCD_SPEED_HIGH)
 286       ;
 287     }
 288
 289   usb_ctl_error(usb);
 290 }
 291
 292 static void dev_get_configuration(struct usb *usb, struct setup_request *setup)
 293 {
 294   if (setup->wValue || setup->wIndex || setup->wLength != 1)
 295     return usb_ctl_error(usb);
 296
 297   switch (usb->state)
 298     {
 299     case USB_STATE_ADDRESSED:
 300       usb_ctl_send_byte(usb, 0);
 301       break;
 302     case USB_STATE_CONFIGURED:
 303       usb_ctl_send_byte(usb, usb->config);
 304       break;
 305     default:
 306       usb_ctl_error(usb);
 307     }
 308 }
 309
 310 static void dev_set_configuration(struct usb *usb, struct setup_request *setup)
 311 {
 312   byte cfg = setup->wValue & 0xff;
 313
 314   // FIXME: Support more configurations
 315   if (cfg > 1 || setup->wIndex || setup->wLength)
 316     return usb_ctl_error(usb);
 317
 318   switch (usb->state)
 319     {
 320     case USB_STATE_ADDRESSED:
 321       if (cfg)
 322         {
 323           usb->config = cfg;
 324           usb->state = USB_STATE_CONFIGURED;
 325           // FIXME: Notify that the device was configured
 326         }
 327       usb_ctl_send_status(usb);
 328       break;
 329     case USB_STATE_CONFIGURED:
 330       if (!cfg)
 331         {
 332           // Unconfiguring
 333           usb->config = 0;
 334           usb->state = USB_STATE_ADDRESSED;
 335           // FIXME: Notify that the device was unconfigured
 336         }
 337       else if (cfg != usb->config)
 338         {
 339           usb->config = cfg;
 340           // FIXME: Notify about configuration change
 341         }
 342       usb_ctl_send_status(usb);
 343       break;
 344     default:
 345       usb_ctl_error(usb);
 346     }
 347 }
 348
 349 static void dev_setup(struct usb *usb, struct setup_request *setup)
 350 {
 351   switch (setup->bRequest)
 352     {
 353     case USB_REQ_GET_STATUS:
 354       return dev_get_status(usb, setup);
 355     case USB_REQ_CLEAR_FEATURE:
 356       return dev_clear_feature(usb, setup);
 357     case USB_REQ_SET_FEATURE:
 358       return dev_set_feature(usb, setup);
 359     case USB_REQ_SET_ADDRESS:
 360       return dev_set_address(usb, setup);
 361     case USB_REQ_GET_DESCRIPTOR:
 362       return dev_get_descriptor(usb, setup);
 363     case USB_REQ_GET_CONFIGURATION:
 364       return dev_get_configuration(usb, setup);
 365     case USB_REQ_SET_CONFIGURATION:
 366       return dev_set_configuration(usb, setup);
 367     }
 368
 369   usb_ctl_setup_error(usb, setup);
 370 }
 371
 372 static void intf_setup(struct usb *usb, struct setup_request *setup)
 373 {
 374   byte intf = setup->wIndex & 0xff;
 375
 376   if (!intf)
 377     {
 378       // FIXME: Support more interfaces
 379       usb_ctl_error(usb);
 380       return;
 381     }
 382
 383   switch (setup->bRequest)
 384     {
 385     case USB_REQ_GET_STATUS:
 386       if (setup->wValue || setup->wLength != 2 || usb->state != USB_STATE_CONFIGURED)
 387         usb_ctl_error(usb);
 388       else
 389         usb_ctl_send_u16(usb, 0);
 390       return;
 391
 392     case USB_REQ_CLEAR_FEATURE:
 393     case USB_REQ_SET_FEATURE:
 394       // Interfaces have no standard features
 395       return usb_ctl_error(usb);
 396     }
 397
 398   usb_ctl_setup_error(usb, setup);
 399 }
 400
 401 static void ep_setup(struct usb *usb, struct setup_request *setup)
 402 {
 403   byte ep_addr = setup->wIndex & 0x8f;
 404
 405   switch (setup->bRequest)
 406     {
 407     case USB_REQ_GET_STATUS:
 408       if (setup->wValue || setup->wLength != 2)
 409         return usb_ctl_error(usb);
 410       switch (usb->state)
 411         {
 412         case USB_STATE_ADDRESSED:
 413           if (ep_addr & 0x7f)
 414             usb_ctl_error(usb);
 415           return;
 416         case USB_STATE_CONFIGURED:
 417           {
 418             if (usb_ep_is_stalled(usb, ep_addr))
 419               usb_ctl_send_u16(usb, 1);
 420             else
 421               usb_ctl_send_u16(usb, 0);
 422             return;
 423           }
 424         default:
 425           return usb_ctl_error(usb);
 426         }
 427       break;
 428
 429     case USB_REQ_SET_FEATURE:
 430       if (setup->wLength)
 431         return usb_ctl_error(usb);
 432       switch (usb->state)
 433         {
 434         case USB_STATE_ADDRESSED:
 435           if (ep_addr & 0x7f)
 436             usb_ctl_error(usb);
 437           return;
 438         case USB_STATE_CONFIGURED:
 439           if (setup->wValue == USB_FEATURE_EP_HALT)
 440             {
 441               if (ep_addr & 0x7f)
 442                 usb_ep_stall(usb, ep_addr);
 443             }
 444           usb_ctl_send_status(usb);
 445           return;
 446         default:
 447           usb_ctl_error(usb);
 448         }
 449       break;
 450
 451     case USB_REQ_CLEAR_FEATURE:
 452       if (setup->wLength)
 453         return usb_ctl_error(usb);
 454       switch (usb->state)
 455         {
 456         case USB_STATE_ADDRESSED:
 457           if (ep_addr & 0x7f)
 458             usb_ctl_error(usb);
 459           return;
 460         case USB_STATE_CONFIGURED:
 461           if (setup->wValue == USB_FEATURE_EP_HALT)
 462             {
 463               if (ep_addr & 0x7f)
 464                 usb_ep_unstall(usb, ep_addr);
 465             }
 466           usb_ctl_send_status(usb);
 467           return;
 468         default:
 469           usb_ctl_error(usb);
 470         }
 471       break;
 472     }
 473
 474   usb_ctl_setup_error(usb, setup);
 475 }
 476
 477 static void usb_handle_setup(struct usb *usb, struct setup_request *setup)
 478 {
 479   usb_debug("Setup: type=%02x req=%02x val=%04x idx=%04x len=%04x\n", setup->bmRequest, setup->bRequest, setup->wValue, setup->wIndex, setup->wLength);
 480
 481   usb->ep0_state = USB_EP0_SETUP;
 482   usb->ep0_setup_data_length = setup->wLength;
 483
 484   if ((setup->bmRequest & USB_REQ_TYPE_MASK) != USB_REQ_TYPE_STANDARD)
 485     {
 486       // FIXME: Class-specific and vendor-specific setup packets not supported
 487       // FIXME: Check USB_STATE_CONFIGURED here
 488       usb_ctl_setup_error(usb, setup);
 489     }
 490
 491   switch (setup->bmRequest & USB_REQ_RECIPIENT_MASK)
 492     {
 493     case USB_REQ_RECIPIENT_DEVICE:
 494       return dev_setup(usb, setup);
 495     case USB_REQ_RECIPIENT_INTERFACE:
 496       return intf_setup(usb, setup);
 497     case USB_REQ_RECIPIENT_ENDPOINT:
 498       return ep_setup(usb, setup);
 499     }
 500
 501   usb_ctl_setup_error(usb, setup);
 502 }
 503
 504 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
 505 {
 506   struct usb *usb = hpcd->pData;
 507   byte *req = (byte *) hpcd->Setup;
 508
 509   struct setup_request setup = {
 510     .bmRequest = req[0],
 511     .bRequest = req[1],
 512     .wValue = get_u16(req+2),
 513     .wIndex = get_u16(req+4),
 514     .wLength = get_u16(req+6),
 515   };
 516   usb_handle_setup(usb, &setup);
 517 }
 518
 519 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 520 {
 521   struct usb *usb = hpcd->pData;
 522   PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
 523
 524   if (!epnum)
 525     {
 526       // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
 527       if (usb->ep0_state != USB_EP0_DATA_OUT)
 528         return;
 529       if (usb->ep0_remaining_length > ep->maxpacket)
 530         {
 531           usb->ep0_remaining_length -= ep->maxpacket;
 532           usb_ep_receive(usb, 0x00, ep->xfer_buff, MIN(usb->ep0_remaining_length, ep->maxpacket));
 533         }
 534       else
 535         {
 536           if (usb->state == USB_STATE_CONFIGURED)
 537             {
 538               // FIXME: Handle incoming control packet
 539             }
 540           usb_ctl_send_status(usb);
 541         }
 542     }
 543   else
 544     {
 545       if (usb->state == USB_STATE_CONFIGURED)
 546         {
 547           // FIXME: Custom data callback
 548         }
 549     }
 550 }
 551
 552 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 553 {
 554   struct usb *usb = hpcd->pData;
 555   PCD_EPTypeDef *ep = &hpcd->IN_ep[epnum];
 556
 557   if (!epnum)
 558     {
 559       // HAL/LL handle EP0 transfers in a completely different way, we have to do many things ourselves
 560       if (usb->ep0_state != USB_EP0_DATA_IN)
 561         return;
 562       if (usb->ep0_remaining_length > ep->maxpacket)
 563         {
 564           usb->ep0_remaining_length -= ep->maxpacket;
 565           usb_ep_transmit(usb, 0x00, ep->xfer_buff, usb->ep0_remaining_length);
 566           usb_ep_receive(usb, 0x00, NULL, 0);
 567         }
 568       else if (usb->ep0_total_length && usb->ep0_total_length % ep->maxpacket == 0 && usb->ep0_total_length < usb->ep0_setup_data_length)
 569         {
 570           /*
 571            *  Each data transfer must be terminated by either a small packet (less than maxpacket)
 572            *  or by reaching the answer size requested in the setup packet. Send an empty final packet
 573            *  if needed.
 574            */
 575           usb_ep_transmit(usb, 0x00, NULL, 0);
 576           usb->ep0_setup_data_length = 0;
 577           usb_ep_receive(usb, 0x00, NULL, 0);
 578         }
 579       else
 580         {
 581           if (usb->state == USB_STATE_CONFIGURED)
 582             {
 583               // FIXME: Custom data callback
 584               // All data have been sent
 585             }
 586         }
 587     }
 588   else
 589     {
 590       if (usb->state == USB_STATE_CONFIGURED)
 591         {
 592           // FIXME: Custom data callback
 593           // This gets called when a complete message is sent
 594         }
 595     }
 596 }
 597
 598 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
 599 {
 600   // We are not interested in Start of frame packets
 601   // (neither we set hpcd->Init.Sof_enable, so this callback does not get called)
 602 }
 603
 604 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
 605 {
 606   struct usb *usb = hpcd->pData;
 607
 608   usb->state = USB_STATE_DEFAULT;
 609
 610   usb_ep_open(usb, 0x00, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
 611   usb_ep_open(usb, 0x80, USB_EP_TYPE_CTRL, USB_MAX_EP0_SIZE);
 612 }
 613
 614 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
 615 {
 616   struct usb *usb = hpcd->pData;
 617
 618   usb->pre_suspend_state = usb->state;
 619   usb->state = USB_STATE_SUSPENDED;
 620
 621   if (hpcd->Init.low_power_enable)
 622     SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
 623 }
 624
 625 void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
 626 {
 627   struct usb *usb = hpcd->pData;
 628   usb->state = usb->pre_suspend_state;
 629 }
 630
 631 void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 632 {
 633   // We do not support isochronous mode
 634 }
 635
 636 void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
 637 {
 638   // We do not support isochronous mode
 639 }
 640
 641 void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
 642 {
 643 }
 644
 645 void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
 646 {
 647   struct usb *usb = hpcd->pData;
 648   usb->state = USB_STATE_DEFAULT;
 649 }