[2.0.x] Add support for LPC1769 at 120 MHz (#9423)

Marlin/src/HAL/HAL_LPC1768/HAL_spi.cpp

  * https://github.com/MarlinFirmware/Marlin/tree/071c7a78f27078fd4aee9a3ef365fcf5e143531e
  */
 
+#include "src/inc/MarlinConfig.h"
+
 #ifdef TARGET_LPC1768
 
 // --------------------------------------------------------------------------
 // Includes
 // --------------------------------------------------------------------------
 
-//#include "../../../MarlinConfig.h"  //works except in U8g
-#include "spi_pins.h"
-#include "fastio.h"
 #include "LPC_SPI.h"
 #include "../SPI.h"
 
 // --------------------------------------------------------------------------
-// Public Variables
-// --------------------------------------------------------------------------
-
-
-// --------------------------------------------------------------------------
 // Public functions
 // --------------------------------------------------------------------------
 
 #if ENABLED(LPC_SOFTWARE_SPI)
+
+  #include "SoftwareSPI.h"
+
   // --------------------------------------------------------------------------
-  // software SPI
+  // Software SPI
   // --------------------------------------------------------------------------
 
-  /**
-   * This software SPI runs at three rates. The SD software provides an index
-   * (spiRate) of 0-6. The mapping is:
-   *     0-1 - about 5 MHz peak
-   *     2-3 - about 2 MHz peak
-   *     all others - about 250 KHz
-   */
-
   static uint8_t SPI_speed = 0;
 
   static uint8_t spiTransfer(uint8_t b) {
-
-    if (!SPI_speed) {       // fastest - about 5 MHz peak
-      for (int bits = 0; bits < 8; bits++) {
-        if (b & 0x80) {
-          WRITE(MOSI_PIN, HIGH);
-          WRITE(MOSI_PIN, HIGH);  // delay to (hopefully) guarantee setup time
-        }
-        else {
-          WRITE(MOSI_PIN, LOW);
-          WRITE(MOSI_PIN, LOW);  // delay to (hopefully) guarantee setup time
-        }
-        b <<= 1;
-        WRITE(SCK_PIN, HIGH);
-        if (READ(MISO_PIN)) {
-          b |= 1;
-        }
-        WRITE(SCK_PIN, LOW);
-      }
-    }
-    else if (SPI_speed == 1) { // medium - about 1 MHz
-      for (int bits = 0; bits < 8; bits++) {
-        if (b & 0x80) {
-          for (uint8_t i = 0; i < 9; i++) WRITE(MOSI_PIN, HIGH);
-        }
-        else {
-          for (uint8_t i = 0; i < 9; i++) WRITE(MOSI_PIN, LOW);
-        }
-        b <<= 1;
-
-        for (uint8_t i = 0; i < 7; i++) WRITE(SCK_PIN, HIGH);
-
-        if (READ(MISO_PIN)) {
-          b |= 1;
-        }
-        WRITE(SCK_PIN, LOW);
-      }
-    }
-    else { // slow - about 250 KHz
-      for (int bits = 0; bits < 8; bits++) {
-        if (b & 0x80) {
-          WRITE(MOSI_PIN, HIGH);
-        }
-        else {
-          WRITE(MOSI_PIN, LOW);
-        }
-        b <<= 1;
-        delayMicroseconds(1U);
-        WRITE(SCK_PIN, HIGH);
-        delayMicroseconds(2U);
-
-        if (READ(MISO_PIN)) {
-          b |= 1;
-        }
-        WRITE(SCK_PIN, LOW);
-        delayMicroseconds(1U);
-      }
-    }
-    return b;
+    return swSpiTransfer(b, SPI_speed, SCK_PIN, MISO_PIN, MOSI_PIN);
   }
 
   void spiBegin() {
-    SET_OUTPUT(SCK_PIN);
-    SET_INPUT(MISO_PIN);
-    SET_OUTPUT(MOSI_PIN);
+    swSpiBegin(SCK_PIN, MISO_PIN, MOSI_PIN);
   }
 
   void spiInit(uint8_t spiRate) {
-    SPI_speed = spiRate >> 1;
-    WRITE(MOSI_PIN, HIGH);
-    WRITE(SCK_PIN, LOW);
+    SPI_speed = swSpiInit(spiRate, SCK_PIN, MOSI_PIN);
   }
 
   uint8_t spiRec() {
     WRITE(SS_PIN, HIGH);
   }
 
-  void SPIClass::begin() { spiBegin(); }
-
-  uint8_t SPIClass::transfer(uint8_t B) {
-    return spiTransfer(B);
-  }
-  uint16_t SPIClass::transfer16(uint16_t data) {
-    uint16_t buffer;
-    buffer = transfer((data>>8) & 0xFF) << 8;
-    buffer |= transfer(data & 0xFF) && 0xFF;
-    return buffer;
-  }
-
-  SPIClass SPI;
-
 #else
 
   // hardware SPI
     PinCfg.Funcnum = 2;
     PinCfg.OpenDrain = 0;
     PinCfg.Pinmode = 0;
-  PinCfg.Pinnum = LPC1768_PIN_PIN(SCK_PIN);
-PinCfg.Portnum = LPC1768_PIN_PORT(SCK_PIN);
+    PinCfg.Pinnum = LPC1768_PIN_PIN(SCK_PIN);
+    PinCfg.Portnum = LPC1768_PIN_PORT(SCK_PIN);
     PINSEL_ConfigPin(&PinCfg);
     SET_OUTPUT(SCK_PIN);
 
-PinCfg.Pinnum = LPC1768_PIN_PIN(MISO_PIN);
-PinCfg.Portnum = LPC1768_PIN_PORT(MISO_PIN);
+    PinCfg.Pinnum = LPC1768_PIN_PIN(MISO_PIN);
+    PinCfg.Portnum = LPC1768_PIN_PORT(MISO_PIN);
     PINSEL_ConfigPin(&PinCfg);
     SET_INPUT(MISO_PIN);
 
     SET_OUTPUT(MOSI_PIN);
   }
 
-
   void spiInit(uint8_t spiRate) {
 
-   // table to convert Marlin spiRates (0-5 plus default) into bit rates
+    // table to convert Marlin spiRates (0-5 plus default) into bit rates
     uint32_t Marlin_speed[7]; // CPSR is always 2
     Marlin_speed[0] = 8333333; //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
     Marlin_speed[1] = 4166667; //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
     Marlin_speed[5] =  250000; //(SCR: 99)  desired:   250,000  actual:   250,000         SPI_SPEED_6
     Marlin_speed[6] =  125000; //(SCR:199)  desired:   125,000  actual:   125,000         Default from HAL.h
 
-
-   // select 50MHz PCLK for SSP0
+    // divide PCLK by 2 for SSP0
     CLKPWR_SetPCLKDiv(CLKPWR_PCLKSEL_SSP0, CLKPWR_PCLKSEL_CCLK_DIV_2);
 
-   // setup for SPI mode
+    // setup for SPI mode
     SSP_CFG_Type HW_SPI_init; // data structure to hold init values
     SSP_ConfigStructInit(&HW_SPI_init);  // set values for SPI mode
     HW_SPI_init.ClockRate = Marlin_speed[MIN(spiRate, 6)]; // put in the specified bit rate
   void spiSend(uint32_t chan, const uint8_t* buf, size_t n) {
   }
 
-
-  uint8_t get_one_byte() {
-   // send a dummy byte so can clock in receive data
+  static uint8_t get_one_byte() {
+    // send a dummy byte so can clock in receive data
     SSP_SendData(LPC_SSP0,0x00FF);
     while (SSP_GetStatus(LPC_SSP0, SSP_STAT_BUSY));  // wait for it to finish
     return SSP_ReceiveData(LPC_SSP0) & 0x00FF;
     }
   }
 
+  static uint8_t spiTransfer(uint8_t b) {
+    while (SSP_GetStatus(LPC_SSP0, SSP_STAT_RXFIFO_NOTEMPTY) || SSP_GetStatus(LPC_SSP0, SSP_STAT_BUSY)) SSP_ReceiveData(LPC_SSP0);  //flush the receive buffer
+    SSP_SendData(LPC_SSP0, b);  // send the byte
+    while (SSP_GetStatus(LPC_SSP0, SSP_STAT_BUSY));  // wait for it to finish
+    return SSP_ReceiveData(LPC_SSP0) & 0x00FF;
+  }
+
   // Write from buffer to SPI
   void spiSendBlock(uint8_t token, const uint8_t* buf) {
   }
 
 #endif // ENABLED(LPC_SOFTWARE_SPI)
 
+void SPIClass::begin() { spiBegin(); }
+
+uint8_t SPIClass::transfer(uint8_t B) {
+  return spiTransfer(B);
+}
+uint16_t SPIClass::transfer16(uint16_t data) {
+  uint16_t buffer;
+  buffer = transfer((data>>8) & 0xFF) << 8;
+  buffer |= transfer(data & 0xFF) && 0xFF;
+  return buffer;
+}
+
+SPIClass SPI;
+
 #endif // TARGET_LPC1768
 

Marlin/src/HAL/HAL_LPC1768/HardwareSerial.cpp

   PINSEL_CFG_Type PinCfg;
   UART_FIFO_CFG_Type FIFOConfig;
 
+  if (Baudrate == baudrate) return; // No need to re-initialize
+
   if (UARTx == LPC_UART0) {
     // Initialize UART0 pin connect
     PinCfg.Funcnum = 1;
   #if TX_BUFFER_SIZE > 0
     TxQueueWritePos = TxQueueReadPos = 0;
   #endif
+
+  // Save the configured baudrate
+  Baudrate = baudrate;
 }
 
 int HardwareSerial::peek() {

Marlin/src/HAL/HAL_LPC1768/HardwareSerial.h

 private:
   LPC_UART_TypeDef *UARTx;
 
+  uint32_t Baudrate;
   uint32_t Status;
   uint8_t RxBuffer[RX_BUFFER_SIZE];
   uint32_t RxQueueWritePos;
 public:
   HardwareSerial(LPC_UART_TypeDef *UARTx)
     : UARTx(UARTx)
+    , Baudrate(0)
     , RxQueueWritePos(0)
     , RxQueueReadPos(0)
     #if TX_BUFFER_SIZE > 0

Marlin/src/HAL/HAL_LPC1768/LPC1768_PWM.cpp

   LPC_SC->PCLKSEL0 &= ~(0x3 << PCLK_PWM1);
   LPC_SC->PCLKSEL0 |= (LPC_PWM1_PCLKSEL0 << PCLK_PWM1);
 
+  uint32_t PR = (CLKPWR_GetPCLK(CLKPWR_PCLKSEL_PWM1) / 1000000) - 1;      // Prescalar to create 1 MHz output
+
   LPC_PWM1->MR0  = LPC_PWM1_MR0;                                          // TC resets every 19,999 + 1 cycles - sets PWM cycle(Ton+Toff) to 20 mS
   // MR0 must be set before TCR enables the PWM
   LPC_PWM1->TCR  = _BV(SBIT_CNTEN) | _BV(SBIT_CNTRST) | _BV(SBIT_PWMEN);  // Enable counters, reset counters, set mode to PWM
   CBI(LPC_PWM1->TCR, SBIT_CNTRST);                                        // Take counters out of reset
-  LPC_PWM1->PR   =  LPC_PWM1_PR;
+  LPC_PWM1->PR   = PR;
   LPC_PWM1->MCR  = _BV(SBIT_PWMMR0R) | _BV(0);                            // Reset TC if it matches MR0, disable all interrupts except for MR0
   LPC_PWM1->CTCR = 0;                                                     // Disable counter mode (enable PWM mode)
   LPC_PWM1->LER  = 0x07F;                                                 // Set the latch Enable Bits to load the new Match Values for MR0 - MR6
   ////  interrupt controlled PWM setup
 
   LPC_SC->PCONP |= 1 << 23;  // power on timer3
-  HAL_PWM_TIMER->PR = LPC_PWM1_PR;
+  HAL_PWM_TIMER->PR = PR;
   HAL_PWM_TIMER->MCR = 0x0B;              // Interrupt on MR0 & MR1, reset on MR0
   HAL_PWM_TIMER->MR0 = LPC_PWM1_MR0;
   HAL_PWM_TIMER->MR1 = 0;

Marlin/src/HAL/HAL_LPC1768/LPC1768_PWM.h

 #define _LPC1768_PWM_H_
 
 #include "pinmapping.h"
+#include <lpc17xx_clkpwr.h>
 
 #define LPC_PWM1_MR0 19999  // base repetition rate minus one count - 20mS
-#define LPC_PWM1_PR 24      // prescaler value - prescaler divide by 24 + 1  -  1 MHz output
-#define LPC_PWM1_PCLKSEL0 0x00   // select clock source for prescaler - defaults to 25MHz on power up
-                                 // 0: 25MHz, 1: 100MHz, 2: 50MHz, 3: 12.5MHZ to PWM1 prescaler
-#define MR0_MARGIN 200       // if channel value too close to MR0 the system locks up
+#define LPC_PWM1_PCLKSEL0 CLKPWR_PCLKSEL_CCLK_DIV_4 // select clock divider for prescaler - defaults to 4 on power up
+#define MR0_MARGIN 200      // if channel value too close to MR0 the system locks up
 
 void LPC1768_PWM_init(void);
 bool LPC1768_PWM_attach_pin(pin_t pin, uint32_t min=1, uint32_t max=(LPC_PWM1_MR0 - (MR0_MARGIN)), uint8_t servo_index=0xFF);

Marlin/src/HAL/HAL_LPC1768/LPC_SPI.h

 #ifdef TARGET_LPC1768
 #include <stdint.h>
 
-#define MSBFIRST 0
+#define MSBFIRST 1
 #define SPI_MODE3 0
 
 class SPISettings {

Marlin/src/HAL/HAL_LPC1768/SoftwareSPI.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Software SPI functions originally from Arduino Sd2Card Library
+ * Copyright (C) 2009 by William Greiman
+ */
+
+/**
+ *
+ * For TARGET_LPC1768
+ */
+
+#include "src/inc/MarlinConfig.h"
+
+#ifdef TARGET_LPC1768
+
+// --------------------------------------------------------------------------
+// Software SPI
+// --------------------------------------------------------------------------
+
+/**
+ * This software SPI runs at multiple rates. The SD software provides an index
+ * (spiRate) of 0-6. The mapping is:
+ *     0 - about 5 MHz peak (6 MHz on LPC1769)
+ *     1-2 - about 2 MHz peak
+ *     3 - about 1 MHz peak
+ *     4 - about 500 kHz peak
+ *     5 - about 250 kHz peak
+ *     6 - about 125 kHz peak
+ */
+
+uint8_t swSpiTransfer(uint8_t b, uint8_t spi_speed, pin_t sck_pin, pin_t miso_pin, pin_t mosi_pin) {
+  for (uint8_t i = 0; i < 8; i++) {
+    if (spi_speed == 0) {
+      if (b & 0x80)
+        WRITE(mosi_pin, HIGH);
+      else
+        WRITE(mosi_pin, LOW);
+
+      WRITE(sck_pin, HIGH);
+      
+      b <<= 1;
+
+      if (miso_pin >= 0)
+        if (READ(miso_pin)) b |= 1;
+
+      WRITE(sck_pin, LOW);
+    }
+    else {
+      if (b & 0x80)
+        for (uint8_t j = 0; j < spi_speed; j++)
+          WRITE(mosi_pin, HIGH);
+      else
+        for (uint8_t j = 0; j < spi_speed; j++)
+          WRITE(mosi_pin, LOW);
+
+      for (uint8_t j = 0; j < spi_speed + (miso_pin >= 0 ? 0 : 1); j++)
+        WRITE(sck_pin, HIGH);
+      
+      b <<= 1;
+
+      if (miso_pin >= 0)
+        if (READ(miso_pin)) b |= 1;
+
+      for (uint8_t j = 0; j < spi_speed; j++)
+        WRITE(sck_pin, LOW);
+    }
+  }
+
+  return b;
+}
+
+void swSpiBegin(pin_t sck_pin, pin_t miso_pin, pin_t mosi_pin) {
+  SET_OUTPUT(sck_pin);
+  if (VALID_PIN(miso_pin))
+    SET_INPUT(miso_pin);
+  SET_OUTPUT(mosi_pin);
+}
+
+uint8_t swSpiInit(uint8_t spiRate, pin_t sck_pin, pin_t mosi_pin) {
+  uint8_t spi_speed = 0;
+
+  spiRate = MIN(spiRate, 6);
+
+  if (SystemCoreClock == 120000000)
+    spi_speed = 44 / POW(2, 6 - spiRate);
+  else
+    spi_speed = 38 / POW(2, 6 - spiRate);
+
+  WRITE(mosi_pin, HIGH);
+  WRITE(sck_pin, LOW);
+
+  return spi_speed;
+}
+
+#endif // TARGET_LPC1768

Marlin/src/HAL/HAL_LPC1768/SoftwareSPI.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _SOFTWARE_SPI_H_
+#define _SOFTWARE_SPI_H_
+
+  #include "pinmapping.h"
+
+  // --------------------------------------------------------------------------
+  // software SPI
+  // --------------------------------------------------------------------------
+
+  /**
+   * This software SPI runs at multiple rates. The SD software provides an index
+   * (spiRate) of 0-6. The mapping is:
+   *     0 - about 5 MHz peak (6 MHz on LPC1769)
+   *     1-2 - about 2 MHz peak
+   *     3 - about 1 MHz peak
+   *     4 - about 500 kHz peak
+   *     5 - about 250 kHz peak
+   *     6 - about 125 kHz peak
+   */
+
+  void swSpiBegin(pin_t sck_pin, pin_t miso_pin, pin_t mosi_pin);
+
+  // Returns the spi_speed value to be passed to swSpiTransfer
+  uint8_t swSpiInit(uint8_t spiRate, pin_t sck_pin, pin_t mosi_pin);
+
+  uint8_t swSpiTransfer(uint8_t b, uint8_t spi_speed, pin_t sck_pin, pin_t miso_pin, pin_t mosi_pin);
+
+#endif // _SOFTWARE_SPI_H_

Marlin/src/HAL/HAL_LPC1768/main.cpp

   }
 }
 
+// detect 17x[4-8] (100MHz) or 17x9 (120MHz)
+static bool isLPC1769() {
+    #define IAP_LOCATION 0x1FFF1FF1
+    uint32_t command[1];
+    uint32_t result[5];
+    typedef void (*IAP)(uint32_t*, uint32_t*);
+    IAP iap = (IAP) IAP_LOCATION;
+
+    command[0] = 54;
+    iap(command, result);
+
+    return ((result[1] & 0x00100000) != 0);
+}
+
 extern uint32_t MSC_SD_Init(uint8_t pdrv);
 
 int main(void) {
     #if NUM_SERIAL > 1
       MYSERIAL1.begin(BAUDRATE);
     #endif
-    SERIAL_PRINTF("\n\nLPC1768 (%dMhz) UART0 Initialised\n", SystemCoreClock / 1000000);
+    SERIAL_PRINTF("\n\n%s (%dMhz) UART0 Initialised\n", isLPC1769() ? "LPC1769" : "LPC1768", SystemCoreClock / 1000000);
     SERIAL_FLUSHTX();
   #endif
 

Marlin/src/HAL/HAL_LPC1768/pinmapping.h

 #define P0_26   LPC1768_PIN(PORT(0), PIN(26), INTERRUPT(1), PWM(0), ADC_CHAN(3))
 #define P0_27   LPC1768_PIN(PORT(0), PIN(27), INTERRUPT(1), PWM(0), ADC_NONE)
 #define P0_28   LPC1768_PIN(PORT(0), PIN(28), INTERRUPT(1), PWM(0), ADC_NONE)
-#define P0_29   LPC1768_PIN(PORT(0), PIN(29), INTERRUPT(1), PWM(0), ADC_NONE)
-#define P0_30   LPC1768_PIN(PORT(0), PIN(30), INTERRUPT(1), PWM(0), ADC_NONE)
+#if SERIAL_PORT != -1 && SERIAL_PORT_2 != -1
+  #define P0_29 LPC1768_PIN(PORT(0), PIN(29), INTERRUPT(1), PWM(0), ADC_NONE)
+  #define P0_30 LPC1768_PIN(PORT(0), PIN(30), INTERRUPT(1), PWM(0), ADC_NONE)
+#endif
 #define P1_00   LPC1768_PIN(PORT(1), PIN( 0), INTERRUPT(0), PWM(0), ADC_NONE)
 #define P1_01   LPC1768_PIN(PORT(1), PIN( 1), INTERRUPT(0), PWM(0), ADC_NONE)
 #define P1_04   LPC1768_PIN(PORT(1), PIN( 4), INTERRUPT(0), PWM(0), ADC_NONE)
     P_NC,
   #endif
            P0_17, P0_18, P0_19, P0_20, P0_21, P0_22, P0_23,
-    P0_24, P0_25, P0_26, P0_27, P0_28, P0_29, P0_30, P_NC,
+    P0_24, P0_25, P0_26, P0_27, P0_28,
+  #if SERIAL_PORT != -1 && SERIAL_PORT_2 != -1
+                                       P0_29, P0_30,
+  #else
+                                       P_NC,  P_NC,
+  #endif
+                                                   P_NC,
 
   P1_00, P1_01, P_NC,  P_NC,  P1_04, P_NC,  P_NC,  P_NC,
   P1_08, P1_09, P1_10, P_NC,  P_NC,  P_NC,  P1_14, P1_15,
   #endif
 };
 
-#if SERIAL_PORT != 0
+#if SERIAL_PORT != 0 && SERIAL_PORT_2 != 0
   #define NUM_ANALOG_INPUTS 8
 #else
   #define NUM_ANALOG_INPUTS 6
 #endif
 
 // P0.6 thru P0.9 are for the onboard SD card
-// P0.29 and P0.30 are for the USB port
-#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09, P0_29, P0_30
+#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09
 
 // Get the digital pin for an analog index
 pin_t analogInputToDigitalPin(const int8_t p);

Marlin/src/HAL/HAL_LPC1768/spi_pins.h

 #ifndef SPI_PINS_LPC1768_H
 #define SPI_PINS_LPC1768_H
 
-#define LPC_SOFTWARE_SPI  // Re-ARM board needs a software SPI because using the
-                          // standard LCD adapter results in the LCD and the
-                          // SD card sharing a single SPI when the RepRap Full
-                          // Graphic Smart Controller is selected
+#include "src/core/macros.h"
+
+#if ENABLED(SDSUPPORT) && ENABLED(DOGLCD) && (LCD_PINS_D4 == SCK_PIN || LCD_PINS_ENABLE == MOSI_PIN || DOGLCD_SCK == SCK_PIN || DOGLCD_MOSI == MOSI_PIN)
+  #define LPC_SOFTWARE_SPI  // If the SD card and LCD adapter share the same SPI pins, then software SPI is currently
+                            // needed due to the speed and mode requred for communicating with each device being different.
+                            // This requirement can be removed if the SPI access to these devices is updated to use
+                            // spiBeginTransaction.
+#endif
 
 /** onboard SD card */
 //#define SCK_PIN           P0_07

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp

 #ifdef TARGET_LPC1768
 
   #include <U8glib.h>
+  #include "SoftwareSPI.h"
 
-  #include <lpc17xx_pinsel.h>
-
-  #define LPC_PORT_OFFSET         (0x0020)
-  #define LPC_PIN(pin)            (1UL << pin)
-  #define LPC_GPIO(port)          ((volatile LPC_GPIO_TypeDef *)(LPC_GPIO0_BASE + LPC_PORT_OFFSET * port))
-
-
-  uint8_t SCK_pin_ST7920_HAL, SCK_port_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL, MOSI_port_ST7920_HAL;
-
-
-  #define SPI_SPEED 4  //20: 200KHz 5:750KHz 4:1MHz 3:1.5MHz 2:3-4MHz
-
-  static void spiSend_sw(uint8_t val)
-  {
-    for (uint8_t i = 0; i < 8; i++) {
-
-      if (val & 0x80)
-        for (uint8_t j = 0; j < SPI_SPEED; j++) {
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOSET = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOSET = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOSET = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-        }
-      else
-        for (uint8_t j = 0; j < SPI_SPEED; j++) {
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOCLR = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOCLR = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-          LPC_GPIO(MOSI_port_ST7920_HAL)->FIOCLR = LPC_PIN(MOSI_pin_ST7920_HAL_HAL);
-        }
-
-      for (uint8_t j = 0; j < SPI_SPEED; j++) {
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOSET = LPC_PIN(SCK_pin_ST7920_HAL);
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOSET = LPC_PIN(SCK_pin_ST7920_HAL);
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOSET = LPC_PIN(SCK_pin_ST7920_HAL);
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOSET = LPC_PIN(SCK_pin_ST7920_HAL);
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOSET = LPC_PIN(SCK_pin_ST7920_HAL);
-      }
-
-      for (uint8_t j = 0; j < SPI_SPEED; j++) {
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOCLR = LPC_PIN(SCK_pin_ST7920_HAL);
-        LPC_GPIO(SCK_port_ST7920_HAL)->FIOCLR = LPC_PIN(SCK_pin_ST7920_HAL);
-      }
-      val = val << 1;
-    }
-  }
+  #define SPI_SPEED 3  // About 1 MHz
 
+  static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL;
+  static uint8_t SPI_speed = 0;
   static uint8_t rs_last_state = 255;
 
   static void u8g_com_LPC1768_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val)
 
       if ( rs == 0 )
         /* command */
-        spiSend_sw(0x0f8);
+        swSpiTransfer(0x0f8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
       else
          /* data */
-        spiSend_sw(0x0fa);
+         swSpiTransfer(0x0fa, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
 
       for( i = 0; i < 4; i++ )   // give the controller some time to process the data
         u8g_10MicroDelay();      // 2 is bad, 3 is OK, 4 is safe
     }
 
-    spiSend_sw(val & 0x0f0);
-    spiSend_sw(val << 4);
+    swSpiTransfer(val & 0x0f0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
+    swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
   }
 
-
   uint8_t u8g_com_HAL_LPC1768_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
   {
     switch(msg)
     {
       case U8G_COM_MSG_INIT:
-        #define LPC1768_PIN_PORT(pin) ((uint8_t)((pin >> 5) & 0b111))
-        #define LPC1768_PIN_PIN(pin) ((uint8_t)(pin & 0b11111))
-        SCK_pin_ST7920_HAL = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_SCK]);
-        SCK_port_ST7920_HAL = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_SCK]);
-        MOSI_pin_ST7920_HAL_HAL = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_MOSI]);
-        MOSI_port_ST7920_HAL = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_MOSI]);
+        SCK_pin_ST7920_HAL = u8g->pin_list[U8G_PI_SCK];
+        MOSI_pin_ST7920_HAL_HAL = u8g->pin_list[U8G_PI_MOSI];
 
-        u8g_SetPILevel(u8g, U8G_PI_CS, 0);
         u8g_SetPIOutput(u8g, U8G_PI_CS);
-        u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
         u8g_SetPIOutput(u8g, U8G_PI_SCK);
-        u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
         u8g_SetPIOutput(u8g, U8G_PI_MOSI);
         u8g_Delay(5);
+
+        SPI_speed = swSpiInit(SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL);
+
+        u8g_SetPILevel(u8g, U8G_PI_CS, 0);
+        u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
+        u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
+
         u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
         break;
 

Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_sw_spi.cpp

 
 */
 
-
-
 #if defined (TARGET_LPC1768)
 
-
 #include <U8glib.h>
+#include "SoftwareSPI.h"
 
-#include <lpc17xx_pinsel.h>
-
-#define LPC_PORT_OFFSET         (0x0020)
-#define LPC_PIN(pin)            (1UL << pin)
-#define LPC_GPIO(port)          ((volatile LPC_GPIO_TypeDef *)(LPC_GPIO0_BASE + LPC_PORT_OFFSET * port))
+#define SPI_SPEED 2  // About 2 MHz
 
-void delayMicroseconds(uint32_t us);
-void pinMode(int16_t pin, uint8_t mode);
-void digitalWrite(int16_t pin, uint8_t pin_status);
-
-
-uint8_t SCK_pin, SCK_port, MOSI_pin, MOSI_port;
-
-#define SPI_SPEED 2  //20: 200KHz 5:750KHz 2:3-4MHz
+static uint8_t SPI_speed = 0;
 
 static void u8g_sw_spi_HAL_LPC1768_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val)
 {
-  for (uint8_t i = 0; i < 8; i++) {
-
-    if (val & 0x80)
-      for (uint8_t j = 0; j < SPI_SPEED; j++) {
-        LPC_GPIO(MOSI_port)->FIOSET = LPC_PIN(MOSI_pin);
-        LPC_GPIO(MOSI_port)->FIOSET = LPC_PIN(MOSI_pin);
-        LPC_GPIO(MOSI_port)->FIOSET = LPC_PIN(MOSI_pin);
-      }
-    else
-      for (uint8_t j = 0; j < SPI_SPEED; j++) {
-        LPC_GPIO(MOSI_port)->FIOCLR = LPC_PIN(MOSI_pin);
-        LPC_GPIO(MOSI_port)->FIOCLR = LPC_PIN(MOSI_pin);
-        LPC_GPIO(MOSI_port)->FIOCLR = LPC_PIN(MOSI_pin);
-      }
-
-    for (uint8_t j = 0; j < SPI_SPEED; j++) {
-      LPC_GPIO(SCK_port)->FIOSET = LPC_PIN(SCK_pin);
-      LPC_GPIO(SCK_port)->FIOSET = LPC_PIN(SCK_pin);
-      LPC_GPIO(SCK_port)->FIOSET = LPC_PIN(SCK_pin);
-      LPC_GPIO(SCK_port)->FIOSET = LPC_PIN(SCK_pin);
-      LPC_GPIO(SCK_port)->FIOSET = LPC_PIN(SCK_pin);
-    }
-
-    for (uint8_t j = 0; j < SPI_SPEED; j++) {
-      LPC_GPIO(SCK_port)->FIOCLR = LPC_PIN(SCK_pin);
-      LPC_GPIO(SCK_port)->FIOCLR = LPC_PIN(SCK_pin);
-    }
-    val = val << 1;
-  }
+  swSpiTransfer(val, SPI_speed, clockPin, -1, dataPin);
 }
 
-
 uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
 {
-
-
   switch(msg)
   {
     case U8G_COM_MSG_INIT:
-      #define LPC1768_PIN_PORT(pin) ((uint8_t)((pin >> 5) & 0b111))
-      #define LPC1768_PIN_PIN(pin) ((uint8_t)(pin & 0b11111))
-      SCK_pin = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_SCK]);
-      SCK_port = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_SCK]);
-      MOSI_pin = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_MOSI]);
-      MOSI_port = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_MOSI]);
-      // As defined by Arduino INPUT(0x0), OUPUT(0x1), INPUT_PULLUP(0x2)
-      #define OUPUT 0x1
-      pinMode(u8g->pin_list[U8G_PI_SCK], OUPUT);
-      pinMode(u8g->pin_list[U8G_PI_MOSI], OUPUT);
-      pinMode(u8g->pin_list[U8G_PI_CS], OUPUT);
-      pinMode(u8g->pin_list[U8G_PI_A0], OUPUT);
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET])  pinMode(u8g->pin_list[U8G_PI_RESET], OUPUT);
-      digitalWrite(u8g->pin_list[U8G_PI_SCK], 0);
-      digitalWrite(u8g->pin_list[U8G_PI_MOSI], 0);
+      u8g_SetPIOutput(u8g, U8G_PI_SCK);
+      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
+      u8g_SetPIOutput(u8g, U8G_PI_CS);
+      u8g_SetPIOutput(u8g, U8G_PI_A0);
+      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPIOutput(u8g, U8G_PI_RESET);
+      SPI_speed = swSpiInit(SPI_SPEED, u8g->pin_list[U8G_PI_SCK], u8g->pin_list[U8G_PI_MOSI]);
+      u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
+      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
       break;
 
     case U8G_COM_MSG_STOP:
       break;
 
     case U8G_COM_MSG_RESET:
-      digitalWrite(u8g->pin_list[U8G_PI_RESET], arg_val);
+      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      digitalWrite(u8g->pin_list[U8G_PI_CS], !arg_val);
+      u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);
       break;
 
     case U8G_COM_MSG_WRITE_BYTE:
       break;
 
     case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      digitalWrite(u8g->pin_list[U8G_PI_A0], arg_val);
+      u8g_SetPILevel(u8g, U8G_PI_A0, arg_val);
       break;
   }
   return 1;

Marlin/src/feature/tmc_util.cpp

       tmc_status(stepperE0, TMC_E0, i, planner.axis_steps_per_mm[E_AXIS]);
     #endif
     #if E1_IS_TRINAMIC
-      tmc_status(stepperE1, TMC_E1, i, planner.axis_steps_per_mm[E_AXIS+1]);
+      tmc_status(stepperE1, TMC_E1, i, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 1
+        #endif
+      ]);
     #endif
     #if E2_IS_TRINAMIC
-      tmc_status(stepperE2, TMC_E2, i, planner.axis_steps_per_mm[E_AXIS+2]);
+      tmc_status(stepperE2, TMC_E2, i, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 2
+        #endif
+      ]);
     #endif
     #if E3_IS_TRINAMIC
-      tmc_status(stepperE3, TMC_E3, i, planner.axis_steps_per_mm[E_AXIS+3]);
+      tmc_status(stepperE3, TMC_E3, i, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 3
+        #endif
+      ]);
     #endif
     #if E4_IS_TRINAMIC
-      tmc_status(stepperE4, TMC_E4, i, planner.axis_steps_per_mm[E_AXIS+4]);
+      tmc_status(stepperE4, TMC_E4, i, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 4
+        #endif
+      ]);
     #endif
 
     SERIAL_EOL();

Marlin/src/lcd/dogm/HAL_LCD_class_defines.h

 {
   public:
     U8GLIB_64128N_2X_HAL(pin_t sck, pin_t mosi, pin_t cs, pin_t a0, pin_t reset = U8G_PIN_NONE)
-      : U8GLIB(&u8g_dev_st7565_64128n_HAL_2x_sw_spi, sck, mosi, cs, a0, reset)
+      : U8GLIB(&u8g_dev_st7565_64128n_HAL_2x_sw_spi, (uint8_t)sck, (uint8_t)mosi, (uint8_t)cs, (uint8_t)a0, (uint8_t)reset)
       { }
     U8GLIB_64128N_2X_HAL(pin_t cs, pin_t a0, pin_t reset = U8G_PIN_NONE)
-      : U8GLIB(&u8g_dev_st7565_64128n_HAL_2x_hw_spi, cs, a0, reset)
+      : U8GLIB(&u8g_dev_st7565_64128n_HAL_2x_hw_spi, (uint8_t)cs, (uint8_t)a0, (uint8_t)reset)
       { }
 };
 
 {
   public:
     U8GLIB_ST7920_128X64_4X_HAL(pin_t sck, pin_t mosi, pin_t cs, pin_t reset = U8G_PIN_NONE)
-      : U8GLIB(&u8g_dev_st7920_128x64_HAL_4x_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset)    // a0 = U8G_PIN_NONE
+      : U8GLIB(&u8g_dev_st7920_128x64_HAL_4x_sw_spi, (uint8_t)sck, (uint8_t)mosi, (uint8_t)cs, U8G_PIN_NONE, (uint8_t)reset)    // a0 = U8G_PIN_NONE
       { }
     U8GLIB_ST7920_128X64_4X_HAL(pin_t cs, pin_t reset = U8G_PIN_NONE)
-      : U8GLIB(&u8g_dev_st7920_128x64_HAL_4x_hw_spi, cs, U8G_PIN_NONE, reset)   // a0 = U8G_PIN_NONE
+      : U8GLIB(&u8g_dev_st7920_128x64_HAL_4x_hw_spi, (uint8_t)cs, U8G_PIN_NONE, (uint8_t)reset)   // a0 = U8G_PIN_NONE
       { }
 };
 
 {
   public:
     U8GLIB_ST7920_128X64_RRD(pin_t sck, pin_t mosi, pin_t cs, pin_t reset = U8G_PIN_NONE)
-      : U8GLIB(&u8g_dev_st7920_128x64_rrd_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset)   // a0 = U8G_PIN_NONE
+      : U8GLIB(&u8g_dev_st7920_128x64_rrd_sw_spi, (uint8_t)sck, (uint8_t)mosi, (uint8_t)cs, U8G_PIN_NONE, (uint8_t)reset)   // a0 = U8G_PIN_NONE
       { }
 };
 

Marlin/src/lcd/ultralcd_impl_DOGM.h

 
 // LCD selection
 #if ENABLED(REPRAPWORLD_GRAPHICAL_LCD)
-  #ifdef CPU_32_BIT
-    U8GLIB_ST7920_128X64_4X u8g(LCD_PINS_D4, LCD_PINS_ENABLE, LCD_PINS_RS); // Original u8glib device. 2 stripes, SW SPI
-  #else
+  #ifdef DISABLED(SDSUPPORT) && (LCD_PINS_D4 == SCK_PIN) && (LCD_PINS_ENABLE == MOSI_PIN)
     U8GLIB_ST7920_128X64_4X u8g(LCD_PINS_RS); // 2 stripes, HW SPI (shared with SD card)
+  #else
+    U8GLIB_ST7920_128X64_4X u8g(LCD_PINS_D4, LCD_PINS_ENABLE, LCD_PINS_RS); // Original u8glib device. 2 stripes, SW SPI
   #endif
 
 #elif ENABLED(U8GLIB_ST7920)
   // RepRap Discount Full Graphics Smart Controller
-    //U8GLIB_ST7920_128X64_4X u8g(LCD_PINS_RS); // 2 stripes, HW SPI (shared with SD card, on AVR does not use standard LCD adapter)
+  #if DISABLED(SDSUPPORT) && (LCD_PINS_D4 == SCK_PIN) && (LCD_PINS_ENABLE == MOSI_PIN)
+    U8GLIB_ST7920_128X64_4X_HAL u8g(LCD_PINS_RS); // 2 stripes, HW SPI (shared with SD card, on AVR does not use standard LCD adapter)
+  #else
     //U8GLIB_ST7920_128X64_4X u8g(LCD_PINS_D4, LCD_PINS_ENABLE, LCD_PINS_RS); // Original u8glib device. 2 stripes, SW SPI
     U8GLIB_ST7920_128X64_RRD u8g(LCD_PINS_D4, LCD_PINS_ENABLE, LCD_PINS_RS); // Number of stripes can be adjusted in ultralcd_st7920_u8glib_rrd.h with PAGE_HEIGHT
                                                                            // AVR version ignores these pin settings
                                                                            // HAL version uses these pin settings
+  #endif
 
 #elif ENABLED(CARTESIO_UI)
   // The CartesioUI display
 
 #elif ENABLED(U8GLIB_ST7565_64128N)
   // The MaKrPanel, Mini Viki, and Viki 2.0, ST7565 controller
-    //U8GLIB_64128N_2X_HAL u8g(DOGLCD_CS, DOGLCD_A0);  // using HW-SPI
+  #if DISABLED(SDSUPPORT) && (DOGLCD_SCK == SCK_PIN) && (DOGLCD_MOSI == MOSI_PIN)
+    U8GLIB_64128N_2X_HAL u8g(DOGLCD_CS, DOGLCD_A0);  // using HW-SPI
+  #else
     U8GLIB_64128N_2X_HAL u8g(DOGLCD_SCK, DOGLCD_MOSI, DOGLCD_CS, DOGLCD_A0);  // using SW-SPI
+  #endif
 
 #elif ENABLED(MKS_12864OLED_SSD1306)
   // MKS 128x64 (SSD1306) OLED I2C LCD

Marlin/src/module/stepper_indirection.cpp

       _TMC2130_INIT(E0, planner.axis_steps_per_mm[E_AXIS]);
     #endif
     #if ENABLED(E1_IS_TMC2130)
-      { constexpr int extruder = 1; _TMC2130_INIT(E1, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2130_INIT(E1, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 1
+        #endif
+      ]);
     #endif
     #if ENABLED(E2_IS_TMC2130)
-      { constexpr int extruder = 2; _TMC2130_INIT(E2, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2130_INIT(E2, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 2
+        #endif
+      ]);
     #endif
     #if ENABLED(E3_IS_TMC2130)
-      { constexpr int extruder = 3; _TMC2130_INIT(E3, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2130_INIT(E3, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 3
+        #endif
+      ]);
     #endif
     #if ENABLED(E4_IS_TMC2130)
-      { constexpr int extruder = 4; _TMC2130_INIT(E4, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2130_INIT(E4, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 4
+        #endif
+      ]);
     #endif
 
   }
       _TMC2208_INIT(E0, planner.axis_steps_per_mm[E_AXIS]);
     #endif
     #if ENABLED(E1_IS_TMC2208)
-      { constexpr int extruder = 1; _TMC2208_INIT(E1, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2208_INIT(E1, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 1
+        #endif
+      ]);
     #endif
     #if ENABLED(E2_IS_TMC2208)
-      { constexpr int extruder = 2; _TMC2208_INIT(E2, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2208_INIT(E2, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 2
+        #endif
+      ]);
     #endif
     #if ENABLED(E3_IS_TMC2208)
-      { constexpr int extruder = 3; _TMC2208_INIT(E3, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2208_INIT(E3, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 3
+        #endif
+      ]);
     #endif
     #if ENABLED(E4_IS_TMC2208)
-      { constexpr int extruder = 4; _TMC2208_INIT(E4, planner.axis_steps_per_mm[E_AXIS_N]); }
+      _TMC2208_INIT(E4, planner.axis_steps_per_mm[E_AXIS
+        #if ENABLED(DISTINCT_E_FACTORS)
+          + 4
+        #endif
+      ]);
     #endif
   }
 #endif // HAVE_TMC2208

frameworks/CMSIS/LPC1768/Re-ARM/system_LPC17xx.c

         break;
     }
   }
+}
+
+// detect 17x[4-8] (100MHz) or 17x9 (120MHz)
+static int can_120MHz() {
+  #define IAP_LOCATION 0x1FFF1FF1
+  uint32_t command[1];
+  uint32_t result[5];
+  typedef void (*IAP)(uint32_t*, uint32_t*);
+  IAP iap = (IAP) IAP_LOCATION;
 
+  command[0] = 54;
+  iap(command, result);
+
+  return result[1] & 0x00100000;
 }
 
 /**
  * @brief  Setup the microcontroller system.
  *         Initialize the System.
  */
-
 void SystemInit (void)
 {
 #if (CLOCK_SETUP)                       /* Clock Setup                        */
 
   LPC_SC->CCLKCFG   = 0x00000002;       /* Setup CPU Clock Divider            */
 
-  LPC_SC->PLL0CFG   = 0x00010018;     // 100MHz
-  LPC_SC->PLL0FEED  = 0xAA;
-  LPC_SC->PLL0FEED  = 0x55;
+  if(can_120MHz()) {
+    LPC_SC->PLL0CFG   = 0x0000000E;     /* configure PLL0                     */
+    LPC_SC->PLL0FEED  = 0xAA;
+    LPC_SC->PLL0FEED  = 0x55;
+  } else {
+    LPC_SC->PLL0CFG   = 0x00010018;     // 100MHz
+    LPC_SC->PLL0FEED  = 0xAA;
+    LPC_SC->PLL0FEED  = 0x55;
+  }
 
   LPC_SC->PLL0CON   = 0x01;             /* PLL0 Enable                        */
   LPC_SC->PLL0FEED  = 0xAA;

frameworks/CMSIS/LPC1768/lib/chanfs/mmc_ssp.c

 /
 /-------------------------------------------------------------------------*/
 
+#include "lpc17xx_ssp.h"
+#include "lpc17xx_clkpwr.h"
+#include "LPC176x.h"
+
 #define SSP_CH	1	/* SSP channel to use (0:SSP0, 1:SSP1) */
 
-#define	CCLK		100000000UL	/* cclk frequency [Hz] */
-#define PCLK_SSP	50000000UL	/* PCLK frequency to be supplied for SSP [Hz] */
 #define SCLK_FAST	25000000UL	/* SCLK frequency under normal operation [Hz] */
 #define	SCLK_SLOW	400000UL	/* SCLK frequency under initialization [Hz] */
 
 		}
 #endif
 
-#if PCLK_SSP * 1 == CCLK
-#define PCLKDIV_SSP	PCLKDIV_1
-#elif PCLK_SSP * 2 == CCLK
 #define PCLKDIV_SSP	PCLKDIV_2
-#elif PCLK_SSP * 4 == CCLK
-#define PCLKDIV_SSP	PCLKDIV_4
-#elif PCLK_SSP * 8 == CCLK
-#define PCLKDIV_SSP	PCLKDIV_8
-#else
-#error Invalid CCLK:PCLK_SSP combination.
-#endif
 
+static void set_spi_clock(uint32_t target_clock)
+{
+  uint32_t prescale, cr0_div, cmp_clk, ssp_clk;
+
+  /* The SSP clock is derived from the (main system oscillator / 2),
+      so compute the best divider from that clock */
+  #if SSP_CH == 0
+    ssp_clk = CLKPWR_GetPCLK (CLKPWR_PCLKSEL_SSP0);
+  #elif SSP_CH == 1
+    ssp_clk = CLKPWR_GetPCLK (CLKPWR_PCLKSEL_SSP1);
+  #endif
+
+	/* Find closest divider to get at or under the target frequency.
+	   Use smallest prescale possible and rely on the divider to get
+	   the closest target frequency */
+	cr0_div = 0;
+	cmp_clk = 0xFFFFFFFF;
+	prescale = 2;
+	while (cmp_clk > target_clock)
+	{
+		cmp_clk = ssp_clk / ((cr0_div + 1) * prescale);
+		if (cmp_clk > target_clock)
+		{
+			cr0_div++;
+			if (cr0_div > 0xFF)
+			{
+				cr0_div = 0;
+				prescale += 2;
+			}
+		}
+	}
+
+  /* Write computed prescaler and divider back to register */
+  SSPxCR0 &= (~SSP_CR0_SCR(0xFF)) & SSP_CR0_BITMASK;
+  SSPxCR0 |= (SSP_CR0_SCR(cr0_div)) & SSP_CR0_BITMASK;
+  SSPxCPSR = prescale & SSP_CPSR_BITMASK;
+}
 
-#define FCLK_FAST() { SSPxCR0 = (SSPxCR0 & 0x00FF) | ((PCLK_SSP / 2 / SCLK_FAST) - 1) << 8; }
-#define FCLK_SLOW() { SSPxCR0 = (SSPxCR0 & 0x00FF) | ((PCLK_SSP / 2 / SCLK_SLOW) - 1) << 8; }
+
+#define FCLK_FAST() set_spi_clock(SCLK_FAST)
+#define FCLK_SLOW() set_spi_clock(SCLK_SLOW)
 
 
 
 
 ---------------------------------------------------------------------------*/
 
-#include "LPC176x.h"
 #include "diskio.h"
 
 
 {
 	__set_PCONP(PCSSPx, 1);	/* Enable SSP module */
 	__set_PCLKSEL(PCLKSSPx, PCLKDIV_SSP);	/* Select PCLK frequency for SSP */
-	SSPxCPSR = 2;			/* CPSDVSR=2 */
 	SSPxCR0 = 0x0007;		/* Set mode: SPI mode 0, 8-bit */
 	SSPxCR1 = 0x2;			/* Enable SSP with Master */
 	ATTACH_SSP();			/* Attach SSP module to I/O pads */