src/main.c

   1 /*
   2  * main.c - main routine of neug
   3  *
   4  * Main routine:
   5  * Copyright (C) 2011, 2012 Free Software Initiative of Japan
   6  * Author: NIIBE Yutaka <gniibe@fsij.org>
   7  *
   8  * This file is a part of NeuG, a Random Number Generator
   9  * implementation.
  10  *
  11  * NeuG is free software: you can redistribute it and/or modify it
  12  * under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 3 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  18  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  19  * License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "ch.h"
  28 #include "hal.h"
  29 #include "board.h"
  30 #include "neug.h"
  31 #include "usb_lld.h"
  32 #include "sys.h"
  33
  34 /*
  35  * We are trying to avoid dependency to C library.
  36  * GCC built-in function(s) are declared here.
  37  */
  38 extern void *memcpy(void *dest, const void *src, size_t n);
  39 extern void *memset (void *s, int c, size_t n);
  40
  41 static Thread *main_thread = NULL;
  42
  43 \f
  44 #define ENDP0_RXADDR        (0x40)
  45 #define ENDP0_TXADDR        (0x80)
  46 #define ENDP1_TXADDR        (0xc0)
  47 #define ENDP2_TXADDR        (0x100)
  48 #define ENDP3_RXADDR        (0x140)
  49
  50 #define USB_CDC_REQ_SET_LINE_CODING             0x20
  51 #define USB_CDC_REQ_GET_LINE_CODING             0x21
  52 #define USB_CDC_REQ_SET_CONTROL_LINE_STATE      0x22
  53 #define USB_CDC_REQ_SEND_BREAK                  0x23
  54
  55 /* USB Device Descriptor */
  56 static const uint8_t vcom_device_desc[18] = {
  57   18,   /* bLength */
  58   USB_DEVICE_DESCRIPTOR_TYPE,   /* bDescriptorType */
  59   0x10, 0x01,                   /* bcdUSB = 1.1 */
  60   0x02,                         /* bDeviceClass (CDC).              */
  61   0x00,                         /* bDeviceSubClass.                 */
  62   0x00,                         /* bDeviceProtocol.                 */
  63   0x40,                         /* bMaxPacketSize.                  */
  64 #include "usb-vid-pid-ver.c.inc"
  65   1,                            /* iManufacturer.                   */
  66   2,                            /* iProduct.                        */
  67   3,                            /* iSerialNumber.                   */
  68   1                             /* bNumConfigurations.              */
  69 };
  70
  71 /* Configuration Descriptor tree for a CDC.*/
  72 static const uint8_t vcom_configuration_desc[67] = {
  73   9,
  74   USB_CONFIGURATION_DESCRIPTOR_TYPE, /* bDescriptorType: Configuration */
  75   /* Configuration Descriptor.*/
  76   67, 0x00,                     /* wTotalLength.                    */
  77   0x02,                         /* bNumInterfaces.                  */
  78   0x01,                         /* bConfigurationValue.             */
  79   0,                            /* iConfiguration.                  */
  80   0x80,                         /* bmAttributes (bus powered).      */
  81   50,                           /* bMaxPower (100mA).               */
  82   /* Interface Descriptor.*/
  83   9,
  84   USB_INTERFACE_DESCRIPTOR_TYPE,
  85   0x00,            /* bInterfaceNumber.                */
  86   0x00,            /* bAlternateSetting.               */
  87   0x01,            /* bNumEndpoints.                   */
  88   0x02,            /* bInterfaceClass (Communications Interface Class,
  89                       CDC section 4.2).  */
  90   0x02,            /* bInterfaceSubClass (Abstract Control Model, CDC
  91                       section 4.3).  */
  92   0x01,            /* bInterfaceProtocol (AT commands, CDC section
  93                       4.4).  */
  94   0,               /* iInterface.                      */
  95   /* Header Functional Descriptor (CDC section 5.2.3).*/
  96   5,          /* bLength.                         */
  97   0x24,       /* bDescriptorType (CS_INTERFACE).  */
  98   0x00,       /* bDescriptorSubtype (Header Functional Descriptor). */
  99   0x10, 0x01, /* bcdCDC.                          */
 100   /* Call Management Functional Descriptor. */
 101   5,            /* bFunctionLength.                 */
 102   0x24,         /* bDescriptorType (CS_INTERFACE).  */
 103   0x01,         /* bDescriptorSubtype (Call Management Functional
 104                    Descriptor). */
 105   0x03,         /* bmCapabilities (D0+D1).          */
 106   0x01,         /* bDataInterface.                  */
 107   /* ACM Functional Descriptor.*/
 108   4,            /* bFunctionLength.                 */
 109   0x24,         /* bDescriptorType (CS_INTERFACE).  */
 110   0x02,         /* bDescriptorSubtype (Abstract Control Management
 111                    Descriptor).  */
 112   0x02,         /* bmCapabilities.                  */
 113   /* Union Functional Descriptor.*/
 114   5,            /* bFunctionLength.                 */
 115   0x24,         /* bDescriptorType (CS_INTERFACE).  */
 116   0x06,         /* bDescriptorSubtype (Union Functional
 117                    Descriptor).  */
 118   0x00,         /* bMasterInterface (Communication Class
 119                    Interface).  */
 120   0x01,         /* bSlaveInterface0 (Data Class Interface).  */
 121   /* Endpoint 2 Descriptor.*/
 122   7,
 123   USB_ENDPOINT_DESCRIPTOR_TYPE,
 124   ENDP2|0x80,    /* bEndpointAddress.    */
 125   0x03,          /* bmAttributes (Interrupt).        */
 126   0x08, 0x00,    /* wMaxPacketSize.                  */
 127   0xFF,          /* bInterval.                       */
 128   /* Interface Descriptor.*/
 129   9,
 130   USB_INTERFACE_DESCRIPTOR_TYPE, /* bDescriptorType: */
 131   0x01,          /* bInterfaceNumber.                */
 132   0x00,          /* bAlternateSetting.               */
 133   0x02,          /* bNumEndpoints.                   */
 134   0x0A,          /* bInterfaceClass (Data Class Interface, CDC section 4.5). */
 135   0x00,          /* bInterfaceSubClass (CDC section 4.6). */
 136   0x00,          /* bInterfaceProtocol (CDC section 4.7). */
 137   0x00,          /* iInterface.                      */
 138   /* Endpoint 3 Descriptor.*/
 139   7,
 140   USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType: Endpoint */
 141   ENDP3,    /* bEndpointAddress. */
 142   0x02,                         /* bmAttributes (Bulk).             */
 143   0x40, 0x00,                   /* wMaxPacketSize.                  */
 144   0x00,                         /* bInterval.                       */
 145   /* Endpoint 1 Descriptor.*/
 146   7,
 147   USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType: Endpoint */
 148   ENDP1|0x80,                   /* bEndpointAddress. */
 149   0x02,                         /* bmAttributes (Bulk).             */
 150   0x40, 0x00,                   /* wMaxPacketSize.                  */
 151   0x00                          /* bInterval.                       */
 152 };
 153
 154
 155 /*
 156  * U.S. English language identifier.
 157  */
 158 static const uint8_t vcom_string0[4] = {
 159   4,                            /* bLength */
 160   USB_STRING_DESCRIPTOR_TYPE,
 161   0x09, 0x04                    /* LangID = 0x0409: US-English */
 162 };
 163
 164 #define USB_STRINGS_FOR_NEUG 1
 165 #include "usb-strings.c.inc"
 166
 167 /*
 168  * Serial Number string.  NOTE: This does not have CONST qualifier.
 169  */
 170 static uint8_t vcom_string3[28] = {
 171   28,                    /* bLength.                         */
 172   USB_STRING_DESCRIPTOR_TYPE, /* bDescriptorType.                 */
 173   '0', 0,  '.', 0,  '0', 0, '2', 0,    /* Version number of NeuG.          */
 174   '-', 0,
 175   0, 0, 0, 0,   /* Filled by Unique device ID.      */
 176   0, 0, 0, 0,
 177   0, 0, 0, 0,
 178   0, 0, 0, 0,
 179 };
 180
 181 static const struct Descriptor device_desc = {
 182   vcom_device_desc,
 183   sizeof (vcom_device_desc)
 184 };
 185
 186 static const struct Descriptor config_desc = {
 187   vcom_configuration_desc,
 188   sizeof (vcom_configuration_desc)
 189 };
 190
 191 static const struct Descriptor string_descs[] = {
 192   {vcom_string0, sizeof vcom_string0},
 193   {neug_string_vendor, sizeof (neug_string_vendor)},
 194   {neug_string_product, sizeof (neug_string_product)},
 195   {vcom_string3, sizeof (vcom_string3)},
 196   {neug_revision_detail, sizeof (neug_revision_detail)},
 197   {neug_config_options, sizeof (neug_config_options)},
 198   {sys_version, sizeof (sys_version)},
 199 };
 200
 201 #define NUM_STRING_DESC (sizeof (string_descs)/sizeof (struct Descriptor))
 202
 203 #define NUM_INTERFACES 2
 204
 205 uint32_t bDeviceState = UNCONNECTED; /* USB device status */
 206
 207
 208 static void
 209 neug_device_reset (void)
 210 {
 211   /* Set DEVICE as not configured */
 212   usb_lld_set_configuration (0);
 213
 214   /* Current Feature initialization */
 215   usb_lld_set_feature (config_desc.Descriptor[7]);
 216
 217   usb_lld_reset ();
 218
 219   /* Initialize Endpoint 0 */
 220   usb_lld_setup_endpoint (ENDP0, EP_CONTROL, 0, ENDP0_RXADDR, ENDP0_TXADDR, 64);
 221 }
 222
 223 extern uint8_t _regnual_start, __heap_end__;
 224
 225 static const uint8_t *const mem_info[] = { &_regnual_start,  &__heap_end__, };
 226
 227 #define USB_FSIJ_MEMINFO  0
 228 #define USB_FSIJ_DOWNLOAD 1
 229 #define USB_FSIJ_EXEC     2
 230 #define USB_NEUG_EXIT   255     /* exit and receive reGNUal */
 231
 232 enum {
 233   FSIJ_DEVICE_RUNNING = 0,
 234   FSIJ_DEVICE_EXITED,
 235   FSIJ_DEVICE_EXEC_REQUESTED,
 236   /**/
 237   FSIJ_DEVICE_NEUG_EXIT_REQUESTED = 255
 238 };
 239
 240 static uint8_t fsij_device_state = FSIJ_DEVICE_RUNNING;
 241
 242 static uint32_t rbit (uint32_t v)
 243 {
 244   uint32_t r;
 245
 246   asm ("rbit    %0, %1" : "=r" (r) : "r" (v));
 247   return r;
 248 }
 249
 250 /* After calling this function, CRC module remain enabled.  */
 251 static int download_check_crc32 (const uint32_t *end_p)
 252 {
 253   uint32_t crc32 = *end_p;
 254   const uint32_t *p;
 255
 256   RCC->AHBENR |= RCC_AHBENR_CRCEN;
 257   CRC->CR = CRC_CR_RESET;
 258
 259   for (p = (const uint32_t *)&_regnual_start; p < end_p; p++)
 260     CRC->DR = rbit (*p);
 261
 262   if ((rbit (CRC->DR) ^ crc32) == 0xffffffff)
 263     return USB_SUCCESS;
 264
 265   return USB_UNSUPPORT;
 266 }
 267
 268 static void neug_ctrl_write_finish (uint8_t req, uint8_t req_no,
 269                                     uint16_t value, uint16_t index,
 270                                     uint16_t len)
 271 {
 272   uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT);
 273
 274   if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT)
 275       && USB_SETUP_SET (req) && req_no == USB_FSIJ_EXEC && len == 0)
 276     {
 277       if (fsij_device_state != FSIJ_DEVICE_EXITED)
 278         return;
 279
 280       (void)value; (void)index;
 281       usb_lld_prepare_shutdown (); /* No further USB communication */
 282       fsij_device_state = FSIJ_DEVICE_EXEC_REQUESTED;
 283     }
 284 }
 285
 286 struct line_coding
 287 {
 288   uint32_t bitrate;
 289   uint8_t format;
 290   uint8_t paritytype;
 291   uint8_t datatype;
 292 };
 293
 294 static struct line_coding line_coding = {
 295   115200, /* baud rate: 115200    */
 296   0x00,   /* stop bits: 1         */
 297   0x00,   /* parity:    none      */
 298   0x08    /* bits:      8         */
 299 };
 300
 301 static uint8_t connected;
 302
 303 static int
 304 vcom_port_data_setup (uint8_t req, uint8_t req_no, uint16_t value)
 305 {
 306   if (USB_SETUP_GET (req))
 307     {
 308       if (req_no == USB_CDC_REQ_GET_LINE_CODING)
 309         {
 310           usb_lld_set_data_to_send (&line_coding, sizeof(line_coding));
 311           return USB_SUCCESS;
 312         }
 313     }
 314   else  /* USB_SETUP_SET (req) */
 315     {
 316       if (req_no == USB_CDC_REQ_SET_LINE_CODING)
 317         {
 318           usb_lld_set_data_to_recv (&line_coding, sizeof(line_coding));
 319           return USB_SUCCESS;
 320         }
 321       else if (req_no == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
 322         {
 323           if (value != 0)
 324             {
 325               if ((connected & 1) == 0)
 326                 /* It's Open call */
 327                 connected++;
 328             }
 329           else
 330             /* Close call */
 331             connected++;
 332
 333           return USB_SUCCESS;
 334         }
 335     }
 336
 337   return USB_UNSUPPORT;
 338 }
 339
 340 static int
 341 neug_setup (uint8_t req, uint8_t req_no,
 342                uint16_t value, uint16_t index, uint16_t len)
 343 {
 344   uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT);
 345
 346   if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT))
 347     {
 348       if (USB_SETUP_GET (req))
 349         {
 350           if (req_no == USB_FSIJ_MEMINFO)
 351             {
 352               usb_lld_set_data_to_send (mem_info, sizeof (mem_info));
 353               return USB_SUCCESS;
 354             }
 355         }
 356       else /* SETUP_SET */
 357         {
 358           uint8_t *addr = (uint8_t *)(0x20000000 + value * 0x100 + index);
 359
 360           if (req_no == USB_FSIJ_DOWNLOAD)
 361             {
 362               if (fsij_device_state != FSIJ_DEVICE_EXITED)
 363                 return USB_UNSUPPORT;
 364
 365               if (addr < &_regnual_start || addr + len > &__heap_end__)
 366                 return USB_UNSUPPORT;
 367
 368               if (index + len < 256)
 369                 memset (addr + index + len, 0, 256 - (index + len));
 370
 371               usb_lld_set_data_to_recv (addr, len);
 372               return USB_SUCCESS;
 373             }
 374           else if (req_no == USB_FSIJ_EXEC && len == 0)
 375             {
 376               if (fsij_device_state != FSIJ_DEVICE_EXITED)
 377                 return USB_UNSUPPORT;
 378
 379               if (((uint32_t)addr & 0x03))
 380                 return USB_UNSUPPORT;
 381
 382               return download_check_crc32 ((uint32_t *)addr);
 383             }
 384           else if (req_no == USB_NEUG_EXIT && len == 0)
 385             {
 386               if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 387                 return USB_UNSUPPORT;
 388
 389               fsij_device_state = FSIJ_DEVICE_NEUG_EXIT_REQUESTED;
 390               chEvtSignalFlagsI (main_thread, 1);
 391               chSchReadyI (main_thread);
 392               return USB_SUCCESS;
 393             }
 394         }
 395     }
 396   else if (type_rcp == (CLASS_REQUEST | INTERFACE_RECIPIENT))
 397     if (index == 0)
 398       return vcom_port_data_setup (req, req_no, value);
 399
 400   return USB_UNSUPPORT;
 401 }
 402
 403 static int
 404 neug_get_descriptor (uint8_t desc_type, uint16_t index, uint16_t value)
 405 {
 406   (void)index;
 407   if (desc_type == DEVICE_DESCRIPTOR)
 408     {
 409       usb_lld_set_data_to_send (device_desc.Descriptor,
 410                                 device_desc.Descriptor_Size);
 411       return USB_SUCCESS;
 412     }
 413   else if (desc_type == CONFIG_DESCRIPTOR)
 414     {
 415       usb_lld_set_data_to_send (config_desc.Descriptor,
 416                                 config_desc.Descriptor_Size);
 417       return USB_SUCCESS;
 418     }
 419   else if (desc_type == STRING_DESCRIPTOR)
 420     {
 421       uint8_t desc_index = value & 0xff;
 422
 423       if (desc_index < NUM_STRING_DESC)
 424         {
 425           usb_lld_set_data_to_send (string_descs[desc_index].Descriptor,
 426                                     string_descs[desc_index].Descriptor_Size);
 427           return USB_SUCCESS;
 428         }
 429     }
 430
 431   return USB_UNSUPPORT;
 432 }
 433
 434 static void
 435 neug_setup_endpoints_for_interface (uint16_t interface, int stop)
 436 {
 437   if (interface == 0)
 438     {
 439       if (!stop)
 440         usb_lld_setup_endpoint (ENDP2, EP_INTERRUPT, 0, 0, ENDP2_TXADDR, 0);
 441       else
 442         usb_lld_stall_tx (ENDP2);
 443     }
 444   else if (interface == 1)
 445     {
 446       if (!stop)
 447         {
 448           usb_lld_setup_endpoint (ENDP1, EP_BULK, 0, 0, ENDP1_TXADDR, 0);
 449           usb_lld_setup_endpoint (ENDP3, EP_BULK, 0, ENDP3_RXADDR, 0, 64);
 450         }
 451       else
 452         {
 453           usb_lld_stall_tx (ENDP1);
 454           usb_lld_stall_rx (ENDP3);
 455         }
 456     }
 457 }
 458
 459 static int neug_usb_event (uint8_t event_type, uint16_t value)
 460 {
 461   int i;
 462   uint8_t current_conf;
 463
 464   switch (event_type)
 465     {
 466     case USB_EVENT_ADDRESS:
 467       bDeviceState = ADDRESSED;
 468       return USB_SUCCESS;
 469     case USB_EVENT_CONFIG:
 470       current_conf = usb_lld_current_configuration ();
 471       if (current_conf == 0)
 472         {
 473           if (value != 1)
 474             return USB_UNSUPPORT;
 475
 476           usb_lld_set_configuration (1);
 477           for (i = 0; i < NUM_INTERFACES; i++)
 478             neug_setup_endpoints_for_interface (i, 0);
 479           bDeviceState = CONFIGURED;
 480         }
 481       else if (current_conf != value)
 482         {
 483           if (value != 0)
 484             return USB_UNSUPPORT;
 485
 486           usb_lld_set_configuration (0);
 487           for (i = 0; i < NUM_INTERFACES; i++)
 488             neug_setup_endpoints_for_interface (i, 1);
 489           bDeviceState = ADDRESSED;
 490         }
 491       /* Do nothing when current_conf == value */
 492       return USB_SUCCESS;
 493
 494       return USB_SUCCESS;
 495     default:
 496       break;
 497     }
 498
 499   return USB_UNSUPPORT;
 500 }
 501
 502
 503 static int neug_interface (uint8_t cmd, uint16_t interface, uint16_t alt)
 504 {
 505   static uint8_t zero = 0;
 506
 507   if (interface >= NUM_INTERFACES)
 508     return USB_UNSUPPORT;
 509
 510   switch (cmd)
 511     {
 512     case USB_SET_INTERFACE:
 513       if (alt != 0)
 514         return USB_UNSUPPORT;
 515       else
 516         {
 517           neug_setup_endpoints_for_interface (interface, 0);
 518           return USB_SUCCESS;
 519         }
 520
 521     case USB_GET_INTERFACE:
 522       usb_lld_set_data_to_send (&zero, 1);
 523       return USB_SUCCESS;
 524
 525     default:
 526     case USB_QUERY_INTERFACE:
 527       return USB_SUCCESS;
 528     }
 529 }
 530
 531 const struct usb_device_method Device_Method = {
 532   neug_device_reset,
 533   neug_ctrl_write_finish,
 534   neug_setup,
 535   neug_get_descriptor,
 536   neug_usb_event,
 537   neug_interface,
 538 };
 539
 540
 541
 542 static void fill_serial_no_by_unique_id (void)
 543 {
 544   extern const uint8_t * unique_device_id (void);
 545   uint8_t *p = &vcom_string3[12];
 546   const uint8_t *u = unique_device_id ();
 547   int i;
 548
 549   for (i = 0; i < 4; i++)
 550     {
 551       uint8_t b = u[i];
 552       uint8_t nibble;
 553
 554       nibble = (b >> 4);
 555       nibble += (nibble >= 10 ? ('A' - 10) : '0');
 556       p[i*4] = nibble;
 557       nibble = (b & 0x0f);
 558       nibble += (nibble >= 10 ? ('A' - 10) : '0');
 559       p[i*4+2] = nibble;
 560     }
 561 }
 562 \f
 563 CH_IRQ_HANDLER (Vector90)
 564 {
 565   CH_IRQ_PROLOGUE();
 566   chSysLockFromIsr();
 567
 568   usb_interrupt_handler ();
 569
 570   chSysUnlockFromIsr();
 571   CH_IRQ_EPILOGUE();
 572 }
 573
 574 void
 575 EP1_IN_Callback (void)
 576 {
 577   if (main_thread != NULL)
 578     {
 579       chSysLockFromIsr ();
 580       main_thread->p_u.rdymsg = RDY_OK;
 581       chSchReadyI (main_thread);
 582       chSysUnlockFromIsr ();
 583     }
 584 }
 585
 586 void
 587 EP2_IN_Callback (void)
 588 {
 589 }
 590
 591 void
 592 EP3_OUT_Callback (void)
 593 {
 594   usb_lld_rx_enable (ENDP3);
 595 }
 596 \f
 597 static WORKING_AREA(wa_led, 64);
 598
 599 #define LED_ONESHOT_SHORT ((eventmask_t)1)
 600 #define LED_ONESHOT_LONG  ((eventmask_t)2)
 601 static Thread *led_thread;
 602
 603 /*
 604  * LED blinker: When notified, let LED emit for 100ms.
 605  */
 606 static msg_t led_blinker (void *arg)
 607 {
 608   (void)arg;
 609
 610   led_thread = chThdSelf ();
 611   set_led (0);
 612
 613   while (1)
 614     {
 615       eventmask_t m;
 616
 617       m = chEvtWaitOne (ALL_EVENTS);
 618       if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 619         break;
 620
 621       set_led (1);
 622       if (m == LED_ONESHOT_SHORT)
 623         chThdSleep (MS2ST (100));
 624       else
 625         chThdSleep (MS2ST (250));
 626       set_led (0);
 627     }
 628
 629   return 0;
 630 }
 631 \f
 632 #define RANDOM_BYTES_LENGTH 60
 633 static uint32_t random_word[RANDOM_BYTES_LENGTH/sizeof (uint32_t)];
 634
 635 /*
 636  * Entry point.
 637  *
 638  * NOTE: the main function is already a thread in the system on entry.
 639  */
 640 int
 641 main (int argc, char **argv)
 642 {
 643   (void)argc;
 644   (void)argv;
 645
 646   fill_serial_no_by_unique_id ();
 647
 648   halInit();
 649   chSysInit();
 650
 651   main_thread = chThdSelf ();
 652
 653   usb_lld_init (config_desc.Descriptor[7]);
 654
 655   chThdCreateStatic (wa_led, sizeof (wa_led), NORMALPRIO, led_blinker, NULL);
 656
 657   neug_init (random_word, RANDOM_BYTES_LENGTH/sizeof (uint32_t));
 658
 659   while (1)
 660     {
 661       unsigned int count = 0;
 662
 663       if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 664         break;
 665
 666       connected = 0;
 667       while (count < NEUG_PRE_LOOP || bDeviceState != CONFIGURED)
 668         {
 669           if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 670             break;
 671
 672           (void)neug_get (NEUG_KICK_FILLING);
 673           if ((count & 0x000f) == 0)
 674             chEvtSignalFlags (led_thread, LED_ONESHOT_SHORT);
 675           chEvtWaitOneTimeout (ALL_EVENTS, MS2ST (25));
 676           count++;
 677         }
 678
 679     waiting_connection:
 680       while ((connected & 1) == 0)
 681         {
 682           if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 683             break;
 684
 685           neug_flush ();
 686           chEvtSignalFlags (led_thread, LED_ONESHOT_LONG);
 687           chEvtWaitOneTimeout (ALL_EVENTS, MS2ST (2500));
 688         }
 689
 690       /* The connection opened.  */
 691       count = 0;
 692
 693       while (1)
 694         {
 695           if (fsij_device_state != FSIJ_DEVICE_RUNNING)
 696             break;
 697
 698           if ((connected & 1) == 0)
 699             goto waiting_connection;
 700
 701           if (bDeviceState != CONFIGURED)
 702             break;
 703
 704           neug_wait_full ();
 705
 706           if ((count & 0x00ff) == 0)
 707             chEvtSignalFlags (led_thread, LED_ONESHOT_SHORT);
 708
 709           usb_lld_txcpy (random_word, ENDP1, 0, RANDOM_BYTES_LENGTH);
 710           neug_flush ();
 711
 712           chSysLock ();
 713           usb_lld_tx_enable (ENDP1, RANDOM_BYTES_LENGTH);
 714           chSchGoSleepS (THD_STATE_SUSPENDED);
 715           chSysUnlock();
 716
 717           count++;
 718         }
 719     }
 720
 721   /*
 722    * We come here, because of FSIJ_DEVICE_NEUG_EXIT_REQUESTED.
 723    */
 724   neug_fini ();
 725
 726   chEvtSignalFlags (led_thread, LED_ONESHOT_SHORT);
 727   chThdWait (led_thread);
 728
 729   fsij_device_state = FSIJ_DEVICE_EXITED;
 730
 731   while (fsij_device_state == FSIJ_DEVICE_EXITED)
 732     chThdSleep (MS2ST (500));
 733
 734   flash_unlock ();              /* Flash unlock should be done here */
 735   set_led (1);
 736   usb_lld_shutdown ();
 737   /* Disable SysTick */
 738   SysTick->CTRL = 0;
 739   /* Disable all interrupts */
 740   port_disable ();
 741   /* Set vector */
 742   SCB->VTOR = (uint32_t)&_regnual_start;
 743 #ifdef DFU_SUPPORT
 744 #define FLASH_SYS_START_ADDR 0x08000000
 745 #define FLASH_SYS_END_ADDR (0x08000000+0x1000)
 746   {
 747     extern uint8_t _sys;
 748     uint32_t addr;
 749     handler *new_vector = (handler *)FLASH_SYS_START_ADDR;
 750     void (*func) (void (*)(void)) = (void (*)(void (*)(void)))new_vector[10];
 751
 752     /* Kill DFU */
 753     for (addr = FLASH_SYS_START_ADDR; addr < FLASH_SYS_END_ADDR;
 754          addr += FLASH_PAGE_SIZE)
 755       flash_erase_page (addr);
 756
 757     /* copy system service routines */
 758     flash_write (FLASH_SYS_START_ADDR, &_sys, 0x1000);
 759
 760     /* Leave NeuG to exec reGNUal */
 761     (*func) (*((void (**)(void))(&_regnual_start+4)));
 762     for (;;);
 763   }
 764 #else
 765   /* Leave NeuG to exec reGNUal */
 766   flash_erase_all_and_exec (*((void (**)(void))(&_regnual_start+4)));
 767 #endif
 768
 769   /* Never reached */
 770   return 0;
 771 }