Use "mount" as card verb

Marlin/src/HAL/HAL_DUE/usb/sd_mmc_spi_mem.cpp

 }
 
 Ctrl_status sd_mmc_spi_test_unit_ready(void) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
     return CTRL_NO_PRESENT;
   return CTRL_GOOD;
 }
 // NOTE: This function is defined as returning the address of the last block
 // in the card, which is cardSize() - 1
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
     return CTRL_NO_PRESENT;
   *nb_sector = card.getSd2Card().cardSize() - 1;
   return CTRL_GOOD;
 }
 
 bool sd_mmc_spi_removal(void) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
     return true;
   return false;
 }
 // #define DEBUG_MMC
 
 Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC
 }
 
 Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC

Marlin/src/HAL/HAL_LPC1768/main.cpp

     // the disk if Marlin has it mounted. Unfortuately there is currently no way
     // to unmount the disk from the LCD menu.
     // if (IS_SD_PRINTING() || IS_SD_FILE_OPEN())
-    if (card.isDetected())
+    if (card.isMounted())
       MSC_Aquire_Lock();
     else
       MSC_Release_Lock();

Marlin/src/HAL/HAL_STM32/persistent_store_sdcard.cpp

   #define EEPROM_FILENAME "eeprom.dat"
 
   bool PersistentStore::access_start() {
-    if (!card.isDetected()) return false;
+    if (!card.isMounted()) return false;
 
     SdFile file, root = card.getroot();
     if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
   }
 
   bool PersistentStore::access_finish() {
-    if (!card.isDetected()) return false;
+    if (!card.isMounted()) return false;
 
     SdFile file, root = card.getroot();
     int bytes_written = 0;

Marlin/src/HAL/HAL_STM32F1/persistent_store_sdcard.cpp

   #define EEPROM_FILENAME "eeprom.dat"
 
   bool PersistentStore::access_start() {
-    if (!card.isDetected()) return false;
+    if (!card.isMounted()) return false;
 
     SdFile file, root = card.getroot();
     if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
   }
 
   bool PersistentStore::access_finish() {
-    if (!card.isDetected()) return false;
+    if (!card.isMounted()) return false;
 
     SdFile file, root = card.getroot();
     int bytes_written = 0;

Marlin/src/Marlin.cpp

   #endif
 
   #if ENABLED(SDSUPPORT)
-    // Auto-mount the SD
-    card.initsd();
+    card.mount(); // Mount the SD card before settings.first_load
   #endif
 
   // Load data from EEPROM if available (or use defaults)

Marlin/src/feature/binary_protocol.h

 
   static bool file_open(char* filename) {
     if (!dummy_transfer) {
-      card.initsd();
+      card.mount();
       card.openFile(filename, false);
       if (!card.isFileOpen()) return false;
     }

Marlin/src/feature/power_loss_recovery.cpp

  */
 void PrintJobRecovery::check() {
   if (enabled) {
-    if (!card.isDetected()) card.initsd();
-    if (card.isDetected()) {
+    if (!card.isMounted()) card.mount();
+    if (card.isMounted()) {
       load();
       if (!valid()) return purge();
       queue.inject_P(PSTR("M1000 S"));

Marlin/src/gcode/sdcard/M21_M22.cpp

 /**
  * M21: Init SD Card
  */
-void GcodeSuite::M21() { card.initsd(); }
+void GcodeSuite::M21() { card.mount(); }
 
 /**
  * M22: Release SD Card

Marlin/src/gcode/sdcard/M26.cpp

  * M26: Set SD Card file index
  */
 void GcodeSuite::M26() {
-  if (card.isDetected() && parser.seenval('S'))
+  if (card.isMounted() && parser.seenval('S'))
     card.setIndex(parser.value_long());
 }
 

Marlin/src/gcode/sdcard/M30.cpp

  * M30 <filename>: Delete SD Card file
  */
 void GcodeSuite::M30() {
-  if (card.isDetected()) {
+  if (card.isMounted()) {
     card.closefile();
     card.removeFile(parser.string_arg);
   }

Marlin/src/gcode/sdcard/M32.cpp

 void GcodeSuite::M32() {
   if (IS_SD_PRINTING()) planner.synchronize();
 
-  if (card.isDetected()) {
+  if (card.isMounted()) {
     const bool call_procedure = parser.boolval('P');
 
     card.openFile(parser.string_arg, true, call_procedure);

Marlin/src/lcd/extensible_ui/ui_api.cpp

   }
 
   bool isMediaInserted() {
-    return IFSD(IS_SD_INSERTED() && card.isDetected(), false);
+    return IFSD(IS_SD_INSERTED() && card.isMounted(), false);
   }
 
   void pausePrint() {
     if (sd_status != last_sd_status) {
       last_sd_status = sd_status;
       if (sd_status) {
-        card.initsd();
-        if (card.isDetected())
+        card.mount();
+        if (card.isMounted())
           ExtUI::onMediaInserted();
         else
           ExtUI::onMediaError();
       }
       else {
-        const bool ok = card.isDetected();
+        const bool ok = card.isMounted();
         card.release();
         if (ok) ExtUI::onMediaRemoved();
       }

Marlin/src/lcd/extui_malyan_lcd.cpp

 
     case 'L': {
       #if ENABLED(SDSUPPORT)
-        if (!card.isDetected()) card.initsd();
+        if (!card.isMounted()) card.mount();
 
         // A more efficient way to do this would be to
         // implement a callback in the ls_SerialPrint code, but

Marlin/src/lcd/menu/menu_main.cpp

 
   const bool busy = IS_SD_PRINTING() || print_job_timer.isRunning()
     #if ENABLED(SDSUPPORT)
-      , card_detected = card.isDetected()
+      , card_detected = card.isMounted()
       , card_open = card_detected && card.isFileOpen()
     #endif
   ;

Marlin/src/lcd/menu/menu_media.cpp

 #if !PIN_EXISTS(SD_DETECT)
   void lcd_sd_refresh() {
     encoderTopLine = 0;
-    card.initsd();
+    card.mount();
   }
 #endif
 
       MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
     #endif
   }
-  else if (card.isDetected())
+  else if (card.isMounted())
     MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
 
   if (ui.should_draw()) for (uint16_t i = 0; i < fileCnt; i++) {

Marlin/src/lcd/ultralcd.cpp

 
       if (sd_status) {
         safe_delay(500); // Some boards need a delay to get settled
-        card.initsd();
+        card.mount();
         if (old_sd_status == 2)
           card.beginautostart();  // Initial boot
         else

Marlin/src/sd/cardreader.cpp

       //sort_reverse = false;
     #endif
   #endif
-  flag.sdprinting = flag.detected = flag.saving = flag.logging = false;
+  flag.sdprinting = flag.mounted = flag.saving = flag.logging = false;
   filesize = sdpos = 0;
   file_subcall_ctr = 0;
 
   SERIAL_EOL();
 }
 
-void CardReader::initsd() {
-  flag.detected = false;
+void CardReader::mount() {
+  flag.mounted = false;
   if (root.isOpen()) root.close();
 
   #ifndef SPI_SPEED
   else if (!root.openRoot(&volume))
     SERIAL_ERROR_MSG(MSG_SD_OPENROOT_FAIL);
   else {
-    flag.detected = true;
+    flag.mounted = true;
     SERIAL_ECHO_MSG(MSG_SD_CARD_OK);
     #if ENABLED(EEPROM_SETTINGS) && NONE(FLASH_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
       settings.first_load();
 
 void CardReader::release() {
   stopSDPrint();
-  flag.detected = false;
+  flag.mounted = false;
 }
 
 void CardReader::openAndPrintFile(const char *name) {
 }
 
 void CardReader::startFileprint() {
-  if (isDetected()) {
+  if (isMounted()) {
     flag.sdprinting = true;
     #if SD_RESORT
       flush_presort();
 
 void CardReader::openFile(char * const path, const bool read, const bool subcall/*=false*/) {
 
-  if (!isDetected()) return;
+  if (!isMounted()) return;
 
   uint8_t doing = 0;
   if (isFileOpen()) {                     // Replacing current file or doing a subroutine
 }
 
 void CardReader::removeFile(const char * const name) {
-  if (!isDetected()) return;
+  if (!isMounted()) return;
 
   //stopSDPrint();
 
 
   if (autostart_index < 0 || flag.sdprinting) return;
 
-  if (!isDetected()) initsd();
+  if (!isMounted()) mount();
   #if ENABLED(EEPROM_SETTINGS) && NONE(FLASH_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
     else settings.first_load();
   #endif
 
-  if (isDetected()
+  if (isMounted()
     #if ENABLED(POWER_LOSS_RECOVERY)
       && !recovery.valid() // Don't run auto#.g when a resume file exists
     #endif
   }
 
   void CardReader::openJobRecoveryFile(const bool read) {
-    if (!isDetected()) return;
+    if (!isMounted()) return;
     if (recovery.file.isOpen()) return;
     if (!recovery.file.open(&root, recovery.filename, read ? O_READ : O_CREAT | O_WRITE | O_TRUNC | O_SYNC))
       SERIAL_ECHOLNPAIR(MSG_SD_OPEN_FILE_FAIL, recovery.filename, ".");

Marlin/src/sd/cardreader.h

   bool saving:1,
        logging:1,
        sdprinting:1,
-       detected:1,
+       mounted:1,
        filenameIsDir:1,
        abort_sd_printing:1
        #if ENABLED(BINARY_FILE_TRANSFER)
 public:
   CardReader();
 
-  static void initsd();
+  static void mount();
   static void write_command(char *buf);
 
   static void beginautostart();
   #endif
 
   static inline void pauseSDPrint() { flag.sdprinting = false; }
-  static inline bool isDetected() { return flag.detected; }
-  static inline bool isFileOpen() { return isDetected() && file.isOpen(); }
+  static inline bool isMounted() { return flag.mounted; }
+  static inline bool isFileOpen() { return isMounted() && file.isOpen(); }
   static inline bool isPaused() { return isFileOpen() && !flag.sdprinting; }
   static inline bool isPrinting() { return flag.sdprinting; }
   static inline bool eof() { return sdpos >= filesize; }