Revert previous patch to fix SD Card emulation

The previous patch modifies SD Card hardware emulation in a way that is
not backwards compatible with previous SDK platform releases. This has
the unfortunate effect of making SD Card emulation not work properly
when running existing AVDs.

Reverting the patch until we get a better one.

Change-Id: I82dac87709d88aa3bd292bf2ed0008ae74d95853

12 files changed, 45 insertions, 376 deletions

diff --git a/CHANGES.TXT b/CHANGES.TXT
index 7c9785b..4ead060 100644
--- a/CHANGES.TXT
+++ b/CHANGES.TXT
@@ -56,9 +56,6 @@ IMPORTANT CHANGES:
   The minor number will now be stuck to 0 since each official emulator
   release is supposed to match a corresponding SDK Tools release.
 
-- Added a new option -sdcard2 <file> to be able to use two SD Card images
-  at once. Note that this requires an updated emulator-specific kernel
-  and system image. It will thus be ignored by older emulated platforms.
 
 OTHER:
 
diff --git a/android/avd/info.c b/android/avd/info.c
index d726112..5634ef6 100644
--- a/android/avd/info.c
+++ b/android/avd/info.c
@@ -92,12 +92,6 @@ AvdInfo*        android_avdInfo;
  */
 #define  SDCARD_PATH     "sdcard.path"
 
-/* the config.ini key that is used to indicate the absolute path
- * to the second SD Card image file, if you don't want to place it in
- * the content directory.
- */
-#define  SDCARD2_PATH     "sdcard2.path"
-
 /* certain disk image files are mounted read/write by the emulator
  * to ensure that several emulators referencing the same files
  * do not corrupt these files, we need to lock them and respond
@@ -687,26 +681,7 @@ EXIT:
     return l->pPath[0];
 }
 
-static void _sdcardLoadImages(ImageLoader* l, AvdInfo* i, AvdInfoParams* params, AvdImageType sdcardImage)
-{
-    imageLoader_set(l, sdcardImage);
-    imageLoader_load(l, IMAGE_OPTIONAL |
-                        IMAGE_IGNORE_IF_LOCKED);
 
-    /* if the file was not found, ignore it */
-    if (l->pPath[0] && !path_exists(l->pPath[0]))
-    {
-        D("ignoring non-existing %s at %s: %s",
-          l->imageText, l->pPath[0], strerror(errno));
-
-        /* if the user provided the SD Card path by hand,
-         * warn him. */
-        if (params->forcePaths[sdcardImage] != NULL)
-            dwarning("ignoring non-existing SD Card image");
-
-        imageLoader_setPath(l, NULL);
-    }
-}
 
 /* find the correct path of all image files we're going to need
  * and lock the files that need it.
@@ -803,8 +778,23 @@ _getImagePaths(AvdInfo*  i, AvdInfoParams*  params )
      * already used, we must ignore it.
      */
     if (!noSdCard) {
-        _sdcardLoadImages(l, i, params, AVD_IMAGE_SDCARD);
-        _sdcardLoadImages(l, i, params, AVD_IMAGE_SDCARD2);
+        imageLoader_set (l, AVD_IMAGE_SDCARD);
+        imageLoader_load(l, IMAGE_OPTIONAL |
+                            IMAGE_IGNORE_IF_LOCKED);
+
+        /* if the file was not found, ignore it */
+        if (l->pPath[0] && !path_exists(l->pPath[0])) 
+        {
+            D("ignoring non-existing %s at %s: %s",
+              l->imageText, l->pPath[0], strerror(errno));
+
+            /* if the user provided the SD Card path by hand,
+             * warn him. */
+            if (params->forcePaths[AVD_IMAGE_SDCARD] != NULL)
+                dwarning("ignoring non-existing SD Card image");
+
+            imageLoader_setPath(l, NULL);
+        }
     }
 
     return 0;
@@ -1059,24 +1049,22 @@ _getSkin( AvdInfo*  i, AvdInfoParams*  params )
 }
 
 /* If the user didn't explicitely provide an SD Card path,
- * check the specfied key in config.ini and use that if
+ * check the SDCARD_PATH key in config.ini and use that if
  * available.
  */
 static void
-_getSDCardPath(AvdInfo*  i, AvdInfoParams*  params, AvdImageType sdcardImage,
-               const char* iniKey )
+_getSDCardPath( AvdInfo*  i, AvdInfoParams*  params )
 {
     const char*  path;
 
-    if (params->forcePaths[sdcardImage] != NULL) {
+    if (params->forcePaths[AVD_IMAGE_SDCARD] != NULL)
         return;
-    }
 
-    path = iniFile_getString(i->configIni, iniKey);
+    path = iniFile_getString(i->configIni, SDCARD_PATH);
     if (path == NULL)
         return;
 
-    params->forcePaths[sdcardImage] = path;
+    params->forcePaths[AVD_IMAGE_SDCARD] = path;
 }
 
 AvdInfo*
@@ -1105,8 +1093,7 @@ avdInfo_new( const char*  name, AvdInfoParams*  params )
      * obsolete SDKs.
      */
     _getSearchPaths(i);
-    _getSDCardPath(i, params, AVD_IMAGE_SDCARD, SDCARD_PATH);
-    _getSDCardPath(i, params, AVD_IMAGE_SDCARD2, SDCARD2_PATH);
+    _getSDCardPath(i, params);
 
     /* don't need this anymore */
     iniFile_free(i->rootIni);
@@ -1274,9 +1261,6 @@ _getBuildImagePaths( AvdInfo*  i, AvdInfoParams*  params )
     if (!noSdCard) {
         imageLoader_set (l, AVD_IMAGE_SDCARD);
         imageLoader_load(l, IMAGE_OPTIONAL | IMAGE_IGNORE_IF_LOCKED);
-
-        imageLoader_set (l, AVD_IMAGE_SDCARD2);
-        imageLoader_load(l, IMAGE_OPTIONAL | IMAGE_IGNORE_IF_LOCKED);
     }
 
     return 0;
diff --git a/android/avd/info.h b/android/avd/info.h
index 75dab89..19df807 100644
--- a/android/avd/info.h
+++ b/android/avd/info.h
@@ -58,7 +58,6 @@
     _AVD_IMG(USERDATA,"userdata-qemu.img", "user data") \
     _AVD_IMG(CACHE,"cache.img","cache") \
     _AVD_IMG(SDCARD,"sdcard.img","SD Card") \
-    _AVD_IMG(SDCARD2,"sdcard2.img","SD Card 2") \
 
 /* define the enumared values corresponding to each AVD image type
  * examples are: AVD_IMAGE_KERNEL, AVD_IMAGE_SYSTEM, etc..
diff --git a/android/cmdline-options.h b/android/cmdline-options.h
index 20d308f..7a1a70f 100644
--- a/android/cmdline-options.h
+++ b/android/cmdline-options.h
@@ -76,7 +76,6 @@ CFG_PARAM( cache,    "<file>", "cache partition image (default is temporary file
 CFG_FLAG ( no_cache, "disable the cache partition" )
 CFG_FLAG ( nocache,  "same as -no-cache" )
 OPT_PARAM( sdcard, "<file>", "SD card image (default <system>/sdcard.img")
-OPT_PARAM( sdcard2, "<file>", "SD card 2 image (default <system>/sdcard2.img")
 OPT_FLAG ( wipe_data, "reset the use data image (copy it from initdata)" )
 CFG_PARAM( avd, "<name>", "use a specific android virtual device" )
 CFG_PARAM( skindir, "<dir>", "search skins in <dir> (default <system>/skins)" )
diff --git a/android/console.c b/android/console.c
index fa86151..8eb1497 100644
--- a/android/console.c
+++ b/android/console.c
@@ -31,8 +31,6 @@
 #include "hw/power_supply.h"
 #include "shaper.h"
 #include "modem_driver.h"
-#include "block.h"
-#include "block_int.h"
 #include "android/gps.h"
 #include "android/globals.h"
 #include "android/utils/bufprint.h"
@@ -2068,135 +2066,6 @@ static const CommandDefRec  geo_commands[] =
 /********************************************************************************************/
 /********************************************************************************************/
 /*****                                                                                 ******/
-/*****                       S D C A R D   C O M M A N D S                             ******/
-/*****                                                                                 ******/
-/********************************************************************************************/
-/********************************************************************************************/
-
-static int
-do_sdcard_insert( ControlClient  client, char*  args )
-{
-    char img[255];
-    char *p;
-    int n;
-    int drv_idx;
-
-    if (!args) {
-        control_write( client, "K0: argument missing, try 'sdcard insert <slot #> [imagefile]'\r\n" );
-        return -1;
-    }
-
-    memset(img, 0, sizeof(img));
-
-    n = strtoul(args, &p, 0);
-    if (n > 2) {
-        control_write( client, "K0: argument out of range\r\n" );
-        return -1;
-    }
-
-    if (p) {
-        p++;
-        strncpy(img, p, sizeof(img) -1);
-    }
-
-    if (goldfish_mmc_is_media_inserted(n)) {
-        control_write( client, "K0: Slot %d already has media inserted\r\n", n );
-        return -1;
-    }
-
-    drv_idx = drive_get_index( IF_IDE, 0, n);
-    if (drv_idx >= 0) {
-        if (img[0] != '\0' && strcmp(img, drives_table[drv_idx].bdrv->filename)) {
-            if (drive_swap(drives_table[drv_idx].bdrv, img)) {
-                control_write (client, "K0: Drive swap failed\r\n");
-                return -1;
-            }
-        }
-    } else {
-        drv_idx = drive_hotadd(img, "index=%d,media=disk", n);
-        if (drv_idx < 0) {
-                control_write (client, "K0: Drive hot-add failed\r\n");
-                return -1;
-        }
-    }
-
-    goldfish_mmc_insert(n, drives_table[drv_idx].bdrv);
-
-    return 0;
-}
-
-static int
-do_sdcard_remove( ControlClient  client, char*  args )
-{
-    int n;
-    int ins;
-
-    if (!args) {
-        control_write( client, "K0: argument missing, try 'sdcard remove <slot #>'\r\n" );
-        return -1;
-    }
-
-    n = atoi(args);
-
-    if ((ins = goldfish_mmc_is_media_inserted(n)) < 0) {
-        control_write( client, "K0: Slot %d is invalid\r\n", n );
-    } else if (!ins) {
-        control_write( client, "K0: Slot %d has no media\r\n", n );
-        return -1;
-    }
-
-    goldfish_mmc_remove(n);
-    return 0;
-}
-
-static int
-do_sdcard_status( ControlClient  client, char*  args )
-{
-    int i;
-    control_write( client, "Current SD card status:\r\n" );
-
-    for (i = 0; i < 2; i++) {
-        int drv_idx = drive_get_index( IF_IDE, 0, i);
-
-        control_write( client,
-                       "  Slot %d, image %s, inserted %d\r\n", i,
-                       (drv_idx >=0 ? drives_table[drv_idx].bdrv->filename : "none"),
-                       goldfish_mmc_is_media_inserted(i));
-    }
-    return 0;
-}
-
-static int
-do_sdcard_fail( ControlClient  client, char*  args )
-{
-	return -ENOSYS;
-}
-
-static const CommandDefRec  sdcard_commands[] =
-{
-    { "insert", "hot-insert a virtual sdcard",
-    "'sdcard insert <slot #> [imagefile]'\r\n",
-    NULL, do_sdcard_insert, NULL },
-
-    { "remove", "hot-remove a virtual sdcard",
-    "'sdcard remove <slot #>'\r\n",
-    NULL, do_sdcard_remove, NULL },
-
-    { "status", "query virtual device status",
-    "'sdcard status'\r\n",
-    NULL, do_sdcard_status, NULL },
-
-    { "fail", "simulate an sdcard failure",
-    "'sdcard fail <read|write>'\r\n",
-    NULL, do_sdcard_fail, NULL },
-
-    { NULL, NULL, NULL, NULL, NULL, NULL }
-};
-
-
-/********************************************************************************************/
-/********************************************************************************************/
-/*****                                                                                 ******/
 /*****                           M A I N   C O M M A N D S                             ******/
 /*****                                                                                 ******/
 /********************************************************************************************/
@@ -2307,10 +2176,6 @@ static const CommandDefRec   main_commands[] =
     "allows you to modify the emulator window\r\n", NULL,
     NULL, window_commands },
 
-    { "sdcard", "manage emulator sdcards",
-    "allows you to modify the emulator sdcard configuration\r\n", NULL,
-    NULL, sdcard_commands },
-
     { NULL, NULL, NULL, NULL, NULL, NULL }
 };
 
diff --git a/android/help.c b/android/help.c
index fe724a6..e8737f5 100644
--- a/android/help.c
+++ b/android/help.c
@@ -120,8 +120,8 @@ help_build_images( stralloc_t*  out )
 
     "  You can use the -sysdir, -system, -kernel, -ramdisk, -datadir, -data options\n"
     "  to specify different search directories or specific image files. You can\n"
-    "  also use the -cache, -sdcard, and -sdcard2 options to indicate specific \n"
-    "  cache partition and SD Card image files.\n\n"
+    "  also use the -cache and -sdcard options to indicate specific cache partition\n"
+    "  and SD Card image files.\n\n"
 
     "  For more details, see the corresponding -help-<option> section.\n\n"
 
@@ -166,7 +166,6 @@ help_disk_images( stralloc_t*  out )
     "    system-qemu.img    an *optional* persistent system image\n"
     "    cache.img          an *optional* cache partition image\n"
     "    sdcard.img         an *optional* SD Card partition image\n\n"
-    "    sdcard2.img        an *optional* second SD Card partition image\n\n"
 
     "  If you use a virtual device, its content directory should store\n"
     "  all writable images, and read-only ones will be found from the\n"
@@ -182,7 +181,7 @@ help_disk_images( stralloc_t*  out )
     "  can still run the emulator by explicitely providing the paths to\n"
     "  *all* required disk images through a combination of the following\n"
     "  options: -sysdir, -datadir, -kernel, -ramdisk, -system, -data, -cache\n"
-    "  -sdcard, and -sdcard2\n\n"
+    "  and -sdcard\n\n"
 
     "  The actual logic being that the emulator should be able to find all\n"
     "  images from the options you give it.\n\n"
@@ -622,21 +621,6 @@ help_sdcard(stralloc_t*  out)
 }
 
 static void
-help_sdcard2(stralloc_t*  out)
-{
-    PRINTF(
-    "  use '-sdcard2 <file>' to specify a second SD Card image file that will be attached\n"
-    "  to the emulator. By default, the 'sdcard.img' file is searched in the data\n"
-    "  directory.\n\n"
-
-    "  if the file does not exist, the emulator will still start, but without a\n"
-    "  second SD Card attached.\n\n"
-
-    "  see '-help-disk-images' for more information about disk image files\n\n"
-    );
-}
-
-static void
 help_skindir(stralloc_t*  out)
 {
     PRINTF(
diff --git a/android/main.c b/android/main.c
index 309adf6..7ff7910 100644
--- a/android/main.c
+++ b/android/main.c
@@ -1798,7 +1798,6 @@ int main(int argc, char **argv)
     int    n;
     char*  opt;
     int    use_sdcard_img = 0;
-    int    use_sdcard2_img = 0;
     int    serial = 0;
     int    gps_serial = 0;
     int    radio_serial = 0;
@@ -2063,14 +2062,6 @@ int main(int argc, char **argv)
                 D("autoconfig: -sdcard %s", opts->sdcard);
             }
         }
-
-        if (!opts->sdcard2 && opts->datadir) {
-            bufprint(tmp, tmpend, "%s/sdcard2.img", opts->datadir);
-            if (path_exists(tmp)) {
-                opts->sdcard2 = qemu_strdup(tmp);
-                D("autoconfig: -sdcard2 %s", opts->sdcard2);
-            }
-        }
     }
 
     /* setup the virtual device parameters from our options
@@ -2091,7 +2082,6 @@ int main(int argc, char **argv)
     _forceAvdImagePath(AVD_IMAGE_USERDATA,   opts->data,   "user data", 0);
     _forceAvdImagePath(AVD_IMAGE_CACHE,      opts->cache,  "cache", 0);
     _forceAvdImagePath(AVD_IMAGE_SDCARD,     opts->sdcard, "SD Card", 0);
-    _forceAvdImagePath(AVD_IMAGE_SDCARD2,    opts->sdcard2, "SD Card 2", 0);
 
     /* we don't accept -skindir without -skin now
      * to simplify the autoconfig stuff with virtual devices
@@ -2490,14 +2480,11 @@ int main(int argc, char **argv)
         args[n++] = strdup(tmp);
     }
 
-    if (hw->hw_sdCard != 0) {
+    if (hw->hw_sdCard != 0)
         opts->sdcard = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_SDCARD);
-        opts->sdcard2 = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_SDCARD2);
-
-    } else if (opts->sdcard || opts->sdcard2) {
+    else if (opts->sdcard) {
         dwarning( "Emulated hardware doesn't support SD Cards" );
         opts->sdcard = NULL;
-        opts->sdcard2 = NULL;
     }
 
     if(opts->sdcard) {
@@ -2519,25 +2506,6 @@ int main(int argc, char **argv)
         }
     }
 
-    if(opts->sdcard2) {
-        uint64_t  size;
-        if (path_get_size(opts->sdcard2, &size) == 0) {
-            /* see if we have an sdcard image.  get its size if it exists */
-            /* due to what looks like limitations of the MMC protocol, one has
-             * to use an SD Card image that is equal or larger than 9 MB
-             */
-            if (size < 9*1024*1024ULL) {
-                fprintf(stderr, "### WARNING: SD Card files must be at least 9MB, ignoring '%s'\n", opts->sdcard2);
-            } else {
-                args[n++] = "-hdb";
-                args[n++] = opts->sdcard2;
-                use_sdcard2_img = 1;
-            }
-        } else {
-            D("no SD Card image at '%s'", opts->sdcard2);
-        }
-    }
-
     if (!opts->logcat || opts->logcat[0] == 0) {
         opts->logcat = getenv("ANDROID_LOG_TAGS");
         if (opts->logcat && opts->logcat[0] == 0)
diff --git a/hw/android_arm.c b/hw/android_arm.c
index ce36c8f..f5df7f2 100644
--- a/hw/android_arm.c
+++ b/hw/android_arm.c
@@ -49,18 +49,7 @@ static struct goldfish_device nand_device = {
 
 /* Board init.  */
 
-static void goldfish_sdcard_init(int n, unsigned base)
-{
-    int idx = drive_get_index( IF_IDE, 0, n );
-
-    goldfish_mmc_init(base, n);
-
-    if (idx >= 0) {
-        goldfish_mmc_insert(n, drives_table[idx].bdrv);
-    }
-}
-
-// #define TEST_SWITCH 1
+#define TEST_SWITCH 1
 #if TEST_SWITCH
 uint32_t switch_test_write(void *opaque, uint32_t state)
 {
@@ -131,9 +120,11 @@ static void android_arm_init_(ram_addr_t ram_size,
 #ifdef HAS_AUDIO
     goldfish_audio_init(0xff004000, 0, audio_input_source);
 #endif
-
-    goldfish_sdcard_init(0, 0xff005000);
-    goldfish_sdcard_init(1, 0xff007000);
+    {
+        int  idx = drive_get_index( IF_IDE, 0, 0 );
+        if (idx >= 0)
+            goldfish_mmc_init(0xff005000, 0, drives_table[idx].bdrv);
+    }
 
     goldfish_memlog_init(0xff006000);
 
diff --git a/hw/goldfish_device.h b/hw/goldfish_device.h
index d0739b7..d04a166 100644
--- a/hw/goldfish_device.h
+++ b/hw/goldfish_device.h
@@ -46,12 +46,7 @@ void goldfish_audio_init(uint32_t base, int id, const char* input_source);
 void goldfish_battery_init();
 void goldfish_battery_set_prop(int ac, int property, int value);
 void goldfish_battery_display(void (* callback)(void *data, const char* string), void *data);
-
-void goldfish_mmc_init(uint32_t base, int id);
-void goldfish_mmc_insert(int id, BlockDriverState* bs);
-void goldfish_mmc_remove(int id);
-int goldfish_mmc_is_media_inserted(int id);
-
+void goldfish_mmc_init(uint32_t base, int id, BlockDriverState* bs);
 void *goldfish_switch_add(char *name, uint32_t (*writefn)(void *opaque, uint32_t state), void *writeopaque, int id);
 void goldfish_switch_set_state(void *opaque, uint32_t state);
 
diff --git a/hw/goldfish_mmc.c b/hw/goldfish_mmc.c
index 8b5c137..3824db9 100644
--- a/hw/goldfish_mmc.c
+++ b/hw/goldfish_mmc.c
@@ -52,7 +52,6 @@ enum {
     MMC_STAT_END_OF_CMD     = 1U << 0,
     MMC_STAT_END_OF_DATA    = 1U << 1,
     MMC_STAT_STATE_CHANGE   = 1U << 2,
-    MMC_STAT_CMD_TIMEOUT    = 1U << 3,
 
     /* MMC_STATE bits */
     MMC_STATE_INSERTED     = 1U << 0,
@@ -83,9 +82,6 @@ struct goldfish_mmc_state {
     uint8_t* buf;
 };
 
-#define GOLDFISH_MMC_MAX 2
-static struct goldfish_mmc_state *gDrvState[GOLDFISH_MMC_MAX];
-
 #define  GOLDFISH_MMC_SAVE_VERSION  2
 #define  QFIELD_STRUCT  struct goldfish_mmc_state
 QFIELD_BEGIN(goldfish_mmc_fields)
@@ -222,24 +218,13 @@ static void goldfish_mmc_do_command(struct goldfish_mmc_state *s, uint32_t cmd,
     int new_status = MMC_STAT_END_OF_CMD;
     int opcode = cmd & 63;
 
- //fprintf(stderr, "goldfish_mmc_do_command opcode: %s (0x%04X), arg: %d\n", get_command_name(opcode), cmd, arg);
+// fprintf(stderr, "goldfish_mmc_do_command opcode: %s (0x%04X), arg: %d\n", get_command_name(opcode), cmd, arg);
+
     s->resp[0] = 0;
     s->resp[1] = 0;
     s->resp[2] = 0;
     s->resp[3] = 0;
 
-    if (!s->bs) {
-        /*
-         * No backing store available. Signal a command timeout
-         * to the host. If the command timeout irq enable is set
-         * then also set the status bit - otherwise we're assuming
-         * a legacy driver which doesnt support timeouts.
-         */
-        if (s->int_enable & MMC_STAT_CMD_TIMEOUT)
-            new_status |= MMC_STAT_CMD_TIMEOUT;
-        goto skip;
-    }
-
 #define SET_R1_CURRENT_STATE(s)    ((s << 9) & 0x00001E00) /* sx, b (4 bits) */
 
     switch (opcode) {
@@ -420,7 +405,6 @@ static void goldfish_mmc_do_command(struct goldfish_mmc_state *s, uint32_t cmd,
             break;
      }
 
- skip:
     s->int_status |= new_status;
 
     if ((s->int_status & s->int_enable)) {
@@ -430,7 +414,7 @@ static void goldfish_mmc_do_command(struct goldfish_mmc_state *s, uint32_t cmd,
 
 static uint32_t goldfish_mmc_read(void *opaque, target_phys_addr_t offset)
 {
-    uint32_t ret = 0;
+    uint32_t ret;
     struct goldfish_mmc_state *s = opaque;
 
     switch(offset) {
@@ -446,11 +430,9 @@ static uint32_t goldfish_mmc_read(void *opaque, target_phys_addr_t offset)
         case MMC_RESP_3:
             return s->resp[3];
         case MMC_STATE: {
-            if (s->bs) {
-                ret = MMC_STATE_INSERTED;
-                if (bdrv_is_read_only(s->bs)) {
-                    ret |= MMC_STATE_READ_ONLY;
-                }
+            ret = MMC_STATE_INSERTED;
+            if (bdrv_is_read_only(s->bs)) {
+                ret |= MMC_STATE_READ_ONLY;
             }
             return ret;
         }
@@ -517,71 +499,22 @@ static CPUWriteMemoryFunc *goldfish_mmc_writefn[] = {
    goldfish_mmc_write
 };
 
-void goldfish_mmc_init(uint32_t base, int id)
+void goldfish_mmc_init(uint32_t base, int id, BlockDriverState* bs)
 {
     struct goldfish_mmc_state *s;
 
-    if (id >= GOLDFISH_MMC_MAX) {
-        fprintf(stderr, "mmc controller %d out of range\n", id);
-        return;
-    }
-
     s = (struct goldfish_mmc_state *)qemu_mallocz(sizeof(*s));
     s->dev.name = "goldfish_mmc";
     s->dev.id = id;
     s->dev.base = base;
     s->dev.size = 0x1000;
     s->dev.irq_count = 1;
-    s->bs = NULL;
+    s->bs = bs;
     s->buf = qemu_memalign(512,512);
 
-    gDrvState[id] = s;
-
     goldfish_device_add(&s->dev, goldfish_mmc_readfn, goldfish_mmc_writefn, s);
 
-    register_savevm( (!id ? "goldfish_mmc0" : "goldfish_mmc1"),
-                     id, GOLDFISH_MMC_SAVE_VERSION,
+    register_savevm( "goldfish_mmc", 0, GOLDFISH_MMC_SAVE_VERSION,
                      goldfish_mmc_save, goldfish_mmc_load, s);
 }
 
-static void goldfish_mmc_setbs(struct goldfish_mmc_state* s, BlockDriverState* bs)
-{
-    s->bs = bs;
-    s->int_status |= MMC_STAT_STATE_CHANGE;
-
-    /*
-     * Legacy - only send state change irq if
-     * the driver has the CMD_TIMEOUT irq enabled.
-     */
-    if (s->int_enable & MMC_STAT_CMD_TIMEOUT)
-        goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-}
-
-void goldfish_mmc_insert(int id, BlockDriverState* bs)
-{
-    if (id >= GOLDFISH_MMC_MAX) {
-        return -1;
-    }
-
-    goldfish_mmc_setbs(gDrvState[id], bs);
-}
-
-int goldfish_mmc_is_media_inserted(int id)
-{
-    if (id > GOLDFISH_MMC_MAX) {
-        return -1;
-    }
-
-    return (gDrvState[id]->bs != NULL);
-}
-
-void goldfish_mmc_remove(int id)
-{
-    if (id >= GOLDFISH_MMC_MAX) {
-        return -1;
-    }
-
-    goldfish_mmc_setbs(gDrvState[id], NULL);
-}
-
-
diff --git a/sysemu.h b/sysemu.h
index 7959197..fe24415 100644
--- a/sysemu.h
+++ b/sysemu.h
@@ -173,7 +173,6 @@ extern int nb_drives;
 extern DriveInfo drives_table[MAX_DRIVES+1];
 
 extern int drive_get_index(BlockInterfaceType type, int bus, int unit);
-extern int drive_get_index_by_bdrv(BlockDriverState *bdrv);
 extern int drive_get_max_bus(BlockInterfaceType type);
 extern void drive_uninit(BlockDriverState *bdrv);
 extern void drive_remove(int index);
@@ -193,8 +192,6 @@ extern int nb_drives_opt;
 
 extern int drive_add(const char *file, const char *fmt, ...);
 extern int drive_init(struct drive_opt *arg, int snapshot, void *machine);
-extern int drive_swap(struct BlockDriverState *bdrv, const char *file);
-extern int drive_hotadd(const char *file, const char *fmt, ...);
 
 /* acpi */
 void qemu_system_hot_add_init(void);
diff --git a/vl-android.c b/vl-android.c
index 5d234a2..d6feced 100644
--- a/vl-android.c
+++ b/vl-android.c
@@ -2223,41 +2223,6 @@ static int drive_get_free_idx(void)
     return -1;
 }
 
-int drive_swap(BlockDriverState *bdrv, const char *file)
-{
-    int index = drive_get_index_by_bdrv(bdrv);
-    int unit = drives_table[index].unit;
-    int opt_idx;
-
-    bdrv_close(bdrv);
-    drive_uninit(bdrv);
-    bdrv_delete(bdrv);
-
-    opt_idx = drive_add(file, HD_ALIAS, unit);
-    return drive_init(&drives_opt[opt_idx], 0, current_machine);
-}
-
-int drive_hotadd(const char *file, const char *fmt, ...)
-{
-    va_list ap;
-    int index = drive_opt_get_free_idx();
-
-    if (nb_drives_opt >= MAX_DRIVES || index == -1) {
-        fprintf(stderr, "qemu: too many drives\n");
-        return -1;
-    }
-
-    drives_opt[index].file = file;
-    va_start(ap, fmt);
-    vsnprintf(drives_opt[index].opt,
-              sizeof(drives_opt[0].opt), fmt, ap);
-    va_end(ap);
-    nb_drives_opt++;
-    if (drive_init(&drives_opt[index], 0, current_machine) < 0)
-        return -1;
-    return index;
-}
-
 int drive_add(const char *file, const char *fmt, ...)
 {
     va_list ap;
@@ -2273,6 +2238,7 @@ int drive_add(const char *file, const char *fmt, ...)
     vsnprintf(drives_opt[index].opt,
               sizeof(drives_opt[0].opt), fmt, ap);
     va_end(ap);
+
     nb_drives_opt++;
     return index;
 }
@@ -2283,15 +2249,6 @@ void drive_remove(int index)
     nb_drives_opt--;
 }
 
-int drive_get_index_by_bdrv(BlockDriverState *bdrv)
-{
-    int index;
-
-    for (index = 0; index < MAX_DRIVES; index++)
-        if (drives_table[index].bdrv == bdrv)
-            return index;
-    return -1;
-}
 int drive_get_index(BlockInterfaceType type, int bus, int unit)
 {
     int index;