🎨 Apply F() to UTF-8/MMU2 string put

Marlin/src/HAL/shared/progmem.h

 #define strrchr_P(str, c) strrchr((str), (c))
 #endif
 #ifndef strsep_P
-#define strsep_P(strp, delim) strsep((strp), (delim))
+#define strsep_P(pstr, delim) strsep((pstr), (delim))
 #endif
 #ifndef strspn_P
 #define strspn_P(str, chrs) strspn((str), (chrs))

Marlin/src/feature/mmu/mmu2.cpp

 #define MMU_CMD_TIMEOUT 45000UL // 45s timeout for mmu commands (except P0)
 #define MMU_P0_TIMEOUT 3000UL   // Timeout for P0 command: 3seconds
 
-#define MMU2_COMMAND(S) tx_str_P(PSTR(S "\n"))
+#define MMU2_COMMAND(S) tx_str(F(S "\n"))
 
 #if ENABLED(MMU_EXTRUDER_SENSOR)
   uint8_t mmu_idl_sens = 0;
       if (cmd) {
         if (WITHIN(cmd, MMU_CMD_T0, MMU_CMD_T0 + EXTRUDERS - 1)) {
           // tool change
-          int filament = cmd - MMU_CMD_T0;
+          const int filament = cmd - MMU_CMD_T0;
           DEBUG_ECHOLNPGM("MMU <= T", filament);
-          tx_printf_P(PSTR("T%d\n"), filament);
+          tx_printf(F("T%d\n"), filament);
           TERN_(MMU_EXTRUDER_SENSOR, mmu_idl_sens = 1); // enable idler sensor, if any
           state = 3; // wait for response
         }
         else if (WITHIN(cmd, MMU_CMD_L0, MMU_CMD_L0 + EXTRUDERS - 1)) {
           // load
-          int filament = cmd - MMU_CMD_L0;
+          const int filament = cmd - MMU_CMD_L0;
           DEBUG_ECHOLNPGM("MMU <= L", filament);
-          tx_printf_P(PSTR("L%d\n"), filament);
+          tx_printf(F("L%d\n"), filament);
           state = 3; // wait for response
         }
         else if (cmd == MMU_CMD_C0) {
         }
         else if (WITHIN(cmd, MMU_CMD_E0, MMU_CMD_E0 + EXTRUDERS - 1)) {
           // eject filament
-          int filament = cmd - MMU_CMD_E0;
+          const int filament = cmd - MMU_CMD_E0;
           DEBUG_ECHOLNPGM("MMU <= E", filament);
-          tx_printf_P(PSTR("E%d\n"), filament);
+          tx_printf(F("E%d\n"), filament);
           state = 3; // wait for response
         }
         else if (cmd == MMU_CMD_R0) {
         }
         else if (WITHIN(cmd, MMU_CMD_F0, MMU_CMD_F0 + EXTRUDERS - 1)) {
           // filament type
-          int filament = cmd - MMU_CMD_F0;
+          const int filament = cmd - MMU_CMD_F0;
           DEBUG_ECHOLNPGM("MMU <= F", filament, " ", cmd_arg);
-          tx_printf_P(PSTR("F%d %d\n"), filament, cmd_arg);
+          tx_printf(F("F%d %d\n"), filament, cmd_arg);
           state = 3; // wait for response
         }
 
  */
 bool MMU2::rx_start() {
   // check for start message
-  return rx_str_P(PSTR("start\n"));
+  return rx_str(F("start\n"));
 }
 
 /**
  * Check if the data received ends with the given string.
  */
-bool MMU2::rx_str_P(const char *str) {
+bool MMU2::rx_str(FSTR_P fstr) {
+  PGM_P pstr = FTOP(fstr);
+
   uint8_t i = strlen(rx_buffer);
 
   while (MMU2_SERIAL.available()) {
   }
   rx_buffer[i] = '\0';
 
-  uint8_t len = strlen_P(str);
+  uint8_t len = strlen_P(pstr);
 
   if (i < len) return false;
 
-  str += len;
+  pstr += len;
 
   while (len--) {
-    char c0 = pgm_read_byte(str--), c1 = rx_buffer[i--];
+    char c0 = pgm_read_byte(pstr--), c1 = rx_buffer[i--];
     if (c0 == c1) continue;
     if (c0 == '\r' && c1 == '\n') continue;  // match cr as lf
     if (c0 == '\n' && c1 == '\r') continue;  // match lf as cr
 /**
  * Transfer data to MMU, no argument
  */
-void MMU2::tx_str_P(const char *str) {
+void MMU2::tx_str(FSTR_P fstr) {
   clear_rx_buffer();
-  uint8_t len = strlen_P(str);
-  LOOP_L_N(i, len) MMU2_SERIAL.write(pgm_read_byte(str++));
+  PGM_P pstr = FTOP(fstr);
+  while (const char c = pgm_read_byte(pstr)) { MMU2_SERIAL.write(c); pstr++; }
   prev_request = millis();
 }
 
 /**
  * Transfer data to MMU, single argument
  */
-void MMU2::tx_printf_P(const char *format, int argument = -1) {
+void MMU2::tx_printf(FSTR_P format, int argument = -1) {
   clear_rx_buffer();
-  uint8_t len = sprintf_P(tx_buffer, format, argument);
+  const uint8_t len = sprintf_P(tx_buffer, FTOP(format), argument);
   LOOP_L_N(i, len) MMU2_SERIAL.write(tx_buffer[i]);
   prev_request = millis();
 }
 /**
  * Transfer data to MMU, two arguments
  */
-void MMU2::tx_printf_P(const char *format, int argument1, int argument2) {
+void MMU2::tx_printf(FSTR_P format, int argument1, int argument2) {
   clear_rx_buffer();
-  uint8_t len = sprintf_P(tx_buffer, format, argument1, argument2);
+  const uint8_t len = sprintf_P(tx_buffer, FTOP(format), argument1, argument2);
   LOOP_L_N(i, len) MMU2_SERIAL.write(tx_buffer[i]);
   prev_request = millis();
 }
  * Check if we received 'ok' from MMU
  */
 bool MMU2::rx_ok() {
-  if (rx_str_P(PSTR("ok\n"))) {
+  if (rx_str(F("ok\n"))) {
     prev_P0_request = millis();
     return true;
   }
     if (cmd == MMU_CMD_NONE && last_cmd == MMU_CMD_C0) {
       if (present && !mmu2s_triggered) {
         DEBUG_ECHOLNPGM("MMU <= 'A'");
-        tx_str_P(PSTR("A\n"));
+        tx_str(F("A\n"));
       }
       // Slowly spin the extruder during C0
       else {

Marlin/src/feature/mmu/mmu2.h

   static bool eject_filament(const uint8_t index, const bool recover);
 
 private:
-  static bool rx_str_P(const char *str);
-  static void tx_str_P(const char *str);
-  static void tx_printf_P(const char *format, const int argument);
-  static void tx_printf_P(const char *format, const int argument1, const int argument2);
+  static inline bool rx_str(FSTR_P fstr);
+  static inline void tx_str(FSTR_P fstr);
+  static inline void tx_printf(FSTR_P ffmt, const int argument);
+  static inline void tx_printf(FSTR_P ffmt, const int argument1, const int argument2);
   static void clear_rx_buffer();
 
   static bool rx_ok();

Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp

   return lcd_put_u8str_max_cb(utf8_str, read_byte_ram, max_length);
 }
 
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
-  return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length) {
+  return lcd_put_u8str_max_cb(utf8_pstr, read_byte_rom, max_length);
 }
 
 #if ENABLED(DEBUG_LCDPRINT)

Marlin/src/lcd/HD44780/marlinui_HD44780.cpp

   }
 
   // Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
-  void lcd_scroll(const lcd_uint_t col, const lcd_uint_t line, PGM_P const text, const uint8_t len, const int16_t time) {
-    uint8_t slen = utf8_strlen_P(text);
+  void lcd_scroll(const lcd_uint_t col, const lcd_uint_t line, FSTR_P const ftxt, const uint8_t len, const int16_t time) {
+    uint8_t slen = utf8_strlen_P(FTOP(ftxt));
     if (slen < len) {
-      lcd_put_u8str_max_P(col, line, text, len);
+      lcd_put_u8str_max(col, line, ftxt, len);
       for (; slen < len; ++slen) lcd_put_wchar(' ');
       safe_delay(time);
     }
     else {
-      PGM_P p = text;
+      PGM_P p = FTOP(ftxt);
       int dly = time / _MAX(slen, 1);
       LOOP_LE_N(i, slen) {
 
 
   static void logo_lines(PGM_P const extra) {
     int16_t indent = (LCD_WIDTH - 8 - utf8_strlen_P(extra)) / 2;
-    lcd_put_wchar(indent, 0, '\x00'); lcd_put_u8str_P(PSTR( "------" ));  lcd_put_wchar('\x01');
-    lcd_put_u8str_P(indent, 1, PSTR("|Marlin|"));  lcd_put_u8str_P(extra);
-    lcd_put_wchar(indent, 2, '\x02'); lcd_put_u8str_P(PSTR( "------" ));  lcd_put_wchar('\x03');
+    lcd_put_wchar(indent, 0, '\x00'); lcd_put_u8str(F( "------" ));  lcd_put_wchar('\x01');
+    lcd_put_u8str(indent, 1, F("|Marlin|"));  lcd_put_u8str_P(extra);
+    lcd_put_wchar(indent, 2, '\x02'); lcd_put_u8str(F( "------" ));  lcd_put_wchar('\x03');
   }
 
   void MarlinUI::show_bootscreen() {
 
     #define LCD_EXTRA_SPACE (LCD_WIDTH-8)
 
-    #define CENTER_OR_SCROLL(STRING,DELAY) \
+    #define CENTER_OR_SCROLL(STRING,DELAY) { \
       lcd_erase_line(3); \
-      if (utf8_strlen(STRING) <= LCD_WIDTH) { \
-        lcd_put_u8str_P((LCD_WIDTH - utf8_strlen_P(PSTR(STRING))) / 2, 3, PSTR(STRING)); \
+      const int len = utf8_strlen(STRING); \
+      if (len <= LCD_WIDTH) { \
+        lcd_put_u8str((LCD_WIDTH - len) / 2, 3, F(STRING)); \
         safe_delay(DELAY); \
       } \
-      else { \
-        lcd_scroll(0, 3, PSTR(STRING), LCD_WIDTH, DELAY); \
-      }
+      else \
+        lcd_scroll(0, 3, F(STRING), LCD_WIDTH, DELAY); \
+    }
 
     //
     // Show the Marlin logo with splash line 1
   lcd_put_u8str(0, 0, status_message);
   lcd_uint_t y = 2;
   #if LCD_HEIGHT >= 4
-    lcd_put_u8str_P(0, y++, GET_TEXT(MSG_HALTED));
+    lcd_put_u8str(0, y++, GET_TEXT_F(MSG_HALTED));
   #endif
-  lcd_put_u8str_P(0, y, GET_TEXT(MSG_PLEASE_RESET));
+  lcd_put_u8str(0, y, GET_TEXT_F(MSG_PLEASE_RESET));
 }
 
 //
   else if (axis_should_home(axis))
     while (const char c = *value++) lcd_put_wchar(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
-    lcd_put_u8str_P(axis == Z_AXIS ? PSTR("       ") : PSTR("    "));
+    lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
     lcd_put_u8str(value);
 }
 
   FORCE_INLINE void _draw_print_progress() {
     const uint8_t progress = ui.get_progress_percent();
-    lcd_put_u8str_P(PSTR(TERN(SDSUPPORT, "SD", "P:")));
+    lcd_put_u8str(F(TERN(SDSUPPORT, "SD", "P:")));
     if (progress)
       lcd_put_u8str(ui8tostr3rj(progress));
     else
-      lcd_put_u8str_P(PSTR("---"));
+      lcd_put_u8str(F("---"));
     lcd_put_wchar('%');
   }
 
 
     // Alternate Status message and Filament display
     if (ELAPSED(millis(), next_filament_display)) {
-      lcd_put_u8str_P(PSTR("Dia "));
+      lcd_put_u8str(F("Dia "));
       lcd_put_u8str(ftostr12ns(filwidth.measured_mm));
-      lcd_put_u8str_P(PSTR(" V"));
+      lcd_put_u8str(F(" V"));
       lcd_put_u8str(i16tostr3rj(planner.volumetric_percent(parser.volumetric_enabled)));
       lcd_put_wchar('%');
       return;
         if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
-          lcd_put_u8str_P(PSTR(" -----"));
+          lcd_put_u8str(F(" -----"));
 
       #else                 // 16x4 or 20x4 display
 
         if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
-          lcd_put_u8str_P(PSTR(" -----"));
+          lcd_put_u8str(F(" -----"));
 
       #endif // LCD_HEIGHT > 3
     }

Marlin/src/lcd/TFTGLCD/lcdprint_TFTGLCD.cpp

   return lcd_put_u8str_max_cb(utf8_str, read_byte_ram, max_length);
 }
 
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
-  return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length) {
+  return lcd_put_u8str_max_cb(utf8_pstr, read_byte_rom, max_length);
 }
 
 #if ENABLED(DEBUG_LCDPRINT)

Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp

     uint8_t indent = (LCD_WIDTH - 8) / 2;
     // symbols 217 (bottom right corner) and 218 (top left corner) are using for letters in some languages
     // and they should be moved to beginning ASCII table as special symbols
-    lcd.setCursor(indent, 0); lcd.write(TLC); lcd_put_u8str_P(PSTR("------"));  lcd.write(TRC);
-    lcd.setCursor(indent, 1); lcd.write(LR);  lcd_put_u8str_P(PSTR("Marlin"));  lcd.write(LR);
-    lcd.setCursor(indent, 2); lcd.write(BLC); lcd_put_u8str_P(PSTR("------"));  lcd.write(BRC);
+    lcd.setCursor(indent, 0); lcd.write(TLC); lcd_put_u8str(F("------"));  lcd.write(TRC);
+    lcd.setCursor(indent, 1); lcd.write(LR);  lcd_put_u8str(F("Marlin"));  lcd.write(LR);
+    lcd.setCursor(indent, 2); lcd.write(BLC); lcd_put_u8str(F("------"));  lcd.write(BRC);
     center_text_P(PSTR(SHORT_BUILD_VERSION), 3);
     center_text_P(PSTR(MARLIN_WEBSITE_URL), 4);
     picBits = ICON_LOGO;
   else if (axis_should_home(axis))
     while (const char c = *value++) lcd.write(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
-    lcd_put_u8str_P(axis == Z_AXIS ? PSTR("       ") : PSTR("    "));
+    lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
     lcd_put_u8str(value);
 }
   FORCE_INLINE void _draw_cooler_status(const bool blink) {
     const celsius_t t2 = thermalManager.degTargetCooler();
 
-    lcd.setCursor(0, 5); lcd_put_u8str_P(PSTR("COOL"));
+    lcd.setCursor(0, 5); lcd_put_u8str(F("COOL"));
     lcd.setCursor(1, 6); lcd_put_u8str(i16tostr3rj(thermalManager.wholeDegCooler()));
     lcd.setCursor(1, 7);
 
 #if ENABLED(LASER_COOLANT_FLOW_METER)
 
   FORCE_INLINE void _draw_flowmeter_status() {
-    lcd.setCursor(5, 5); lcd_put_u8str_P(PSTR("FLOW"));
+    lcd.setCursor(5, 5); lcd_put_u8str(F("FLOW"));
     lcd.setCursor(7, 6); lcd_put_wchar('L');
     lcd.setCursor(6, 7); lcd_put_u8str(ftostr11ns(cooler.flowrate));
 
 #if ENABLED(I2C_AMMETER)
 
   FORCE_INLINE void _draw_ammeter_status() {
-    lcd.setCursor(10, 5); lcd_put_u8str_P(PSTR("ILAZ"));
+    lcd.setCursor(10, 5); lcd_put_u8str(F("ILAZ"));
     ammeter.read();
     lcd.setCursor(11, 6);
     if (ammeter.current <= 0.999f)
 #if HAS_CUTTER
 
   FORCE_INLINE void _draw_cutter_status() {
-    lcd.setCursor(15, 5);  lcd_put_u8str_P(PSTR("CUTT"));
+    lcd.setCursor(15, 5);  lcd_put_u8str(F("CUTT"));
     #if CUTTER_UNIT_IS(RPM)
-      lcd.setCursor(16, 6);  lcd_put_u8str_P(PSTR("RPM"));
+      lcd.setCursor(16, 6);  lcd_put_u8str(F("RPM"));
       lcd.setCursor(15, 7);  lcd_put_u8str(ftostr31ns(float(cutter.unitPower) / 1000));
       lcd_put_wchar('K');
     #elif CUTTER_UNIT_IS(PERCENT)
     if (!PanelDetected) return;
     const uint8_t progress = ui._get_progress();
     #if ENABLED(SDSUPPORT)
-      lcd_put_u8str_P(PSTR("SD"));
+      lcd_put_u8str(F("SD"));
     #elif ENABLED(LCD_SET_PROGRESS_MANUALLY)
-      lcd_put_u8str_P(PSTR("P:"));
+      lcd_put_u8str(F("P:"));
     #endif
     if (progress)
       lcd.print(ui8tostr3rj(progress));
     else
-      lcd_put_u8str_P(PSTR("---"));
+      lcd_put_u8str(F("---"));
     lcd.write('%');
   }
 
 
     // Alternate Status message and Filament display
     if (ELAPSED(millis(), next_filament_display)) {
-      lcd_put_u8str_P(PSTR("Dia "));
+      lcd_put_u8str(F("Dia "));
       lcd.print(ftostr12ns(filament_width_meas));
-      lcd_put_u8str_P(PSTR(" V"));
+      lcd_put_u8str(F(" V"));
       lcd.print(i16tostr3rj(100.0 * (
           parser.volumetric_enabled
             ? planner.volumetric_area_nominal / planner.volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]
   //
 
   lcd.setCursor(0, 1);
-  lcd_put_u8str_P(PSTR("FR")); lcd.print(i16tostr3rj(feedrate_percentage)); lcd.write('%');
+  lcd_put_u8str(F("FR")); lcd.print(i16tostr3rj(feedrate_percentage)); lcd.write('%');
 
   #if BOTH(SDSUPPORT, HAS_PRINT_PROGRESS)
     lcd.setCursor(LCD_WIDTH / 2 - 3, 1);
       #else
         #define FANX 17
       #endif
-      lcd.setCursor(FANX, 5); lcd_put_u8str_P(PSTR("FAN"));
+      lcd.setCursor(FANX, 5); lcd_put_u8str(F("FAN"));
       lcd.setCursor(FANX + 1, 6); lcd.write('%');
       lcd.setCursor(FANX, 7);
       lcd.print(i16tostr3rj(per));
     void MarlinUI::draw_hotend_status(const uint8_t row, const uint8_t extruder) {
       if (!PanelDetected) return;
       lcd.setCursor((LCD_WIDTH - 14) / 2, row + 1);
-      lcd.write(LCD_STR_THERMOMETER[0]); lcd_put_u8str_P(PSTR(" E")); lcd.write('1' + extruder); lcd.write(' ');
+      lcd.write(LCD_STR_THERMOMETER[0]); lcd_put_u8str(F(" E")); lcd.write('1' + extruder); lcd.write(' ');
       lcd.print(i16tostr3rj(thermalManager.wholeDegHotend(extruder))); lcd.write(LCD_STR_DEGREE[0]); lcd.write('/');
       lcd.print(i16tostr3rj(thermalManager.degTargetHotend(extruder))); lcd.write(LCD_STR_DEGREE[0]);
       lcd.print_line();
       *fb++ = ',';  lcd.print(i16tostr3left(y_plot)); *fb = ')';
 
       // Show all values
-      lcd.setCursor(_LCD_W_POS, 1); lcd_put_u8str_P(PSTR("X:"));
+      lcd.setCursor(_LCD_W_POS, 1); lcd_put_u8str(F("X:"));
       lcd.print(ftostr52(LOGICAL_X_POSITION(pgm_read_float(&ubl._mesh_index_to_xpos[x_plot]))));
-      lcd.setCursor(_LCD_W_POS, 2); lcd_put_u8str_P(PSTR("Y:"));
+      lcd.setCursor(_LCD_W_POS, 2); lcd_put_u8str(F("Y:"));
       lcd.print(ftostr52(LOGICAL_Y_POSITION(pgm_read_float(&ubl._mesh_index_to_ypos[y_plot]))));
 
       // Show the location value
-      lcd.setCursor(_LCD_W_POS, 3); lcd_put_u8str_P(PSTR("Z:"));
+      lcd.setCursor(_LCD_W_POS, 3); lcd_put_u8str(F("Z:"));
 
       if (!isnan(ubl.z_values[x_plot][y_plot]))
         lcd.print(ftostr43sign(ubl.z_values[x_plot][y_plot]));
       else
-        lcd_put_u8str_P(PSTR(" -----"));
+        lcd_put_u8str(F(" -----"));
 
       center_text_P(GET_TEXT(MSG_UBL_FINE_TUNE_MESH), 8);
 

Marlin/src/lcd/dogm/lcdprint_u8g.cpp

   return ret;
 }
 
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length) {
   u8g_uint_t x = u8g.getPrintCol(), y = u8g.getPrintRow(),
-           ret = uxg_DrawUtf8StrP(u8g.getU8g(), x, y, utf8_str_P, max_length);
+           ret = uxg_DrawUtf8StrP(u8g.getU8g(), x, y, utf8_pstr, max_length);
   u8g.setPrintPos(x + ret, y);
   return ret;
 }

Marlin/src/lcd/dogm/marlinui_DOGM.cpp

     auto _draw_bootscreen_bmp = [&](const uint8_t *bitmap) {
       u8g.drawBitmapP(offx, offy, START_BMP_BYTEWIDTH, START_BMPHEIGHT, bitmap);
       set_font(FONT_MENU);
-      if (!two_part || !line2) lcd_put_u8str_P(txt_offx_1, txt_base - (MENU_FONT_HEIGHT), PSTR(SHORT_BUILD_VERSION));
-      if (!two_part || line2) lcd_put_u8str_P(txt_offx_2, txt_base, PSTR(MARLIN_WEBSITE_URL));
+      if (!two_part || !line2) lcd_put_u8str(txt_offx_1, txt_base - (MENU_FONT_HEIGHT), F(SHORT_BUILD_VERSION));
+      if (!two_part || line2) lcd_put_u8str(txt_offx_2, txt_base, F(MARLIN_WEBSITE_URL));
     };
 
     auto draw_bootscreen_bmp = [&](const uint8_t *bitmap) {
   do {
     set_font(FONT_MENU);
     lcd_put_u8str(0, h4 * 1, status_message);
-    lcd_put_u8str_P(0, h4 * 2, GET_TEXT(MSG_HALTED));
-    lcd_put_u8str_P(0, h4 * 3, GET_TEXT(MSG_PLEASE_RESET));
+    lcd_put_u8str(0, h4 * 2, GET_TEXT_F(MSG_HALTED));
+    lcd_put_u8str(0, h4 * 3, GET_TEXT_F(MSG_PLEASE_RESET));
   } while (u8g.nextPage());
 }
 
         if (!isnan(ubl.z_values[x_plot][y_plot]))
           lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
         else
-          lcd_put_u8str_P(PSTR(" -----"));
+          lcd_put_u8str(F(" -----"));
       }
 
     }

Marlin/src/lcd/dogm/status_screen_DOGM.cpp

 
 FORCE_INLINE void _draw_centered_temp(const celsius_t temp, const uint8_t tx, const uint8_t ty) {
   if (temp < 0)
-    lcd_put_u8str(tx - 3 * (INFO_FONT_WIDTH) / 2 + 1, ty, "err");
+    lcd_put_u8str(tx - 3 * (INFO_FONT_WIDTH) / 2 + 1, ty, F("err"));
   else {
     const char *str = i16tostr3rj(temp);
     const uint8_t len = str[0] != ' ' ? 3 : str[1] != ' ' ? 2 : 1;
   else if (axis_should_home(axis))
     while (const char c = *value++) lcd_put_wchar(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
-    lcd_put_u8str_P(axis == Z_AXIS ? PSTR("       ") : PSTR("    "));
+    lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
     lcd_put_u8str(value);
 }
           }
         }
         else if (progress_state == 2 && estimation_string[0]) {
-          lcd_put_u8str_P(PROGRESS_BAR_X, EXTRAS_BASELINE, PSTR("R:"));
+          lcd_put_u8str(PROGRESS_BAR_X, EXTRAS_BASELINE, F("R:"));
           lcd_put_u8str(estimation_x_pos, EXTRAS_BASELINE, estimation_string);
         }
         else if (elapsed_string[0]) {
         if (show_e_total) {
           #if ENABLED(LCD_SHOW_E_TOTAL)
             _draw_axis_value(E_AXIS, xstring, true);
-            lcd_put_u8str_P(PSTR("       "));
+            lcd_put_u8str(F("       "));
           #endif
         }
         else {
       lcd_put_u8str(102, EXTRAS_2_BASELINE, mstring);
       lcd_put_wchar('%');
       set_font(FONT_MENU);
-      lcd_put_wchar(47, EXTRAS_2_BASELINE, LCD_STR_FILAM_DIA[0]); // lcd_put_u8str_P(PSTR(LCD_STR_FILAM_DIA));
+      lcd_put_wchar(47, EXTRAS_2_BASELINE, LCD_STR_FILAM_DIA[0]); // lcd_put_u8str(F(LCD_STR_FILAM_DIA));
       lcd_put_wchar(93, EXTRAS_2_BASELINE, LCD_STR_FILAM_MUL[0]);
     #endif
   }
     #if BOTH(FILAMENT_LCD_DISPLAY, SDSUPPORT)
       // Alternate Status message and Filament display
       if (ELAPSED(millis(), next_filament_display)) {
-        lcd_put_u8str_P(PSTR(LCD_STR_FILAM_DIA));
+        lcd_put_u8str(F(LCD_STR_FILAM_DIA));
         lcd_put_wchar(':');
         lcd_put_u8str(wstring);
-        lcd_put_u8str_P(PSTR("  " LCD_STR_FILAM_MUL));
+        lcd_put_u8str(F("  " LCD_STR_FILAM_MUL));
         lcd_put_wchar(':');
         lcd_put_u8str(mstring);
         lcd_put_wchar('%');

Marlin/src/lcd/dogm/status_screen_lite_ST7920.cpp

   while (*str && len--) write_byte(*str++);
 }
 
-void ST7920_Lite_Status_Screen::write_str_P(PGM_P const str) {
-  PGM_P p_str = (PGM_P)str;
-  while (char c = pgm_read_byte(p_str++)) write_byte(c);
+void ST7920_Lite_Status_Screen::write_str(FSTR_P const fstr) {
+  PGM_P pstr = FTOP(fstr);
+  while (char c = pgm_read_byte(pstr++)) write_byte(c);
 }
 
 void ST7920_Lite_Status_Screen::write_number(const int16_t value, const uint8_t digits/*=3*/) {
   // Draw centered
   if (value > 9) {
     write_number(value, 4);
-    write_str_P(PSTR("% "));
+    write_str(F("% "));
   }
   else {
     write_number(value, 3);
-    write_str_P(PSTR("%  "));
+    write_str(F("%  "));
   }
 }
 
   };
 
   if (targetStateChange) {
-    if (!showTarget) write_str_P(PSTR("    "));
+    if (!showTarget) write_str(F("    "));
     draw_degree_symbol(5, line, !showTarget);
     draw_degree_symbol(9, line,  showTarget);
   }

Marlin/src/lcd/dogm/status_screen_lite_ST7920.h

 
     static void write_str(const char *str);
     static void write_str(const char *str, const uint8_t len);
-    static void write_str_P(PGM_P const str);
+    static void write_str(FSTR_P const fstr);
     static void write_number(const int16_t value, const uint8_t digits=3);
 
     static void _extended_function_set(const bool extended, const bool graphics);

Marlin/src/lcd/e3v2/marlinui/lcdprint_dwin.cpp

   return lcd_put_u8str_max_cb(utf8_str, read_byte_ram, max_length);
 }
 
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
-  return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length) {
+  return lcd_put_u8str_max_cb(utf8_pstr, read_byte_rom, max_length);
 }
 
 lcd_uint_t lcd_put_u8str_ind_P(PGM_P const pstr, const int8_t ind, PGM_P const inStr/*=nullptr*/, const lcd_uint_t maxlen/*=LCD_WIDTH*/) {

Marlin/src/lcd/e3v2/marlinui/ui_common.cpp

 
   slen = utf8_strlen(S(GET_TEXT_F(MSG_HALTED)));
   lcd_moveto(cx - (slen / 2), cy);
-  lcd_put_u8str_P((const char*)GET_TEXT_F(MSG_HALTED));
+  lcd_put_u8str(GET_TEXT_F(MSG_HALTED));
 
   slen = utf8_strlen(S(GET_TEXT_F(MSG_HALTED)));
   lcd_moveto(cx - (slen / 2), cy + 1);
-  lcd_put_u8str_P((const char*)GET_TEXT_F(MSG_HALTED));
+  lcd_put_u8str(GET_TEXT_F(MSG_HALTED));
 }
 
 //

Marlin/src/lcd/lcdprint.h

 /**
  * @brief Draw a ROM UTF-8 string
  *
- * @param utf8_str_P : the ROM UTF-8 string
+ * @param utf8_pstr : the ROM UTF-8 string
  * @param max_length : the pixel length of the string allowed (or number of slots in HD44780)
  *
  * @return the pixel width
  *
  * Draw a ROM UTF-8 string
  */
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length);
-inline int lcd_put_u8str_max_P(const lcd_uint_t col, const lcd_uint_t row, PGM_P utf8_str_P, pixel_len_t max_length) {
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length);
+inline int lcd_put_u8str_max_P(const lcd_uint_t col, const lcd_uint_t row, PGM_P utf8_pstr, pixel_len_t max_length) {
   lcd_moveto(col, row);
-  return lcd_put_u8str_max_P(utf8_str_P, max_length);
+  return lcd_put_u8str_max_P(utf8_pstr, max_length);
+}
+inline int lcd_put_u8str_max(const lcd_uint_t col, const lcd_uint_t row, FSTR_P const utf8_fstr, pixel_len_t max_length) {
+  return lcd_put_u8str_max_P(col, row, FTOP(utf8_fstr), max_length);
 }
 
 void lcd_put_int(const int i);
   return lcd_put_u8str_P(pstr);
 }
 
+inline int lcd_put_u8str(FSTR_P const fstr) { return lcd_put_u8str_P(FTOP(fstr)); }
+inline int lcd_put_u8str(const lcd_uint_t col, const lcd_uint_t row, FSTR_P const fstr) {
+  return lcd_put_u8str_P(col, row, FTOP(fstr));
+}
+
 lcd_uint_t lcd_put_u8str_ind_P(PGM_P const pstr, const int8_t ind, PGM_P const inStr=nullptr, const lcd_uint_t maxlen=LCD_WIDTH);
 inline lcd_uint_t lcd_put_u8str_ind_P(const lcd_uint_t col, const lcd_uint_t row, PGM_P const pstr, const int8_t ind, PGM_P const inStr=nullptr, const lcd_uint_t maxlen=LCD_WIDTH) {
   lcd_moveto(col, row);
   return lcd_put_u8str_ind_P(pstr, ind, inStr, maxlen);
 }
+inline lcd_uint_t lcd_put_u8str_ind(const lcd_uint_t col, const lcd_uint_t row, FSTR_P const fstr, const int8_t ind, FSTR_P const inFstr=nullptr, const lcd_uint_t maxlen=LCD_WIDTH) {
+  return lcd_put_u8str_ind_P(col, row, FTOP(fstr), ind, FTOP(inFstr), maxlen);
+}
 
-inline int lcd_put_u8str(const char *str) { return lcd_put_u8str_max(str, PIXEL_LEN_NOLIMIT); }
-inline int lcd_put_u8str(const lcd_uint_t col, const lcd_uint_t row, PGM_P const str) {
+inline int lcd_put_u8str(const char * const str) { return lcd_put_u8str_max(str, PIXEL_LEN_NOLIMIT); }
+inline int lcd_put_u8str(const lcd_uint_t col, const lcd_uint_t row, const char * const str) {
   lcd_moveto(col, row);
   return lcd_put_u8str(str);
 }

Marlin/src/lcd/menu/game/game.cpp

     u8g.setColorIndex(0);
     u8g.drawBox(lx - 1, ly - gohigh - 1, gowide + 2, gohigh + 2);
     u8g.setColorIndex(1);
-    if (ui.get_blink()) lcd_put_u8str_P(lx, ly, PSTR("GAME OVER"));
+    if (ui.get_blink()) lcd_put_u8str(lx, ly, F("GAME OVER"));
   }
 }
 

Marlin/src/lcd/menu/menu_bed_corners.cpp

     // Display # of good points found vs total needed
     if (PAGE_CONTAINS(y - (MENU_FONT_HEIGHT), y)) {
       SETCURSOR(TERN(TFT_COLOR_UI, 2, 0), cy);
-      lcd_put_u8str_P(GET_TEXT(MSG_BED_TRAMMING_GOOD_POINTS));
+      lcd_put_u8str_(GET_TEXT_F(MSG_BED_TRAMMING_GOOD_POINTS));
       IF_ENABLED(TFT_COLOR_UI, lcd_moveto(12, cy));
       lcd_put_u8str(GOOD_POINTS_TO_STR(good_points));
       lcd_put_wchar('/');
     // Display the Last Z value
     if (PAGE_CONTAINS(y - (MENU_FONT_HEIGHT), y)) {
       SETCURSOR(TERN(TFT_COLOR_UI, 2, 0), cy);
-      lcd_put_u8str_P(GET_TEXT(MSG_BED_TRAMMING_LAST_Z));
+      lcd_put_u8str(GET_TEXT_F(MSG_BED_TRAMMING_LAST_Z));
       IF_ENABLED(TFT_COLOR_UI, lcd_moveto(12, 2));
       lcd_put_u8str(LAST_Z_TO_STR(last_z));
     }

Marlin/src/lcd/menu/menu_mixer.cpp

     if (ui.should_draw()) {
       char tmp[16];
       SETCURSOR(1, (LCD_HEIGHT - 1) / 2);
-      lcd_put_u8str_P(isend ? GET_TEXT(MSG_END_Z) : GET_TEXT(MSG_START_Z));
+      lcd_put_u8str(isend ? GET_TEXT_F(MSG_END_Z) : GET_TEXT_F(MSG_START_Z));
       sprintf_P(tmp, PSTR("%4d.%d mm"), int(zvar), int(zvar * 10) % 10);
       SETCURSOR_RJ(9, (LCD_HEIGHT - 1) / 2);
       lcd_put_u8str(tmp);
   void _lcd_draw_mix(const uint8_t y) {
     char tmp[20]; // "100%_100%"
     sprintf_P(tmp, PSTR("%3d%% %3d%%"), int(mixer.mix[0]), int(mixer.mix[1]));
-    SETCURSOR(2, y); lcd_put_u8str_P(GET_TEXT(MSG_MIX));
+    SETCURSOR(2, y); lcd_put_u8str(GET_TEXT_F(MSG_MIX));
     SETCURSOR_RJ(10, y); lcd_put_u8str(tmp);
   }
 #endif

Marlin/src/lcd/menu/menu_tune.cpp

           TERN_(HAS_MARLINUI_U8GLIB, ui.set_font(FONT_MENU));
           #if ENABLED(TFT_COLOR_UI)
             lcd_moveto(4, 3);
-            lcd_put_u8str_P(GET_TEXT(MSG_BABYSTEP_TOTAL));
+            lcd_put_u8str(GET_TEXT_F(MSG_BABYSTEP_TOTAL));
             lcd_put_wchar(':');
             lcd_moveto(10, 3);
           #else
             lcd_moveto(0, TERN(HAS_MARLINUI_U8GLIB, LCD_PIXEL_HEIGHT - MENU_FONT_DESCENT, LCD_HEIGHT - 1));
-            lcd_put_u8str_P(GET_TEXT(MSG_BABYSTEP_TOTAL));
+            lcd_put_u8str(GET_TEXT_F(MSG_BABYSTEP_TOTAL));
             lcd_put_wchar(':');
           #endif
           lcd_put_u8str(BABYSTEP_TO_STR(mps * babystep.axis_total[BS_TOTAL_IND(axis)]));

Marlin/src/lcd/tft/ui_common.cpp

   return tft_string.width();
 }
 
-int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
+int lcd_put_u8str_max_P(PGM_P utf8_pstr, pixel_len_t max_length) {
   if (max_length < 1) return 0;
-  tft_string.set(utf8_str_P);
+  tft_string.set(utf8_pstr);
   tft_string.trim();
   tft_string.truncate(max_length);
   tft.add_text(MENU_TEXT_X_OFFSET, MENU_TEXT_Y_OFFSET, COLOR_MENU_TEXT, tft_string);