Do not call EC programmer shutdown functions explicitly.

flashrom.c

 /*
  * This file is part of the flashrom project.
  *
  * Copyright (C) 2000 Silicon Integrated System Corporation
  * Copyright (C) 2004 Tyan Corp <yhlu@tyan.com>
  * Copyright (C) 2005-2008 coresystems GmbH
  * Copyright (C) 2008,2009 Carl-Daniel Hailfinger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ skipping 106 matching lines @@
 unsigned long flashbase;
 
 /* Is writing allowed with this programmer? */
 int programmer_may_write;
 
 const struct programmer_entry programmer_table[] = {
 #if CONFIG_INTERNAL == 1
         {
                 .name                   = "internal",
                 .init                   = internal_init,
+                /* called implicitly using shutdown callback */
                 .shutdown               = internal_shutdown,
                 .map_flash_region       = physmap,
                 .unmap_flash_region     = physunmap,
                 .chip_readb             = internal_chip_readb,
                 .chip_readw             = internal_chip_readw,
                 .chip_readl             = internal_chip_readl,
                 .chip_readn             = internal_chip_readn,
                 .chip_writeb            = internal_chip_writeb,
                 .chip_writew            = internal_chip_writew,
                 .chip_writel            = internal_chip_writel,
@@ skipping 340 matching lines @@
 static int shutdown_fn_count = 0;
 struct shutdown_func_data {
         void (*func) (void *data);
         void *data;
 } static shutdown_fn[SHUTDOWN_MAXFN];
 /* Initialize to 0 to make sure nobody registers a shutdown function before
  * programmer init.
  */
 static int may_register_shutdown = 0;
 
+static int programmer_shutdown_done = 0;
+
 /* Register a function to be executed on programmer shutdown.
  * The advantage over atexit() is that you can supply a void pointer which will
  * be used as parameter to the registered function upon programmer shutdown.
  * This pointer can point to arbitrary data used by said function, e.g. undo
  * information for GPIO settings etc. If unneeded, set data=NULL.
  * Please note that the first (void *data) belongs to the function signature of
  * the function passed as first parameter.
  */
 int register_shutdown(void (*function) (void *data), void *data)
 {
@@ skipping 73 matching lines @@
                 int i = --chip_restore_fn_count;
                 rc |= chip_restore_fn[i].func(chip_restore_fn[i].flash,
                                               chip_restore_fn[i].status);
         }
 
         return rc;
 }
 
 int programmer_shutdown(void)
 {
+        if (programmer_shutdown_done) {
+                msg_gdbg("%s: shutdown has already been done\n", __func__);
+                return -1;
+        }
+
+        msg_gdbg("%s: carrying out %d shutdown callbacks\n",
+                 __func__, shutdown_fn_count);
+
         /* Registering shutdown functions is no longer allowed. */
         may_register_shutdown = 0;
         while (shutdown_fn_count > 0) {
                 int i = --shutdown_fn_count;
                 shutdown_fn[i].func(shutdown_fn[i].data);
         }
         return programmer_table[programmer].shutdown();
 }
 
 void *programmer_map_flash_region(const char *descr, unsigned long phys_addr,
@@ skipping 1418 matching lines @@
 out_nofree:
         chip_restore(); /* must be done before programmer_shutdown() */
         /*
          * programmer_shutdown() call is moved to cli_mfg() in chromium os
          * tree. This is because some operations, such as write protection,
          * requires programmer_shutdown() but does not call doit().
          */
 //      programmer_shutdown();
         return ret;
 }