Version 1.0.9.
[gnuk/neug.git] / src / main.c
1 /*
2  * main.c - main routine of neug
3  *
4  * Main routine:
5  * Copyright (C) 2011, 2012, 2013, 2015, 2016, 2017, 2018
6  *               Free Software Initiative of Japan
7  * Author: NIIBE Yutaka <gniibe@fsij.org>
8  *
9  * This file is a part of NeuG, a True Random Number Generator
10  * implementation.
11  *
12  * NeuG is free software: you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License as published by
14  * the Free Software Foundation, either version 3 of the License, or
15  * (at your option) any later version.
16  *
17  * NeuG is distributed in the hope that it will be useful, but WITHOUT
18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
20  * License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
24  *
25  */
26
27
28 #include <stdint.h>
29 #include <string.h>
30 #include <chopstx.h>
31 #include <eventflag.h>
32
33 #include "config.h"
34 #include "neug.h"
35 #include "usb_lld.h"
36 #include "sys.h"
37 #ifdef GNU_LINUX_EMULATION
38 #include <stdio.h>
39 #include <stdlib.h>
40 #define main emulated_main
41 #else
42 #include "mcu/stm32f103.h"
43 #define FLASH_UPGRADE_SUPPORT 1
44 #endif
45 #include "adc.h"
46
47 #define RANDOM_BYTES_LENGTH 64
48 static uint32_t random_word[RANDOM_BYTES_LENGTH/sizeof (uint32_t)];
49
50 enum {
51   FSIJ_DEVICE_RUNNING = 0,
52   FSIJ_DEVICE_EXITED,
53   FSIJ_DEVICE_EXEC_REQUESTED,
54   /**/
55   FSIJ_DEVICE_NEUG_FRAUCHEKY_REQUESTED = 254,
56   FSIJ_DEVICE_NEUG_EXIT_REQUESTED = 255
57 };
58
59 /*
60  * When Running NeuG:           1
61  * NeuG enabled but Suspend:   -1
62  * No NeuG _and_ not Suspend:   0 
63  */
64 static int8_t running_neug;
65
66 #ifdef FRAUCHEKY_SUPPORT
67 extern void EP6_IN_Callback (uint16_t len);
68 extern void EP6_OUT_Callback (uint16_t len);
69 #endif
70
71 static chopstx_mutex_t usb_mtx;
72 static chopstx_cond_t usb_cnd;
73 static uint32_t bDeviceState = USB_DEVICE_STATE_UNCONNECTED;
74 static uint8_t fsij_device_state = FSIJ_DEVICE_RUNNING;
75 static uint8_t connected;
76
77
78 #define ENDP0_RXADDR        (0x40)
79 #define ENDP0_TXADDR        (0x80)
80 #define ENDP1_TXADDR        (0xc0)
81 #define ENDP2_TXADDR        (0x100)
82 #define ENDP3_RXADDR        (0x10A)
83 /* Next available space for USB is: 0x14A */
84
85 #define USB_CDC_REQ_SET_LINE_CODING             0x20
86 #define USB_CDC_REQ_GET_LINE_CODING             0x21
87 #define USB_CDC_REQ_SET_CONTROL_LINE_STATE      0x22
88 #define USB_CDC_REQ_SEND_BREAK                  0x23
89
90 /* USB Device Descriptor */
91 static
92 #if !defined(GNU_LINUX_EMULATION)
93 const
94 #endif
95 uint8_t vcom_device_desc[18] = {
96   18,   /* bLength */
97   DEVICE_DESCRIPTOR,            /* bDescriptorType */
98   0x10, 0x01,                   /* bcdUSB = 1.1 */
99   0x02,                         /* bDeviceClass (CDC).              */
100   0x00,                         /* bDeviceSubClass.                 */
101   0x00,                         /* bDeviceProtocol.                 */
102   0x40,                         /* bMaxPacketSize.                  */
103   0x00, 0x00,                   /* idVendor  (will be replaced)     */
104   0x00, 0x00,                   /* idProduct (will be replaced)     */
105   0x00, 0x00,                   /* bcdDevice (will be replaced)     */
106   1,                            /* iManufacturer.                   */
107   2,                            /* iProduct.                        */
108   3,                            /* iSerialNumber.                   */
109   1                             /* bNumConfigurations.              */
110 };
111
112 #define VCOM_FEATURE_BUS_POWERED        0x80
113
114 /* Configuration Descriptor tree for a CDC.*/
115 static const uint8_t vcom_config_desc[67] = {
116   9,
117   CONFIG_DESCRIPTOR,            /* bDescriptorType: Configuration   */
118   /* Configuration Descriptor.*/
119   67, 0x00,                     /* wTotalLength.                    */
120   0x02,                         /* bNumInterfaces.                  */
121   0x01,                         /* bConfigurationValue.             */
122   0,                            /* iConfiguration.                  */
123   VCOM_FEATURE_BUS_POWERED,     /* bmAttributes.                    */
124   50,                           /* bMaxPower (100mA).               */
125   /* Interface Descriptor.*/
126   9,
127   INTERFACE_DESCRIPTOR,
128   0x00,            /* bInterfaceNumber.                */
129   0x00,            /* bAlternateSetting.               */
130   0x01,            /* bNumEndpoints.                   */
131   0x02,            /* bInterfaceClass (Communications Interface Class,
132                       CDC section 4.2).  */
133   0x02,            /* bInterfaceSubClass (Abstract Control Model, CDC
134                       section 4.3).  */
135   0x01,            /* bInterfaceProtocol (AT commands, CDC section
136                       4.4).  */
137   0,               /* iInterface.                      */
138   /* Header Functional Descriptor (CDC section 5.2.3).*/
139   5,          /* bLength.                         */
140   0x24,       /* bDescriptorType (CS_INTERFACE).  */
141   0x00,       /* bDescriptorSubtype (Header Functional Descriptor). */
142   0x10, 0x01, /* bcdCDC.                          */
143   /* Call Management Functional Descriptor. */
144   5,            /* bFunctionLength.                 */
145   0x24,         /* bDescriptorType (CS_INTERFACE).  */
146   0x01,         /* bDescriptorSubtype (Call Management Functional
147                    Descriptor). */
148   0x03,         /* bmCapabilities (D0+D1).          */
149   0x01,         /* bDataInterface.                  */
150   /* ACM Functional Descriptor.*/
151   4,            /* bFunctionLength.                 */
152   0x24,         /* bDescriptorType (CS_INTERFACE).  */
153   0x02,         /* bDescriptorSubtype (Abstract Control Management
154                    Descriptor).  */
155   0x02,         /* bmCapabilities.                  */
156   /* Union Functional Descriptor.*/
157   5,            /* bFunctionLength.                 */
158   0x24,         /* bDescriptorType (CS_INTERFACE).  */
159   0x06,         /* bDescriptorSubtype (Union Functional
160                    Descriptor).  */
161   0x00,         /* bMasterInterface (Communication Class
162                    Interface).  */
163   0x01,         /* bSlaveInterface0 (Data Class Interface).  */
164   /* Endpoint 2 Descriptor.*/
165   7,
166   ENDPOINT_DESCRIPTOR,
167   ENDP2|0x80,    /* bEndpointAddress.    */
168   0x03,          /* bmAttributes (Interrupt).        */
169   0x0A, 0x00,    /* wMaxPacketSize.                  */
170   0xFF,          /* bInterval.                       */
171   /* Interface Descriptor.*/
172   9,
173   INTERFACE_DESCRIPTOR,          /* bDescriptorType: */
174   0x01,          /* bInterfaceNumber.                */
175   0x00,          /* bAlternateSetting.               */
176   0x02,          /* bNumEndpoints.                   */
177   0x0A,          /* bInterfaceClass (Data Class Interface, CDC section 4.5). */
178   0x00,          /* bInterfaceSubClass (CDC section 4.6). */
179   0x00,          /* bInterfaceProtocol (CDC section 4.7). */
180   0x00,          /* iInterface.                      */
181   /* Endpoint 3 Descriptor.*/
182   7,
183   ENDPOINT_DESCRIPTOR,          /* bDescriptorType: Endpoint */
184   ENDP3,    /* bEndpointAddress. */
185   0x02,                         /* bmAttributes (Bulk).             */
186   0x40, 0x00,                   /* wMaxPacketSize.                  */
187   0x00,                         /* bInterval.                       */
188   /* Endpoint 1 Descriptor.*/
189   7,
190   ENDPOINT_DESCRIPTOR,          /* bDescriptorType: Endpoint */
191   ENDP1|0x80,                   /* bEndpointAddress. */
192   0x02,                         /* bmAttributes (Bulk).             */
193   0x40, 0x00,                   /* wMaxPacketSize.                  */
194   0x00                          /* bInterval.                       */
195 };
196
197
198 /*
199  * U.S. English language identifier.
200  */
201 static const uint8_t vcom_string0[4] = {
202   4,                            /* bLength */
203   STRING_DESCRIPTOR,
204   0x09, 0x04                    /* LangID = 0x0409: US-English */
205 };
206
207 #include "usb-strings.c.inc"
208
209 static void neug_setup_endpoints_for_interface (struct usb_dev *dev,
210                                                 uint16_t interface, int stop);
211 #ifdef FRAUCHEKY_SUPPORT
212 #ifdef ACKBTN_SUPPORT
213 #include <contrib/ackbtn.h>
214 #endif
215 extern int fraucheky_main_active;
216
217 #define MSC_MASS_STORAGE_RESET_COMMAND 0xFF
218 extern int fraucheky_enabled (void);
219 extern void fraucheky_init (void);
220 extern void fraucheky_main (void);
221
222 extern void fraucheky_setup_endpoints_for_interface (int stop);
223 extern int fraucheky_setup (struct usb_dev *dev);
224 extern int fraucheky_get_descriptor (struct usb_dev *dev);
225 #endif
226
227 #define NUM_INTERFACES 2
228
229 static void
230 usb_device_reset (struct usb_dev *dev)
231 {
232   usb_lld_reset (dev, VCOM_FEATURE_BUS_POWERED);
233
234   /* Initialize Endpoint 0.  */
235 #ifdef GNU_LINUX_EMULATION
236   usb_lld_setup_endp (dev, ENDP0, 1, 1);
237 #else
238   usb_lld_setup_endpoint (ENDP0, EP_CONTROL, 0, ENDP0_RXADDR, ENDP0_TXADDR, 64);
239 #endif
240
241   /* Notify upper layer.  */
242   chopstx_mutex_lock (&usb_mtx);
243   bDeviceState = USB_DEVICE_STATE_ATTACHED;
244   connected = 0;
245   chopstx_cond_signal (&usb_cnd);
246   chopstx_mutex_unlock (&usb_mtx);
247 }
248
249 #ifdef FLASH_UPGRADE_SUPPORT
250 extern uint8_t _regnual_start, __heap_end__;
251
252 static const uint8_t *const mem_info[] = { &_regnual_start,  &__heap_end__, };
253 #endif
254
255 /* USB vendor requests to control pipe */
256 #define USB_FSIJ_MEMINFO          0
257 #define USB_FSIJ_DOWNLOAD         1
258 #define USB_FSIJ_EXEC             2
259 #define USB_NEUG_SET_PASSWD     253
260 #define USB_NEUG_GET_INFO       254
261 #define USB_NEUG_EXIT           255 /* Ask to exit and to receive reGNUal */
262
263 #define DEFAULT_PASSWD "12345678"
264 #define DEFAULT_PASSWD_LEN 8
265
266 uint8_t neug_passwd[33] __attribute__ ((section(".passwd"))) = {
267   0xff,
268   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
269   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
270   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
271 };
272 static uint8_t usbbuf[64];
273
274 #ifdef FLASH_UPGRADE_SUPPORT
275 static void set_passwd (void)
276 {
277   flash_unlock ();
278   if (neug_passwd[0] != 0xff)
279     flash_erase_page ((uintptr_t)neug_passwd);
280   if (usbbuf[0] == DEFAULT_PASSWD_LEN
281       && !memcmp (usbbuf + 1, DEFAULT_PASSWD, DEFAULT_PASSWD_LEN))
282     return;
283   flash_write ((uintptr_t)neug_passwd, usbbuf, usbbuf[0] + 1);
284 }
285
286
287 /* After calling this function, CRC module remain enabled.  */
288 static int download_check_crc32 (struct usb_dev *dev, const uint32_t *end_p)
289 {
290   uint32_t crc32 = *end_p;
291   const uint32_t *p;
292
293   crc32_rv_reset ();
294
295   for (p = (const uint32_t *)&_regnual_start; p < end_p; p++)
296     crc32_rv_step (rbit (*p));
297
298   if ((rbit (crc32_rv_get ()) ^ crc32) == 0xffffffff)
299     return usb_lld_ctrl_ack (dev);
300
301   return -1;
302 }
303 #endif
304
305
306 #define NEUG_SPECIAL_BITRATE 110
307
308 struct line_coding
309 {
310   uint32_t bitrate;
311   uint8_t format;
312   uint8_t paritytype;
313   uint8_t datatype;
314 } __attribute__((packed));
315
316 static struct line_coding line_coding = {
317   115200, /* baud rate: 115200    */
318   0x00,   /* stop bits: 1         */
319   0x00,   /* parity:    none      */
320   0x08    /* bits:      8         */
321 };
322
323 #define CDC_CTRL_DTR            0x0001
324
325 static void
326 usb_ctrl_write_finish (struct usb_dev *dev)
327 {
328   struct device_req *arg = &dev->dev_req;
329   uint8_t type_rcp = arg->type & (REQUEST_TYPE|RECIPIENT);
330
331   if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT)
332       && USB_SETUP_SET (arg->type))
333     {
334       if (arg->request == USB_FSIJ_EXEC)
335         {
336           chopstx_mutex_lock (&usb_mtx);
337           if (fsij_device_state == FSIJ_DEVICE_EXITED)
338             {
339               usb_lld_prepare_shutdown (); /* No further USB communication */
340               fsij_device_state = FSIJ_DEVICE_EXEC_REQUESTED;
341             }
342           chopstx_mutex_unlock (&usb_mtx);
343         }
344 #ifdef FLASH_UPGRADE_SUPPORT
345       else if (arg->request == USB_NEUG_SET_PASSWD)
346         set_passwd ();
347 #endif
348       else if (arg->request == USB_NEUG_EXIT)
349         {
350           if ((neug_passwd[0] == 0xff && usbbuf[0] == DEFAULT_PASSWD_LEN
351                && !memcmp (usbbuf + 1, DEFAULT_PASSWD, DEFAULT_PASSWD_LEN))
352 #ifdef FLASH_UPGRADE_SUPPORT
353               || (neug_passwd[0] == usbbuf[0]
354                   && !memcmp (neug_passwd+1, usbbuf+1, neug_passwd[0]))
355 #endif
356               )
357             {
358               chopstx_mutex_lock (&usb_mtx);
359               fsij_device_state = FSIJ_DEVICE_NEUG_EXIT_REQUESTED;
360               chopstx_cond_signal (&usb_cnd);
361               chopstx_mutex_unlock (&usb_mtx);
362             }
363         }
364     }
365   else if (type_rcp == (CLASS_REQUEST | INTERFACE_RECIPIENT) && arg->index == 0
366            && USB_SETUP_SET (arg->type))
367     {
368       if (arg->request == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
369         {
370           /* Open/close the connection.  */
371           chopstx_mutex_lock (&usb_mtx);
372           connected = (arg->value & CDC_CTRL_DTR)? 1 : 0;
373           chopstx_cond_signal (&usb_cnd);
374           chopstx_mutex_unlock (&usb_mtx);
375         }
376 #ifdef FRAUCHEKY_SUPPORT
377       else if (running_neug && arg->request == USB_CDC_REQ_SET_LINE_CODING)
378         {
379           chopstx_mutex_lock (&usb_mtx);
380           if (line_coding.bitrate == NEUG_SPECIAL_BITRATE)
381             {
382               fsij_device_state = FSIJ_DEVICE_NEUG_FRAUCHEKY_REQUESTED;
383               chopstx_cond_signal (&usb_cnd);
384             }
385           else if (fsij_device_state == FSIJ_DEVICE_NEUG_FRAUCHEKY_REQUESTED)
386             fsij_device_state = FSIJ_DEVICE_RUNNING;
387           chopstx_mutex_unlock (&usb_mtx);
388         }
389       else if (!running_neug && arg->request == MSC_MASS_STORAGE_RESET_COMMAND)
390         fraucheky_setup_endpoints_for_interface (0);
391 #endif
392     }
393 }
394
395
396 static int
397 vcom_port_data_setup (struct usb_dev *dev)
398 {
399   struct device_req *arg = &dev->dev_req;
400
401   if (USB_SETUP_GET (arg->type))
402     {
403       if (arg->request == USB_CDC_REQ_GET_LINE_CODING)
404         return usb_lld_ctrl_send (dev, &line_coding, sizeof(line_coding));
405     }
406   else  /* USB_SETUP_SET (req) */
407     {
408       if (arg->request == USB_CDC_REQ_SET_LINE_CODING
409           && arg->len == sizeof (line_coding))
410         return usb_lld_ctrl_recv (dev, &line_coding, sizeof (line_coding));
411       else if (arg->request == USB_CDC_REQ_SET_CONTROL_LINE_STATE)
412         return usb_lld_ctrl_ack (dev);
413     }
414
415   return -1;
416 }
417
418 static int
419 usb_setup (struct usb_dev *dev)
420 {
421   struct device_req *arg = &dev->dev_req;
422   uint8_t type_rcp = arg->type & (REQUEST_TYPE|RECIPIENT);
423
424   if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT))
425     {
426       if (USB_SETUP_GET (arg->type))
427         {
428           if (arg->request == USB_FSIJ_MEMINFO)
429             {
430 #ifdef FLASH_UPGRADE_SUPPORT
431               chopstx_mutex_lock (&usb_mtx);
432               if (fsij_device_state != FSIJ_DEVICE_EXITED)
433                 {
434                   chopstx_mutex_unlock (&usb_mtx);
435                   return -1;
436                 }
437               chopstx_mutex_unlock (&usb_mtx);
438               return usb_lld_ctrl_send (dev, mem_info, sizeof (mem_info));
439 #else
440               return -1;
441 #endif
442             }
443           else if (arg->request == USB_NEUG_GET_INFO)
444             {
445               if (arg->index == 0)
446                 return usb_lld_ctrl_send (dev, &neug_mode, sizeof (uint8_t));
447               else if (arg->index == 1)
448                 return usb_lld_ctrl_send (dev, &neug_err_cnt, sizeof (uint16_t));
449               else if (arg->index == 2)
450                 return usb_lld_ctrl_send (dev, &neug_err_cnt_rc, sizeof (uint16_t));
451               else if (arg->index == 3)
452                 return usb_lld_ctrl_send (dev, &neug_err_cnt_p64, sizeof (uint16_t));
453               else if (arg->index == 4)
454                 return usb_lld_ctrl_send (dev, &neug_err_cnt_p4k, sizeof (uint16_t));
455               else if (arg->index == 5)
456                 return usb_lld_ctrl_send (dev, &neug_rc_max, sizeof (uint16_t));
457               else if (arg->index == 6)
458                 return usb_lld_ctrl_send (dev, &neug_p64_max, sizeof (uint16_t));
459               else if (arg->index == 7)
460                 return usb_lld_ctrl_send (dev, &neug_p4k_max, sizeof (uint16_t));
461               else
462                 return -1;
463             }
464         }
465       else /* SETUP_SET */
466         {
467 #ifdef FLASH_UPGRADE_SUPPORT
468           uint8_t *addr = (uint8_t *)(0x20000000UL + arg->value * 0x100 + arg->index);
469 #endif
470
471           if (arg->request == USB_FSIJ_DOWNLOAD)
472             {
473 #ifdef FLASH_UPGRADE_SUPPORT
474               chopstx_mutex_lock (&usb_mtx);
475               if (fsij_device_state != FSIJ_DEVICE_EXITED)
476                 {
477                   chopstx_mutex_unlock (&usb_mtx);
478                   return -1;
479                 }
480               chopstx_mutex_unlock (&usb_mtx);
481
482               if (addr < &_regnual_start || addr + arg->len > &__heap_end__)
483                 return -1;
484
485               if (arg->index + arg->len < 256)
486                 memset (addr + arg->index + arg->len, 0, 256 - (arg->index + arg->len));
487
488               return usb_lld_ctrl_recv (dev, addr, arg->len);
489 #else
490               return -1;
491 #endif
492             }
493           else if (arg->request == USB_FSIJ_EXEC && arg->len == 0)
494             {
495 #ifdef FLASH_UPGRADE_SUPPORT
496               chopstx_mutex_lock (&usb_mtx);
497               if (fsij_device_state != FSIJ_DEVICE_EXITED)
498                 {
499                   chopstx_mutex_unlock (&usb_mtx);
500                   return -1;
501                 }
502               chopstx_mutex_unlock (&usb_mtx);
503
504               if (((uintptr_t)addr & 0x03))
505                 return -1;
506
507               return download_check_crc32 (dev, (uint32_t *)addr);
508 #else
509               return -1;
510 #endif
511             }
512           else if (arg->request == USB_NEUG_SET_PASSWD && arg->len <= 32)
513             {
514               usbbuf[0] = arg->len;
515               return usb_lld_ctrl_recv (dev, usbbuf + 1, arg->len);
516             }
517           else if (arg->request == USB_NEUG_EXIT && arg->len <= 32)
518             {
519               chopstx_mutex_lock (&usb_mtx);
520               if (fsij_device_state != FSIJ_DEVICE_RUNNING)
521                 {
522                   chopstx_mutex_unlock (&usb_mtx);
523                   return -1;
524                 }
525               chopstx_mutex_unlock (&usb_mtx);
526
527               usbbuf[0] = arg->len;
528               return usb_lld_ctrl_recv (dev, usbbuf + 1, arg->len);
529             }
530         }
531     }
532   else if (type_rcp == (CLASS_REQUEST | INTERFACE_RECIPIENT)
533            && arg->index == 0)
534     {
535 #ifdef FRAUCHEKY_SUPPORT
536       if (running_neug)
537         return vcom_port_data_setup (dev);
538       else
539         return fraucheky_setup (dev);
540 #else
541       return vcom_port_data_setup (dev);
542 #endif
543     }
544
545   return -1;
546 }
547
548 static int
549 usb_get_descriptor (struct usb_dev *dev)
550 {
551   struct device_req *arg = &dev->dev_req;
552   uint8_t rcp = arg->type & RECIPIENT;
553   uint8_t desc_type = (arg->value >> 8);
554   uint8_t desc_index = (arg->value & 0xff);
555
556 #ifdef FRAUCHEKY_SUPPORT
557   if (!running_neug)
558     return fraucheky_get_descriptor (dev);
559 #endif
560
561   if (rcp != DEVICE_RECIPIENT)
562     return -1;
563
564   if (desc_type == DEVICE_DESCRIPTOR)
565     return usb_lld_ctrl_send (dev,
566                               vcom_device_desc, sizeof (vcom_device_desc));
567   else if (desc_type == CONFIG_DESCRIPTOR)
568     return usb_lld_ctrl_send (dev,
569                               vcom_config_desc, sizeof (vcom_config_desc));
570   else if (desc_type == STRING_DESCRIPTOR)
571     {
572       const uint8_t *str;
573       int size;
574
575       switch (desc_index)
576         {
577         case 0:
578           str = vcom_string0;
579           size = sizeof (vcom_string0);
580           break;
581         case 1:
582           str = neug_string_vendor;
583           size = sizeof (neug_string_vendor);
584           break;
585         case 2:
586           str = neug_string_product;
587           size = sizeof (neug_string_product);
588           break;
589         case 3:
590           str = neug_string_serial;
591           size = sizeof (neug_string_serial);
592           break;
593         case 4:
594           str = neug_revision_detail;
595           size = sizeof (neug_revision_detail);
596           break;
597         case 5:
598           str = neug_config_options;
599           size = sizeof (neug_config_options);
600           break;
601         case 6:
602           str = sys_version;
603           size = sizeof (sys_version);
604           break;
605 #ifdef USE_SYS3
606         case 7:
607           {
608             int i;
609             str = usbbuf;
610             for (i = 0; i < (int)sizeof (usbbuf)/2 - 2; i++)
611               {
612                 if (sys_board_name[i] == 0)
613                   break;
614
615                 usbbuf[i*2+2] = sys_board_name[i];
616                 usbbuf[i*2+3] = 0;
617               }
618             usbbuf[0] = i*2 + 2;
619             usbbuf[1] = STRING_DESCRIPTOR;
620             size = i*2 + 2;
621           }
622           break;
623 #endif
624         default:
625           return -1;
626         }
627
628       return usb_lld_ctrl_send (dev, str, size);
629     }
630
631   return -1;
632 }
633
634 static void
635 neug_setup_endpoints_for_interface (struct usb_dev *dev,
636                                     uint16_t interface, int stop)
637 {
638 #if !defined(GNU_LINUX_EMULATION)
639   (void)dev;
640 #endif
641   
642   if (interface == 0)
643     {
644 #ifdef FRAUCHEKY_SUPPORT
645       if (running_neug)
646         {
647           if (!stop)
648 #ifdef GNU_LINUX_EMULATION
649             usb_lld_setup_endp (dev, ENDP2, 0, 1);
650 #else
651             usb_lld_setup_endpoint (ENDP2, EP_INTERRUPT, 0, 0, ENDP2_TXADDR, 0);
652 #endif
653           else
654             usb_lld_stall_tx (ENDP2);
655         }
656       else
657         fraucheky_setup_endpoints_for_interface (stop);
658 #else
659       if (!stop)
660 #ifdef GNU_LINUX_EMULATION
661         usb_lld_setup_endp (dev, ENDP2, 0, 1);
662 #else
663         usb_lld_setup_endpoint (ENDP2, EP_INTERRUPT, 0, 0, ENDP2_TXADDR, 0);
664 #endif
665       else
666         usb_lld_stall_tx (ENDP2);
667 #endif
668     }
669   else if (interface == 1)
670     {
671       if (!stop)
672         {
673 #ifdef GNU_LINUX_EMULATION
674           usb_lld_setup_endp (dev, ENDP1, 0, 1);
675           usb_lld_setup_endp (dev, ENDP3, 1, 0);
676 #else
677           usb_lld_setup_endpoint (ENDP1, EP_BULK, 0, 0, ENDP1_TXADDR, 0);
678           usb_lld_setup_endpoint (ENDP3, EP_BULK, 0, ENDP3_RXADDR, 0, 64);
679 #endif
680           /* Start with no data receiving (ENDP3 not enabled) */
681         }
682       else
683         {
684           usb_lld_stall_tx (ENDP1);
685           usb_lld_stall_rx (ENDP3);
686         }
687     }
688 }
689
690 static int
691 usb_set_configuration (struct usb_dev *dev)
692 {
693   int i;
694   uint8_t current_conf;
695
696   current_conf = usb_lld_current_configuration (dev);
697   if (current_conf == 0)
698     {
699       if (dev->dev_req.value != 1)
700         return -1;
701
702       usb_lld_set_configuration (dev, 1);
703       for (i = 0; i < NUM_INTERFACES; i++)
704         neug_setup_endpoints_for_interface (dev, i, 0);
705       chopstx_mutex_lock (&usb_mtx);
706       bDeviceState = USB_DEVICE_STATE_CONFIGURED;
707       chopstx_mutex_unlock (&usb_mtx);
708     }
709   else if (current_conf != dev->dev_req.value)
710     {
711       if (dev->dev_req.value != 0)
712         return -1;
713
714       usb_lld_set_configuration (dev, 0);
715       for (i = 0; i < NUM_INTERFACES; i++)
716         neug_setup_endpoints_for_interface (dev, i, 1);
717       chopstx_mutex_lock (&usb_mtx);
718       bDeviceState = USB_DEVICE_STATE_ADDRESSED;
719       chopstx_cond_signal (&usb_cnd);
720       chopstx_mutex_unlock (&usb_mtx);
721     }
722
723   /* Do nothing when current_conf == value */
724   return usb_lld_ctrl_ack (dev);
725 }
726
727
728 static int
729 usb_set_interface (struct usb_dev *dev)
730 {
731   uint16_t interface = dev->dev_req.index;
732   uint16_t alt = dev->dev_req.value;
733
734   if (interface >= NUM_INTERFACES)
735     return -1;
736
737   if (alt != 0)
738     return -1;
739   else
740     {
741       neug_setup_endpoints_for_interface (dev, interface, 0);
742       return usb_lld_ctrl_ack (dev);
743     }
744 }
745
746 static int
747 usb_get_interface (struct usb_dev *dev)
748 {
749   const uint8_t zero = 0;
750   uint16_t interface = dev->dev_req.index;
751
752   if (interface >= NUM_INTERFACES)
753     return -1;
754
755   return usb_lld_ctrl_send (dev, &zero, 1);
756 }
757
758
759 static int
760 usb_get_status_interface (struct usb_dev *dev)
761 {
762   const uint16_t status_info = 0;
763   uint16_t interface = dev->dev_req.index;
764
765   if (interface >= NUM_INTERFACES)
766     return -1;
767
768   return usb_lld_ctrl_send (dev, &status_info, 2);
769 }
770
771 static void usb_tx_done (uint8_t ep_num, uint16_t len);
772 static void usb_rx_ready (uint8_t ep_num, uint16_t len);
773
774
775 #ifdef GNU_LINUX_EMULATION
776 #include <signal.h>
777 #define INTR_REQ_USB SIGUSR1
778 #else
779 #define INTR_REQ_USB 20
780 #endif
781
782 #define PRIO_USB 3
783
784 static void *
785 usb_main (void *arg)
786 {
787   chopstx_intr_t usb_intr;
788 #if defined(ACKBTN_SUPPORT) && defined(FRAUCHEKY_SUPPORT)
789   chopstx_intr_t ack_intr;
790   struct chx_poll_head *const poll_ptrs[] = {
791     (struct chx_poll_head *const)&usb_intr,
792     (struct chx_poll_head *const)&ack_intr,
793   };
794 #endif
795   struct usb_dev dev;
796
797 #if defined(ACKBTN_SUPPORT) && defined(FRAUCHEKY_SUPPORT)
798   if (arg)
799     {
800       ackbtn_init (&ack_intr);
801       ackbtn_enable ();
802     }
803 #else
804   (void)arg;
805 #endif
806   usb_lld_init (&dev, VCOM_FEATURE_BUS_POWERED);
807   chopstx_claim_irq (&usb_intr, INTR_REQ_USB);
808   goto event_handle;    /* For old SYS < 3.0 */
809
810   while (1)
811     {
812 #if defined(ACKBTN_SUPPORT) && defined(FRAUCHEKY_SUPPORT)
813       chopstx_poll (NULL, arg ? 2 : 1, poll_ptrs);
814 #else
815       chopstx_intr_wait (&usb_intr);
816 #endif
817
818 #if defined(ACKBTN_SUPPORT) && defined(FRAUCHEKY_SUPPORT)
819       if (arg && ack_intr.ready)
820         {
821           ackbtn_disable ();
822           chopstx_intr_done (&ack_intr);
823           fraucheky_main_active = 0;
824           continue;
825         }
826 #endif
827
828       if (usb_intr.ready)
829         {
830           int e;
831           uint8_t ep_num;
832
833         event_handle:
834           e = usb_lld_event_handler (&dev);
835           ep_num = USB_EVENT_ENDP (e);
836           chopstx_intr_done (&usb_intr);
837
838           if (ep_num != 0)
839             {
840               if (USB_EVENT_TXRX (e))
841                 usb_tx_done (ep_num, USB_EVENT_LEN (e));
842               else
843                 usb_rx_ready (ep_num, USB_EVENT_LEN (e));
844             }
845           else
846             switch (USB_EVENT_ID (e))
847               {
848               case USB_EVENT_DEVICE_RESET:
849                 usb_device_reset (&dev);
850                 break;
851
852               case USB_EVENT_DEVICE_ADDRESSED:
853                 chopstx_mutex_lock (&usb_mtx);
854                 bDeviceState = USB_DEVICE_STATE_ADDRESSED;
855                 chopstx_cond_signal (&usb_cnd);
856                 chopstx_mutex_unlock (&usb_mtx);
857                 break;
858
859               case USB_EVENT_GET_DESCRIPTOR:
860                 if (usb_get_descriptor (&dev) < 0)
861                   usb_lld_ctrl_error (&dev);
862                 break;
863
864               case USB_EVENT_SET_CONFIGURATION:
865                 if (usb_set_configuration (&dev) < 0)
866                   usb_lld_ctrl_error (&dev);
867                 break;
868
869               case USB_EVENT_SET_INTERFACE:
870                 if (usb_set_interface (&dev) < 0)
871                   usb_lld_ctrl_error (&dev);
872                 break;
873
874               case USB_EVENT_CTRL_REQUEST:
875                 /* Device specific device request.  */
876                 if (usb_setup (&dev) < 0)
877                   usb_lld_ctrl_error (&dev);
878                 break;
879
880               case USB_EVENT_GET_STATUS_INTERFACE:
881                 if (usb_get_status_interface (&dev) < 0)
882                   usb_lld_ctrl_error (&dev);
883                 break;
884
885               case USB_EVENT_GET_INTERFACE:
886                 if (usb_get_interface (&dev) < 0)
887                   usb_lld_ctrl_error (&dev);
888                 break;
889
890               case USB_EVENT_SET_FEATURE_DEVICE:
891               case USB_EVENT_SET_FEATURE_ENDPOINT:
892               case USB_EVENT_CLEAR_FEATURE_DEVICE:
893               case USB_EVENT_CLEAR_FEATURE_ENDPOINT:
894                 usb_lld_ctrl_ack (&dev);
895                 break;
896
897               case USB_EVENT_CTRL_WRITE_FINISH:
898                 /* Control WRITE transfer finished.  */
899                 usb_ctrl_write_finish (&dev);
900                 break;
901
902               case USB_EVENT_DEVICE_SUSPEND:
903                 if (running_neug == 1)
904                   {
905                     running_neug = -1;
906                     neug_fini ();
907                   }
908                 chopstx_conf_idle (2);
909                 bDeviceState |= USB_DEVICE_STATE_SUSPEND;
910                 break;
911
912               case USB_EVENT_DEVICE_WAKEUP:
913                 chopstx_conf_idle (1);
914                 if (running_neug == -1)
915                   {
916                     neug_init (random_word, RANDOM_BYTES_LENGTH/sizeof (uint32_t));
917                     running_neug = 1;
918                   }
919                 bDeviceState &= ~USB_DEVICE_STATE_SUSPEND;
920                 break;
921
922               case USB_EVENT_OK:
923               default:
924                 break;
925               }
926         }
927     }
928
929   return NULL;
930 }
931
932 #define ID_OFFSET (2+SERIALNO_STR_LEN*2)
933 static void fill_serial_no_by_unique_id (void)
934 {
935   uint8_t *p = &neug_string_serial[ID_OFFSET];
936   const uint8_t *u = unique_device_id () + (MHZ < 96 ? 8: 0);
937   int i;
938
939   for (i = 0; i < 4; i++)
940     {
941       uint8_t b = u[3-i];
942       uint8_t nibble;
943
944       nibble = (b >> 4);
945       nibble += (nibble >= 10 ? ('A' - 10) : '0');
946       p[i*4] = nibble;
947       p[i*4+1] = 0;
948       nibble = (b & 0x0f);
949       nibble += (nibble >= 10 ? ('A' - 10) : '0');
950       p[i*4+2] = nibble;
951       p[i*4+3] = 0;
952     }
953 }
954
955
956 static void
957 usb_tx_done (uint8_t ep_num, uint16_t len)
958 {
959   if (ep_num == ENDP1)
960     {
961       chopstx_mutex_lock (&usb_mtx);
962       chopstx_cond_signal (&usb_cnd);
963       chopstx_mutex_unlock (&usb_mtx);
964     }
965   else if (ep_num == ENDP2)
966     {
967       /* INTERRUPT Transfer done */
968     }
969 #ifdef FRAUCHEKY_SUPPORT
970   else if (ep_num == ENDP6)
971     EP6_IN_Callback (len);
972 #else
973   (void)len;
974 #endif
975 }
976
977 #ifdef GNU_LINUX_EMULATION
978 static uint8_t endp3_buf[64];
979 #endif
980
981 static void
982 usb_rx_ready (uint8_t ep_num, uint16_t len)
983 {
984   if (ep_num == ENDP3)
985 #ifdef GNU_LINUX_EMULATION
986     usb_lld_rx_enable_buf (ENDP3, endp3_buf, 64);
987 #else
988     usb_lld_rx_enable (ENDP3);
989 #endif
990 #ifdef FRAUCHEKY_SUPPORT
991   else if (ep_num == ENDP6)
992     EP6_OUT_Callback (len);
993 #else
994   (void)len;
995 #endif
996 }
997 \f
998 #define STACK_MAIN
999 #define STACK_PROCESS_1
1000 #define STACK_PROCESS_3
1001 #include "stack-def.h"
1002 #define STACK_ADDR_LED ((uintptr_t)process1_base)
1003 #define STACK_SIZE_LED (sizeof process1_base)
1004 #define STACK_ADDR_USB ((uintptr_t)process3_base)
1005 #define STACK_SIZE_USB (sizeof process3_base)
1006
1007
1008 #define PRIO_LED 3
1009 static struct eventflag led_event;
1010
1011 #define LED_ONESHOT_SHORT       ((eventmask_t)1)
1012 #define LED_TWOSHOTS            ((eventmask_t)2)
1013 #define LED_ONESHOT_LONG        ((eventmask_t)4)
1014
1015 /*
1016  * LED blinker: When notified, let LED emit for 100ms.
1017  */
1018 static void *
1019 led_blinker (void *arg)
1020 {
1021   (void)arg;
1022
1023   set_led (0);
1024
1025   while (1)
1026     {
1027       eventmask_t m;
1028
1029       m = eventflag_wait (&led_event);
1030
1031       set_led (1);
1032       if (m == LED_ONESHOT_SHORT)
1033         chopstx_usec_wait (100*1000);
1034       else if (m == LED_TWOSHOTS)
1035         {
1036           chopstx_usec_wait (50*1000);
1037           set_led (0);
1038           chopstx_usec_wait (50*1000);
1039           set_led (1);
1040           chopstx_usec_wait (50*1000);
1041         }
1042       else
1043         chopstx_usec_wait (250*1000);
1044       set_led (0);
1045     }
1046
1047   return NULL;
1048 }
1049 \f
1050 #ifdef GNU_LINUX_EMULATION
1051 static uint8_t endp1_buf[RANDOM_BYTES_LENGTH];
1052 #endif
1053
1054 static void copy_to_tx (uint32_t v, int i)
1055 {
1056 #ifdef GNU_LINUX_EMULATION
1057   memcpy (&endp1_buf[i*4], &v, 4);
1058 #else
1059   usb_lld_txcpy (&v, ENDP1, i * 4, 4);
1060 #endif
1061 }
1062
1063 #ifdef FLASH_UPGRADE_SUPPORT
1064 /*
1065  * In Gnuk 1.0.[12], reGNUal was not relocatable.
1066  * Now, it's relocatable, but we need to calculate its entry address
1067  * based on it's pre-defined address.
1068  */
1069 #define REGNUAL_START_ADDRESS_COMPATIBLE 0x20001400
1070 static uint32_t
1071 calculate_regnual_entry_address (const uint8_t *addr)
1072 {
1073   const uint8_t *p = addr + 4;
1074   uintptr_t v = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24);
1075
1076   v -= REGNUAL_START_ADDRESS_COMPATIBLE;
1077   v += (uintptr_t)addr;
1078   return v;
1079 }
1080 #endif
1081
1082
1083 static int
1084 check_usb_status (void *arg)
1085 {
1086   (void)arg;
1087
1088   return (connected || bDeviceState != USB_DEVICE_STATE_CONFIGURED
1089           || fsij_device_state != FSIJ_DEVICE_RUNNING);
1090 }
1091
1092
1093
1094 /*
1095  * Entry point.
1096  *
1097  * NOTE: the main function is already a thread in the system on entry.
1098  */
1099 int
1100 main (int argc, char **argv)
1101 {
1102 #ifdef FLASH_UPGRADE_SUPPORT
1103   uintptr_t entry;
1104 #endif
1105   chopstx_t led_thread, usb_thd;
1106   unsigned int count;
1107
1108   chopstx_conf_idle (1);
1109
1110 #ifdef GNU_LINUX_EMULATION
1111   if (argc >= 4 || (argc == 2 && !strcmp (argv[1], "--help")))
1112     {
1113       fprintf (stdout, "Usage: %s [--vidpid=Vxxx:Pxxx]", argv[0]);
1114       exit (0);
1115     }
1116
1117   if (argc >= 2 && !strncmp (argv[1], "--debug=", 8))
1118     {
1119       debug = strtol (&argv[1][8], NULL, 10);
1120       argc--;
1121       argv++;
1122     }
1123
1124   if (argc >= 2 && !strncmp (argv[1], "--vidpid=", 9))
1125     {
1126       uint32_t id;
1127       char *p;
1128
1129       id = (uint32_t)strtol (&argv[1][9], &p, 16);
1130       vcom_device_desc[8] = (id & 0xff);
1131       vcom_device_desc[9] = (id >> 8);
1132
1133       if (p && p[0] == ':')
1134         {
1135           id = (uint32_t)strtol (&p[1], NULL, 16);
1136           vcom_device_desc[10] = (id & 0xff);
1137           vcom_device_desc[11] = (id >> 8);
1138         }
1139
1140       argc--;
1141       argv++;
1142     }
1143 #else
1144   (void)argc;
1145   (void)argv;
1146 #endif
1147
1148   fill_serial_no_by_unique_id ();
1149
1150   adc_init ();
1151   neug_init (random_word, RANDOM_BYTES_LENGTH/sizeof (uint32_t));
1152
1153   eventflag_init (&led_event);
1154
1155   chopstx_mutex_init (&usb_mtx);
1156   chopstx_cond_init (&usb_cnd);
1157
1158   led_thread = chopstx_create (PRIO_LED, STACK_ADDR_LED, STACK_SIZE_LED,
1159                                led_blinker, NULL);
1160
1161 #ifdef FRAUCHEKY_SUPPORT
1162   if (fraucheky_enabled ())
1163     {
1164     go_fraucheky:
1165       bDeviceState = USB_DEVICE_STATE_UNCONNECTED;
1166       usb_thd = chopstx_create (PRIO_USB, STACK_ADDR_USB, STACK_SIZE_USB,
1167                                 usb_main, (void *)~0);
1168       fraucheky_init ();
1169       while (bDeviceState != USB_DEVICE_STATE_CONFIGURED)
1170         chopstx_usec_wait (250*1000);
1171       set_led (1);
1172       fraucheky_main ();
1173       chopstx_cancel (usb_thd);
1174       chopstx_join (usb_thd, NULL);
1175       usb_lld_shutdown ();
1176       bDeviceState = USB_DEVICE_STATE_UNCONNECTED;
1177     }
1178 #endif
1179
1180   running_neug = 1;
1181
1182   usb_thd = chopstx_create (PRIO_USB, STACK_ADDR_USB, STACK_SIZE_USB,
1183                             usb_main, NULL);
1184
1185   chopstx_mutex_lock (&usb_mtx);
1186
1187  not_configured:
1188   count = 0;
1189   /* Initial run-up */
1190   while (count < NEUG_PRE_LOOP || bDeviceState != USB_DEVICE_STATE_CONFIGURED)
1191     {
1192       if (fsij_device_state != FSIJ_DEVICE_RUNNING)
1193         break;
1194
1195       chopstx_mutex_unlock (&usb_mtx);
1196       neug_wait_full ();
1197       neug_flush ();
1198
1199       if ((count & 0x0007) == 0)
1200         eventflag_signal (&led_event, LED_ONESHOT_SHORT);
1201       chopstx_usec_wait (25*1000);
1202       count++;
1203       chopstx_mutex_lock (&usb_mtx);
1204     }
1205
1206   /* Holding USB_MTX...  */
1207   while (1)
1208     {
1209       int last_was_fullsizepacket = 0;
1210
1211       if (fsij_device_state != FSIJ_DEVICE_RUNNING)
1212         break;
1213
1214       chopstx_mutex_unlock (&usb_mtx);
1215       while (1)
1216         {
1217           uint32_t usec = 5000*1000;
1218           chopstx_poll_cond_t poll_desc;
1219           struct chx_poll_head *pd_array[1] = {
1220             (struct chx_poll_head *)&poll_desc
1221           };
1222
1223           poll_desc.type = CHOPSTX_POLL_COND;
1224           poll_desc.ready = 0;
1225           poll_desc.cond = &usb_cnd;
1226           poll_desc.mutex = &usb_mtx;
1227           poll_desc.check = check_usb_status;
1228           poll_desc.arg = NULL;
1229
1230           if (chopstx_poll (&usec, 1, pd_array))
1231             break;
1232
1233           /* Timeout */
1234           neug_flush ();
1235           neug_mode_select (line_coding.paritytype);
1236           eventflag_signal (&led_event, LED_TWOSHOTS);
1237         }
1238
1239       chopstx_mutex_lock (&usb_mtx);
1240       if (bDeviceState != USB_DEVICE_STATE_CONFIGURED)
1241         goto not_configured;
1242
1243       /* The connection opened.  */
1244       count = 0;
1245
1246       while (1)
1247         {
1248           int i;
1249
1250           chopstx_mutex_unlock (&usb_mtx);
1251           /*
1252            * No parity is standard.  It means providing conditioned output.
1253            * When parity enabled, it means to provide raw output
1254            * (CRC32 filtered when odd, direct sample of ADC when even).
1255            *
1256            * line_coding.paritytype:
1257            *   0: None, 1: Odd, 2: Even
1258            */
1259           neug_mode_select (line_coding.paritytype);
1260
1261           if ((count & 0x03ff) == 0)
1262             eventflag_signal (&led_event, LED_ONESHOT_SHORT);
1263
1264           i = neug_consume_random (copy_to_tx);
1265
1266           if (i == 0 && !last_was_fullsizepacket)
1267             {    /* Only send ZLP when the last packet was fullsize.  */
1268               neug_wait_full ();
1269
1270               chopstx_mutex_lock (&usb_mtx);
1271               if (bDeviceState != USB_DEVICE_STATE_CONFIGURED || !connected
1272                   || fsij_device_state != FSIJ_DEVICE_RUNNING)
1273                 break;
1274             }
1275           else
1276             {
1277               if (i == 64/4)
1278                 last_was_fullsizepacket = 1;
1279               else
1280                 last_was_fullsizepacket = 0;
1281
1282               chopstx_mutex_lock (&usb_mtx);
1283               if (bDeviceState != USB_DEVICE_STATE_CONFIGURED || !connected
1284                   || fsij_device_state != FSIJ_DEVICE_RUNNING)
1285                 break;
1286
1287               /* Prepare sending random data.  */
1288 #ifdef GNU_LINUX_EMULATION
1289               usb_lld_tx_enable_buf (ENDP1, endp1_buf, i * 4);
1290 #else
1291               usb_lld_tx_enable (ENDP1, i * 4);
1292 #endif
1293               chopstx_cond_wait (&usb_cnd, &usb_mtx);
1294               count++;
1295             }
1296         }
1297     }
1298
1299   chopstx_mutex_unlock (&usb_mtx);
1300
1301   chopstx_cancel (led_thread);
1302   chopstx_join (led_thread, NULL);
1303
1304   /*
1305    * We come here, because of FSIJ_DEVICE_NEUG_EXIT_REQUESTED
1306    * or FSIJ_DEVICE_NEUG_FRAUCHEKY_REQUESTED.
1307    */
1308   if (running_neug == 1)
1309     {
1310       running_neug = 0;
1311       neug_fini ();
1312
1313       /* Enable CRC module again.
1314        * This is required (together with one in download_check_crc32).
1315        */
1316       crc32_rv_reset ();
1317     }
1318
1319   chopstx_mutex_lock (&usb_mtx);
1320 #ifdef FRAUCHEKY_SUPPORT
1321   if (line_coding.bitrate == NEUG_SPECIAL_BITRATE)
1322     {
1323       while (fsij_device_state == FSIJ_DEVICE_NEUG_FRAUCHEKY_REQUESTED)
1324         {
1325           chopstx_mutex_unlock (&usb_mtx);
1326           set_led (1);
1327           chopstx_usec_wait (500*1000);
1328           set_led (0);
1329           chopstx_usec_wait (500*1000);
1330           chopstx_mutex_lock (&usb_mtx);
1331         }
1332
1333       usb_lld_prepare_shutdown ();
1334       chopstx_mutex_unlock (&usb_mtx);
1335       chopstx_cancel (usb_thd);
1336       chopstx_join (usb_thd, NULL);
1337       usb_lld_shutdown ();
1338       goto go_fraucheky;
1339     }
1340 #endif
1341
1342   fsij_device_state = FSIJ_DEVICE_EXITED;
1343
1344   while (fsij_device_state == FSIJ_DEVICE_EXITED)
1345     {
1346       chopstx_mutex_unlock (&usb_mtx);
1347       chopstx_usec_wait (500*1000);
1348       chopstx_mutex_lock (&usb_mtx);
1349     }
1350   chopstx_mutex_unlock (&usb_mtx);
1351
1352   flash_unlock ();              /* Flash unlock should be done here */
1353   set_led (1);
1354   usb_lld_shutdown ();
1355
1356   /* Finish application.  */
1357   chopstx_cancel (usb_thd);
1358   chopstx_join (usb_thd, NULL);
1359
1360 #ifdef FLASH_UPGRADE_SUPPORT
1361   /* Set vector */
1362   SCB->VTOR = (uintptr_t)&_regnual_start;
1363   entry = calculate_regnual_entry_address (&_regnual_start);
1364 #ifdef DFU_SUPPORT
1365 #define FLASH_SYS_START_ADDR 0x08000000
1366 #define FLASH_SYS_END_ADDR (0x08000000+0x1000)
1367 #define CHIP_ID_REG ((uint32_t *)0xE0042000)
1368   {
1369     extern uint8_t _sys;
1370     uintptr_t addr;
1371     handler *new_vector = (handler *)FLASH_SYS_START_ADDR;
1372     void (*func) (void (*)(void)) = (void (*)(void (*)(void)))new_vector[9];
1373     uint32_t flash_page_size = 1024; /* 1KiB default */
1374
1375    if ((*CHIP_ID_REG)&0x07 == 0x04) /* High dencity device.  */
1376      flash_page_size += 0x0400; /* It's 2KiB. */
1377
1378     /* Kill DFU */
1379     for (addr = FLASH_SYS_START_ADDR; addr < FLASH_SYS_END_ADDR;
1380          addr += flash_page_size)
1381       flash_erase_page (addr);
1382
1383     /* copy system service routines */
1384     flash_write (FLASH_SYS_START_ADDR, &_sys, 0x1000);
1385
1386     /* Leave NeuG to exec reGNUal */
1387     (*func) ((void (*)(void))entry);
1388     for (;;);
1389   }
1390 #else
1391   /* Leave NeuG to exec reGNUal */
1392   flash_erase_all_and_exec ((void (*)(void))entry);
1393 #endif
1394 #else
1395   exit (0);
1396 #endif
1397
1398   /* Never reached */
1399   return 0;
1400 }