Bump with M851XY

2019-09-08 18:38:25 -04:00
parent 769701e64a
commit ed5cc1a0c0
537 changed files with 18424 additions and 3582 deletions
@@ -20,9 +20,9 @@

 #include "../shared/Marduino.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio_AVR.h"
-#include "watchdog_AVR.h"
-#include "math_AVR.h"
+#include "fastio.h"
+#include "watchdog.h"
+#include "math.h"

 #ifdef USBCON
  #include "HardwareSerial.h"
@@ -65,7 +65,7 @@ Timer get_pwm_timer(const pin_t pin) {
            /*n, q*/      2, 0
          };
        }
-      #elif defined TCCR2A
+      #elif defined(TCCR2A)
        #if ENABLED(USE_OCR2A_AS_TOP)
          case TIMER2A:   break; // protect TIMER2A
          case TIMER2B: {
@@ -26,7 +26,7 @@

 #ifdef __AVR__

-#include "fastio_AVR.h"
+#include "fastio.h"

 #ifdef FASTIO_EXT_START

@@ -29,7 +29,7 @@
 *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 72 75 76 77 74 xx xx xx xx xx
 */

-#include "../fastio_AVR.h"
+#include "../fastio.h"

 // change for your board
 #define DEBUG_LED   DIO21
@@ -28,7 +28,7 @@
 *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
 */

-#include "../fastio_AVR.h"
+#include "../fastio.h"

 // change for your board
 #define DEBUG_LED   DIO46
@@ -28,7 +28,7 @@
 *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
 */

-#include "../fastio_AVR.h"
+#include "../fastio.h"

 #define DEBUG_LED   AIO5

@@ -54,7 +54,7 @@
 *                        +--------+
 */

-#include "../fastio_AVR.h"
+#include "../fastio.h"

 #define DEBUG_LED   DIO0

@@ -29,7 +29,7 @@
 *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
 */

-#include "../fastio_AVR.h"
+#include "../fastio.h"

 // change for your board
 #define DEBUG_LED   DIO31 /* led D5 red */
@@ -26,7 +26,7 @@

 #if ENABLED(USE_WATCHDOG)

-#include "watchdog_AVR.h"
+#include "watchdog.h"

 #include "../../Marlin.h"

@@ -32,9 +32,9 @@
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio_Due.h"
-#include "watchdog_Due.h"
-#include "HAL_timers_Due.h"
+#include "fastio.h"
+#include "watchdog.h"
+#include "timers.h"

 #include <stdint.h>

@@ -58,8 +58,8 @@
  #define NUM_SERIAL 1
 #endif

-#include "MarlinSerial_Due.h"
-#include "MarlinSerialUSB_Due.h"
+#include "MarlinSerial.h"
+#include "MarlinSerialUSB.h"

 // On AVR this is in math.h?
 #define square(x) ((x)*(x))
@@ -94,17 +94,6 @@ void sei(void);                     // Enable interrupts
 void HAL_clear_reset_source(void);  // clear reset reason
 uint8_t HAL_get_reset_source(void); // get reset reason

-//
-// SPI: Extended functions taking a channel number (Hardware SPI only)
-//
-
-// Write single byte to specified SPI channel
-void spiSend(uint32_t chan, byte b);
-// Write buffer to specified SPI channel
-void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-// Read single byte from specified SPI channel
-uint8_t spiRec(uint32_t chan);
-
 //
 // EEPROM
 //
@@ -34,7 +34,7 @@

 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "InterruptVectors_Due.h"
+#include "InterruptVectors.h"

 /* The relocated Exception/Interrupt Table - According to the ARM
   reference manual, alignment to 128 bytes should suffice, but in
@@ -29,8 +29,8 @@

 #include "../../inc/MarlinConfig.h"

-#include "MarlinSerial_Due.h"
-#include "InterruptVectors_Due.h"
+#include "MarlinSerial.h"
+#include "InterruptVectors.h"
 #include "../../Marlin.h"

 template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
@@ -31,7 +31,7 @@

 #if SERIAL_PORT == -1

-#include "MarlinSerialUSB_Due.h"
+#include "MarlinSerialUSB.h"

 #if ENABLED(EMERGENCY_PARSER)
  #include "../../feature/emergency_parser.h"
@@ -31,7 +31,7 @@

 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "HAL_timers_Due.h"
+#include "timers.h"

 static pin_t tone_pin;
 volatile static int32_t toggles;
@@ -71,7 +71,7 @@ void spiSend(uint8_t b);
 void spiSend(const uint8_t* buf, size_t n);

 #include "../../shared/Marduino.h"
-#include "../fastio_Due.h"
+#include "../fastio.h"

 void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
   PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
@@ -34,7 +34,7 @@
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"

-#include "HAL_timers_Due.h"
+#include "timers.h"

 // ------------------------
 // Local defines
@@ -230,7 +230,7 @@

 /* Define NO_INIT attribute */
 #if 0 //ndef NO_INIT
-#if defined   ( __CC_ARM   )
+#ifdef __CC_ARM
 #   define NO_INIT __attribute__((zero_init))
 #elif defined ( __ICCARM__ )
 #   define NO_INIT __no_init
@@ -262,7 +262,7 @@
 //! @{
 typedef unsigned char           Bool; //!< Boolean.
 #ifndef __cplusplus
-#if !defined(__bool_true_false_are_defined)
+#ifndef __bool_true_false_are_defined
 typedef unsigned char           bool; //!< Boolean.
 #endif
 #endif
@@ -443,7 +443,7 @@ typedef struct
 #define DISABLE   0
 #define ENABLE    1
 #ifndef __cplusplus
-#if !defined(__bool_true_false_are_defined)
+#ifndef __bool_true_false_are_defined
 #define false 0
 #define true 1
 #endif
@@ -61,27 +61,27 @@ extern "C" {
 * Below BOARD_XXX macros are related to the specific board, and
 * should be defined by the board code, otherwise default value are used.
 */
-#if !defined(BOARD_FREQ_SLCK_XTAL)
+#ifndef BOARD_FREQ_SLCK_XTAL
 #  warning The board slow clock xtal frequency has not been defined.
 #  define BOARD_FREQ_SLCK_XTAL      (32768UL)
 #endif

-#if !defined(BOARD_FREQ_SLCK_BYPASS)
+#ifndef BOARD_FREQ_SLCK_BYPASS
 #  warning The board slow clock bypass frequency has not been defined.
 #  define BOARD_FREQ_SLCK_BYPASS    (32768UL)
 #endif

-#if !defined(BOARD_FREQ_MAINCK_XTAL)
+#ifndef BOARD_FREQ_MAINCK_XTAL
 #  warning The board main clock xtal frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_XTAL    (12000000UL)
 #endif

-#if !defined(BOARD_FREQ_MAINCK_BYPASS)
+#ifndef BOARD_FREQ_MAINCK_BYPASS
 #  warning The board main clock bypass frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_BYPASS  (12000000UL)
 #endif

-#if !defined(BOARD_OSC_STARTUP_US)
+#ifndef BOARD_OSC_STARTUP_US
 #  warning The board main clock xtal startup time has not been defined.
 #  define BOARD_OSC_STARTUP_US      (15625UL)
 #endif
@@ -43,12 +43,12 @@
 * \asf_license_stop
 *
 */
+
 /*
 * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
 */
-#ifndef  _SPC_PROTOCOL_H_
-#define  _SPC_PROTOCOL_H_
-
+#ifndef _SPC_PROTOCOL_H_
+#define _SPC_PROTOCOL_H_

 /**
 * \ingroup usb_msc_protocol
@@ -55,7 +55,7 @@
 #include "udi.h"

 // Check the number of port
-#ifndef  UDI_CDC_PORT_NB
+#ifndef UDI_CDC_PORT_NB
 # define  UDI_CDC_PORT_NB 1
 #endif
 #if (UDI_CDC_PORT_NB < 1) || (UDI_CDC_PORT_NB > 7)
@@ -50,7 +50,7 @@
 #include "usb_protocol_cdc.h"
 #include "conf_usb.h"

-#ifndef  UDI_CDC_PORT_NB
+#ifndef UDI_CDC_PORT_NB
 # define  UDI_CDC_PORT_NB 1
 #endif

@@ -24,7 +24,7 @@

 #include "../../inc/MarlinConfig.h"
 #include "../../Marlin.h"
-#include "watchdog_Due.h"
+#include "watchdog.h"

 // Override Arduino runtime to either config or disable the watchdog
 //
@@ -23,7 +23,7 @@
 #ifdef ARDUINO_ARCH_ESP32

 #include "HAL.h"
-#include "HAL_timers_ESP32.h"
+#include "timers.h"
 #include <rom/rtc.h>
 #include <driver/adc.h>
 #include <esp_adc_cal.h>
@@ -30,11 +30,11 @@
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"

-#include "fastio_ESP32.h"
-#include "watchdog_ESP32.h"
+#include "fastio.h"
+#include "watchdog.h"
 #include "i2s.h"

-#include "HAL_timers_ESP32.h"
+#include "timers.h"

 #include "WebSocketSerial.h"
 #include "FlushableHardwareSerial.h"
@@ -27,9 +27,10 @@
 #include "../shared/HAL_SPI.h"
 #include <pins_arduino.h>
 #include "spi_pins.h"
-#include "../../core/macros.h"
 #include <SPI.h>

+#include "../../core/macros.h"
+
 // ------------------------
 // Public Variables
 // ------------------------
@@ -25,7 +25,7 @@

 #if HAS_SERVOS

-#include "HAL_Servo_ESP32.h"
+#include "Servo.h"

 // Adjacent channels (0/1, 2/3 etc.) share the same timer and therefore the same frequency and resolution settings on ESP32,
 // so we only allocate servo channels up high to avoid side effects with regards to analogWrite (fans, leds, laser pwm etc.)
@@ -30,7 +30,7 @@

 #include "HAL.h"

-#include "HAL_timers_ESP32.h"
+#include "timers.h"

 // ------------------------
 // Local defines
@@ -26,7 +26,7 @@

 #if ENABLED(USE_WATCHDOG)

-#include "watchdog_ESP32.h"
+#include "watchdog.h"

 void watchdogSetup(void) {
  // do whatever. don't remove this function.
@@ -22,16 +22,18 @@

 #ifdef ARDUINO_ARCH_ESP32

+#include <SPIFFS.h>
+#undef DISABLED  // esp32-hal-gpio.h
+
 #include "../../inc/MarlinConfigPre.h"

 #if ENABLED(WEBSUPPORT)

-#include <SPIFFS.h>
 #include "wifi.h"

 AsyncEventSource events("/events"); // event source (Server-Sent events)

-void onNotFound(AsyncWebServerRequest *request){
+void onNotFound(AsyncWebServerRequest *request) {
  request->send(404);
 }

@@ -56,7 +56,7 @@ uint8_t _getc();
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
 #include "watchdog.h"
-#include "HAL_timers.h"
+#include "timers.h"
 #include "serial.h"

 #define SHARED_SERVOS HAS_SERVOS
@@ -86,14 +86,6 @@ inline void HAL_init(void) { }
 int freeMemory(void);
 #pragma GCC diagnostic pop

-// SPI: Extended functions which take a channel number (hardware SPI only)
-/** Write single byte to specified SPI channel */
-void spiSend(uint32_t chan, byte b);
-/** Write buffer to specified SPI channel */
-void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-/** Read single byte from specified SPI channel */
-uint8_t spiRec(uint32_t chan);
-
 // ADC
 #define HAL_ANALOG_SELECT(pin) HAL_adc_enable_channel(pin)
 #define HAL_START_ADC(pin)     HAL_adc_start_conversion(pin)
@@ -90,7 +90,7 @@ void eeprom_read_block(void *__dst, const void *__src, size_t __n) { }

 void eeprom_update_block(const void *__src, void *__dst, size_t __n) { }

-char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s) {
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {
  char format_string[20];
  snprintf(format_string, 20, "%%%d.%df", __width, __prec);
  sprintf(__s, format_string, __val);
@@ -49,8 +49,6 @@ typedef uint8_t byte;
 #define PGM_P const char *

 // Used for libraries, preprocessor, and constants
-#define min(a,b) ((a)<(b)?(a):(b))
-#define max(a,b) ((a)>(b)?(a):(b))
 #define abs(x) ((x)>0?(x):-(x))

 #ifndef isnan
@@ -111,13 +109,13 @@ uint16_t analogRead(pin_t);
 // EEPROM
 void eeprom_write_byte(unsigned char *pos, unsigned char value);
 unsigned char eeprom_read_byte(unsigned char *pos);
-void eeprom_read_block (void *__dst, const void *__src, size_t __n);
-void eeprom_update_block (const void *__src, void *__dst, size_t __n);
+void eeprom_read_block(void *__dst, const void *__src, size_t __n);
+void eeprom_update_block(const void *__src, void *__dst, size_t __n);

 int32_t random(int32_t);
 int32_t random(int32_t, int32_t);
 void randomSeed(uint32_t);

-char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);

 int map(uint16_t x, uint16_t in_min, uint16_t in_max, uint16_t out_min, uint16_t out_max);
@@ -108,11 +108,11 @@ public:

  void flush() { receive_buffer.clear(); }

-  uint8_t availableForWrite(void){
+  uint8_t availableForWrite(void) {
    return transmit_buffer.free() > 255 ? 255 : (uint8_t)transmit_buffer.free();
  }

-  void flushTX(void){
+  void flushTX(void) {
    if (host_connected)
      while (transmit_buffer.available()) { /* nada */ }
  }
@@ -25,7 +25,7 @@
 #include "hardware/Timer.h"

 #include "../../inc/MarlinConfig.h"
-#include "HAL_timers.h"
+#include "timers.h"

 /**
 * Use POSIX signals to attempt to emulate Interrupts
@@ -41,7 +41,7 @@ extern "C" volatile uint32_t _millis;
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
 #include "watchdog.h"
-#include "HAL_timers.h"
+#include "timers.h"
 #include "MarlinSerial.h"

 #include <adc.h>
@@ -116,17 +116,6 @@ extern "C" volatile uint32_t _millis;
 int freeMemory(void);
 #pragma GCC diagnostic pop

-//
-// SPI: Extended functions taking a channel number (Hardware SPI only)
-//
-
-// Write single byte to specified SPI channel
-void spiSend(uint32_t chan, byte b);
-// Write buffer to specified SPI channel
-void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-// Read single byte from specified SPI channel
-uint8_t spiRec(uint32_t chan);
-
 //
 // ADC API
 //
@@ -38,7 +38,7 @@ extern "C" {
 #include "../../sd/cardreader.h"
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "HAL_timers.h"
+#include "timers.h"

 extern uint32_t MSC_SD_Init(uint8_t pdrv);
 extern "C" int isLPC1769();
@@ -29,7 +29,7 @@
 #ifdef TARGET_LPC1768

 #include "../../inc/MarlinConfig.h"
-#include "HAL_timers.h"
+#include "timers.h"

 void HAL_timer_init(void) {
  SBI(LPC_SC->PCONP, SBIT_TIMER0);  // Power ON Timer 0
@@ -25,9 +25,9 @@
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio_SAMD51.h"
-#include "watchdog_SAMD51.h"
-#include "HAL_timers_SAMD51.h"
+#include "fastio.h"
+#include "watchdog.h"
+#include "timers.h"

 #ifdef ADAFRUIT_GRAND_CENTRAL_M4
  #include "MarlinSerial_AGCM4.h"
@@ -146,3 +146,11 @@ FORCE_INLINE void _delay_ms(const int delay_ms) { delay(delay_ms); }
 #pragma GCC diagnostic ignored "-Wunused-function"
 int freeMemory(void);
 #pragma GCC diagnostic pop
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
+#ifdef __cplusplus
+  }
+#endif
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -33,7 +33,7 @@
 #include "../shared/servo.h"
 #include "../shared/servo_private.h"
 #include "SAMD51.h"
-#include "HAL_timers_SAMD51.h"
+#include "timers.h"

 #define __TC_GCLK_ID(t)         TC##t##_GCLK_ID
 #define _TC_GCLK_ID(t)          __TC_GCLK_ID(t)
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -25,7 +25,7 @@
 // Includes
 // --------------------------------------------------------------------------
 #include "../../inc/MarlinConfig.h"
-#include "HAL_timers_SAMD51.h"
+#include "timers.h"

 // --------------------------------------------------------------------------
 // Local defines
@@ -25,7 +25,7 @@

 #if ENABLED(USE_WATCHDOG)

-  #include "watchdog_SAMD51.h"
+  #include "watchdog.h"

  void watchdog_init(void) {
    // The low-power oscillator used by the WDT runs at 32,768 Hz with
@@ -28,8 +28,8 @@
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio_STM32.h"
-#include "watchdog_STM32.h"
+#include "fastio.h"
+#include "watchdog.h"

 #include "../../inc/MarlinConfigPre.h"

@@ -96,7 +96,7 @@
  #define NUM_SERIAL 1
 #endif

-#include "HAL_timers_STM32.h"
+#include "timers.h"

 /**
 * TODO: review this to return 1 for pins that are not analog input
@@ -169,17 +169,6 @@ static inline int freeMemory() {

 #pragma GCC diagnostic pop

-//
-// SPI: Extended functions which take a channel number (hardware SPI only)
-//
-
-// Write single byte to specified SPI channel
-void spiSend(uint32_t chan, byte b);
-// Write buffer to specified SPI channel
-void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-// Read single byte from specified SPI channel
-uint8_t spiRec(uint32_t chan);
-
 //
 // EEPROM
 //
@@ -82,12 +82,7 @@ void spiInit(uint8_t spiRate) {
      clock = 4000000; // Default from the SPI library
  }
  spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
-  #if defined(MISO_PIN) && defined(SDSS) && defined(MOSI_PIN) && defined(SCK_PIN)
-    SPI.setMISO(MISO_PIN);
-    SPI.setSSEL(SDSS);
-    SPI.setMOSI(MOSI_PIN);
-    SPI.setSCLK(SCK_PIN);
-  #endif
+
  SPI.begin();
 }

@@ -26,7 +26,7 @@

 #if HAS_SERVOS

-#include "HAL_Servo_STM32.h"
+#include "Servo.h"

 uint8_t servoPin[MAX_SERVOS] = { 0 };

@@ -29,9 +29,11 @@
 #ifdef BOARD_NR_GPIO_PINS  // Only in STM32GENERIC (Maple)

 #ifdef __STM32F1__
-  #include "../HAL_STM32F1/fastio_STM32F1.h"
+  #include "../HAL_STM32F1/fastio.h"
 #elif defined(STM32F4) || defined(STM32F7)
-  #include "../HAL_STM32_F4_F7/fastio_STM32_F4_F7.h"
+  #include "../HAL_STM32_F4_F7/fastio.h"
+#else
+  #include "fastio.h"
 #endif

 extern const stm32_pin_info PIN_MAP[BOARD_NR_GPIO_PINS];
@@ -145,19 +145,19 @@ uint8_t get_pin_mode(const pin_t Ard_num) {
    case 'D' : mode_all = GPIOD->MODER; break;
    #ifdef PE_0
      case 'E' : mode_all = GPIOE->MODER; break;
-    #elif defined (PF_0)
+    #elif defined(PF_0)
      case 'F' : mode_all = GPIOF->MODER; break;
-    #elif defined (PG_0)
+    #elif defined(PG_0)
      case 'G' : mode_all = GPIOG->MODER; break;
-    #elif defined (PH_0)
+    #elif defined(PH_0)
      case 'H' : mode_all = GPIOH->MODER; break;
-    #elif defined (PI_0)
+    #elif defined(PI_0)
      case 'I' : mode_all = GPIOI->MODER; break;
-    #elif defined (PJ_0)
+    #elif defined(PJ_0)
      case 'J' : mode_all = GPIOJ->MODER; break;
-    #elif defined (PK_0)
+    #elif defined(PK_0)
      case 'K' : mode_all = GPIOK->MODER; break;
-    #elif defined (PL_0)
+    #elif defined(PL_0)
      case 'L' : mode_all = GPIOL->MODER; break;
    #endif
  }
@@ -24,7 +24,7 @@

 #include "HAL.h"

-#include "HAL_timers_STM32.h"
+#include "timers.h"

 // ------------------------
 // Local defines
@@ -28,7 +28,7 @@

  #include "../../inc/MarlinConfig.h"

-  #include "watchdog_STM32.h"
+  #include "watchdog.h"
  #include <IWatchdog.h>

  void watchdog_init() { IWatchdog.begin(4000000); } // 4 sec timeout
@@ -82,7 +82,7 @@
 // Public Variables
 // ------------------------

-#ifdef SERIAL_USB
+#if (!defined(SERIAL_USB) && !defined(USE_USB_COMPOSITE))
  USBSerial SerialUSB;
 #endif

@@ -93,7 +93,7 @@ uint16_t HAL_adc_result;
 // ------------------------
 STM32ADC adc(ADC1);

-uint8_t adc_pins[] = {
+const uint8_t adc_pins[] = {
  #if HAS_TEMP_ADC_0
    TEMP_0_PIN,
  #endif
@@ -121,6 +121,15 @@ uint8_t adc_pins[] = {
  #if ENABLED(FILAMENT_WIDTH_SENSOR)
    FILWIDTH_PIN,
  #endif
+  #if HAS_JOY_ADC_X
+    JOY_X_PIN,
+  #endif
+  #if HAS_JOY_ADC_Y
+    JOY_Y_PIN,
+  #endif
+  #if HAS_JOY_ADC_Z
+    JOY_Z_PIN,
+  #endif
 };

 enum TEMP_PINS : char {
@@ -151,15 +160,20 @@ enum TEMP_PINS : char {
  #if ENABLED(FILAMENT_WIDTH_SENSOR)
    FILWIDTH,
  #endif
+  #if HAS_JOY_ADC_X
+    JOY_X,
+  #endif
+  #if HAS_JOY_ADC_Y
+    JOY_Y,
+  #endif
+  #if HAS_JOY_ADC_Z
+    JOY_Z,
+  #endif
  ADC_PIN_COUNT
 };

 uint16_t HAL_adc_results[ADC_PIN_COUNT];

-// ------------------------
-// Function prototypes
-// ------------------------
-
 // ------------------------
 // Private functions
 // ------------------------
@@ -201,6 +215,9 @@ void HAL_init(void) {
  #if PIN_EXISTS(LED)
    OUT_WRITE(LED_PIN, LOW);
  #endif
+  #ifdef USE_USB_COMPOSITE
+    MSC_SD_init();
+  #endif
  #if PIN_EXISTS(USB_CONNECT)
    OUT_WRITE(USB_CONNECT_PIN, !USB_CONNECT_INVERTING);  // USB clear connection
    delay(1000);                                         // Give OS time to notice
@@ -208,6 +225,24 @@ void HAL_init(void) {
  #endif
 }

+// HAL idle task
+void HAL_idletask(void) {
+  #ifdef USE_USB_COMPOSITE
+    #if ENABLED(SHARED_SD_CARD)
+      // If Marlin is using the SD card we need to lock it to prevent access from
+      // a PC via USB.
+      // Other HALs use IS_SD_PRINTING() and IS_SD_FILE_OPEN() to check for access but
+      // this will not reliably detect delete operations. To be safe we will lock
+      // 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())
+      /* copy from lpc1768 framework, should be fixed later for process SHARED_SD_CARD*/
+    #endif
+    // process USB mass storage device class loop
+    MarlinMSC.loop();
+  #endif
+}
+
 /* VGPV Done with defines
 // disable interrupts
 void cli(void) { noInterrupts(); }
@@ -270,7 +305,7 @@ void HAL_adc_init(void) {
  #else
    adc.setSampleRate(ADC_SMPR_41_5); // 41.5 ADC cycles
  #endif
-  adc.setPins(adc_pins, ADC_PIN_COUNT);
+  adc.setPins((uint8_t *)adc_pins, ADC_PIN_COUNT);
  adc.setDMA(HAL_adc_results, (uint16_t)ADC_PIN_COUNT, (uint32_t)(DMA_MINC_MODE | DMA_CIRC_MODE), nullptr);
  adc.setScanMode();
  adc.setContinuous();
@@ -305,6 +340,15 @@ void HAL_adc_start_conversion(const uint8_t adc_pin) {
    #if HAS_TEMP_ADC_5
      case TEMP_5_PIN: pin_index = TEMP_5; break;
    #endif
+    #if HAS_JOY_ADC_X
+      case JOY_X_PIN: pin_index = JOY_X; break;
+    #endif
+    #if HAS_JOY_ADC_Y
+      case JOY_Y_PIN: pin_index = JOY_Y; break;
+    #endif
+    #if HAS_JOY_ADC_Z
+      case JOY_Z_PIN: pin_index = JOY_Z; break;
+    #endif
    #if ENABLED(FILAMENT_WIDTH_SENSOR)
      case FILWIDTH_PIN: pin_index = FILWIDTH; break;
    #endif
@@ -33,30 +33,39 @@
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"

-#include "fastio_STM32F1.h"
-#include "watchdog_STM32F1.h"
+#include "fastio.h"
+#include "watchdog.h"

-#include "HAL_timers_STM32F1.h"
+#include "timers.h"

 #include <stdint.h>
 #include <util/atomic.h>

 #include "../../inc/MarlinConfigPre.h"
+#include "msc_sd.h"

 // ------------------------
 // Defines
 // ------------------------

 #ifdef SERIAL_USB
-  #define UsbSerial Serial
+  #ifndef USE_USB_COMPOSITE
+    #define UsbSerial Serial
+  #else
+    #define UsbSerial MarlinCompositeSerial
+  #endif
  #define MSerial1  Serial1
  #define MSerial2  Serial2
  #define MSerial3  Serial3
  #define MSerial4  Serial4
  #define MSerial5  Serial5
 #else
-  extern USBSerial SerialUSB;
-  #define UsbSerial SerialUSB
+  #ifndef USE_USB_COMPOSITE
+    extern USBSerial SerialUSB;
+    #define UsbSerial SerialUSB
+  #else
+    #define UsbSerial MarlinCompositeSerial
+  #endif
  #define MSerial1  Serial
  #define MSerial2  Serial1
  #define MSerial3  Serial2
@@ -111,6 +120,8 @@

 // Set interrupt grouping for this MCU
 void HAL_init(void);
+#define HAL_IDLETASK 1
+void HAL_idletask(void);

 /**
 * TODO: review this to return 1 for pins that are not analog input
@@ -208,17 +219,6 @@ static int freeMemory() {

 #pragma GCC diagnostic pop

-//
-// SPI: Extended functions which take a channel number (hardware SPI only)
-//
-
-// Write single byte to specified SPI channel
-void spiSend(uint32_t chan, byte b);
-// Write buffer to specified SPI channel
-void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-// Read single byte from specified SPI channel
-uint8_t spiRec(uint32_t chan);
-
 //
 // EEPROM
 //
@@ -0,0 +1,738 @@
+/******************************************************************************
+ * The MIT License
+ *
+ * Copyright (c) 2010 Perry Hung.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *****************************************************************************/
+
+/**
+ * @author Marti Bolivar <mbolivar@leaflabs.com>
+ * @brief Wirish SPI implementation.
+ */
+
+#ifdef __STM32F1__
+
+#include <SPI.h>
+
+#include <libmaple/timer.h>
+#include <libmaple/util.h>
+#include <libmaple/rcc.h>
+
+#include <boards.h>
+#include <wirish.h>
+
+/** Time in ms for DMA receive timeout */
+#define DMA_TIMEOUT 100
+
+#if CYCLES_PER_MICROSECOND != 72
+  #warning "Unexpected clock speed; SPI frequency calculation will be incorrect"
+#endif
+
+struct spi_pins { uint8_t nss, sck, miso, mosi; };
+
+static const spi_pins* dev_to_spi_pins(spi_dev *dev);
+static void configure_gpios(spi_dev *dev, bool as_master);
+static spi_baud_rate determine_baud_rate(spi_dev *dev, uint32_t freq);
+
+#if (BOARD_NR_SPI >= 3) && !defined(STM32_HIGH_DENSITY)
+  #error "The SPI library is misconfigured: 3 SPI ports only available on high density STM32 devices"
+#endif
+
+static const spi_pins board_spi_pins[] __FLASH__ = {
+  #if BOARD_NR_SPI >= 1
+    { BOARD_SPI1_NSS_PIN,
+      BOARD_SPI1_SCK_PIN,
+      BOARD_SPI1_MISO_PIN,
+      BOARD_SPI1_MOSI_PIN },
+  #endif
+  #if BOARD_NR_SPI >= 2
+    { BOARD_SPI2_NSS_PIN,
+      BOARD_SPI2_SCK_PIN,
+      BOARD_SPI2_MISO_PIN,
+      BOARD_SPI2_MOSI_PIN },
+  #endif
+  #if BOARD_NR_SPI >= 3
+    { BOARD_SPI3_NSS_PIN,
+      BOARD_SPI3_SCK_PIN,
+      BOARD_SPI3_MISO_PIN,
+      BOARD_SPI3_MOSI_PIN },
+  #endif
+};
+
+#if BOARD_NR_SPI >= 1
+  static void *_spi1_this;
+#endif
+#if BOARD_NR_SPI >= 2
+  static void *_spi2_this;
+#endif
+#if BOARD_NR_SPI >= 3
+  static void *_spi3_this;
+#endif
+
+/**
+ * Constructor
+ */
+SPIClass::SPIClass(uint32_t spi_num) {
+  _currentSetting = &_settings[spi_num - 1];  // SPI channels are called 1 2 and 3 but the array is zero indexed
+
+  switch (spi_num) {
+    #if BOARD_NR_SPI >= 1
+      case 1:
+        _currentSetting->spi_d = SPI1;
+        _spi1_this = (void*)this;
+        break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+      case 2:
+        _currentSetting->spi_d = SPI2;
+        _spi2_this = (void*)this;
+        break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+      case 3:
+        _currentSetting->spi_d = SPI3;
+        _spi3_this = (void*)this;
+        break;
+    #endif
+    default: ASSERT(0);
+  }
+
+  // Init things specific to each SPI device
+  // clock divider setup is a bit of hack, and needs to be improved at a later date.
+  #if BOARD_NR_SPI >= 1
+    _settings[0].spi_d = SPI1;
+    _settings[0].clockDivider = determine_baud_rate(_settings[0].spi_d, _settings[0].clock);
+    _settings[0].spiDmaDev = DMA1;
+    _settings[0].spiTxDmaChannel = DMA_CH3;
+    _settings[0].spiRxDmaChannel = DMA_CH2;
+  #endif
+  #if BOARD_NR_SPI >= 2
+    _settings[1].spi_d = SPI2;
+    _settings[1].clockDivider = determine_baud_rate(_settings[1].spi_d, _settings[1].clock);
+    _settings[1].spiDmaDev = DMA1;
+    _settings[1].spiTxDmaChannel = DMA_CH5;
+    _settings[1].spiRxDmaChannel = DMA_CH4;
+  #endif
+  #if BOARD_NR_SPI >= 3
+    _settings[2].spi_d = SPI3;
+    _settings[2].clockDivider = determine_baud_rate(_settings[2].spi_d, _settings[2].clock);
+    _settings[2].spiDmaDev = DMA2;
+    _settings[2].spiTxDmaChannel = DMA_CH2;
+    _settings[2].spiRxDmaChannel = DMA_CH1;
+  #endif
+
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_IDLE;
+}
+
+/**
+ * Set up/tear down
+ */
+void SPIClass::updateSettings() {
+  uint32_t flags = ((_currentSetting->bitOrder == MSBFIRST ? SPI_FRAME_MSB : SPI_FRAME_LSB) | _currentSetting->dataSize | SPI_SW_SLAVE | SPI_SOFT_SS);
+  spi_master_enable(_currentSetting->spi_d, (spi_baud_rate)_currentSetting->clockDivider, (spi_mode)_currentSetting->dataMode, flags);
+}
+
+void SPIClass::begin() {
+  spi_init(_currentSetting->spi_d);
+  configure_gpios(_currentSetting->spi_d, 1);
+  updateSettings();
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_READY;
+}
+
+void SPIClass::beginSlave() {
+  spi_init(_currentSetting->spi_d);
+  configure_gpios(_currentSetting->spi_d, 0);
+  uint32_t flags = ((_currentSetting->bitOrder == MSBFIRST ? SPI_FRAME_MSB : SPI_FRAME_LSB) | _currentSetting->dataSize);
+  spi_slave_enable(_currentSetting->spi_d, (spi_mode)_currentSetting->dataMode, flags);
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_READY;
+}
+
+void SPIClass::end() {
+  if (!spi_is_enabled(_currentSetting->spi_d)) return;
+
+  // Follows RM0008's sequence for disabling a SPI in master/slave
+  // full duplex mode.
+  while (spi_is_rx_nonempty(_currentSetting->spi_d)) {
+    // FIXME [0.1.0] remove this once you have an interrupt based driver
+    volatile uint16_t rx __attribute__((unused)) = spi_rx_reg(_currentSetting->spi_d);
+  }
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ }
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ }
+
+  spi_peripheral_disable(_currentSetting->spi_d);
+  // added for DMA callbacks.
+  // Need to add unsetting the callbacks for the DMA channels.
+  _currentSetting->state = SPI_STATE_IDLE;
+}
+
+/* Roger Clark added  3 functions */
+void SPIClass::setClockDivider(uint32_t clockDivider) {
+  _currentSetting->clockDivider = clockDivider;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_BR);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (clockDivider & SPI_CR1_BR);
+}
+
+void SPIClass::setBitOrder(BitOrder bitOrder) {
+  _currentSetting->bitOrder = bitOrder;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_LSBFIRST);
+  if (bitOrder == LSBFIRST) cr1 |= SPI_CR1_LSBFIRST;
+  _currentSetting->spi_d->regs->CR1 = cr1;
+}
+
+/**
+ * Victor Perez. Added to test changing datasize from 8 to 16 bit modes on the fly.
+ * Input parameter should be SPI_CR1_DFF set to 0 or 1 on a 32bit word.
+ */
+void SPIClass::setDataSize(uint32_t datasize) {
+  _currentSetting->dataSize = datasize;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_DFF);
+  uint8_t en = spi_is_enabled(_currentSetting->spi_d);
+  spi_peripheral_disable(_currentSetting->spi_d);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (datasize & SPI_CR1_DFF) | en;
+}
+
+void SPIClass::setDataMode(uint8_t dataMode) {
+  /*
+  Notes:
+  As far as we know the AVR numbers for dataMode match the numbers required by the STM32.
+  From the AVR doc http://www.atmel.com/images/doc2585.pdf section 2.4
+
+  SPI Mode  CPOL  CPHA  Shift SCK-edge  Capture SCK-edge
+  0       0     0     Falling     Rising
+  1       0     1     Rising      Falling
+  2       1     0     Rising      Falling
+  3       1     1     Falling     Rising
+
+  On the STM32 it appears to be
+
+  bit 1 - CPOL : Clock polarity
+    (This bit should not be changed when communication is ongoing)
+    0 : CLK to 0 when idle
+    1 : CLK to 1 when idle
+
+  bit 0 - CPHA : Clock phase
+    (This bit should not be changed when communication is ongoing)
+    0 : The first clock transition is the first data capture edge
+    1 : The second clock transition is the first data capture edge
+
+  If someone finds this is not the case or sees a logic error with this let me know ;-)
+  */
+  _currentSetting->dataMode = dataMode;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_CPOL|SPI_CR1_CPHA);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (dataMode & (SPI_CR1_CPOL|SPI_CR1_CPHA));
+}
+
+void SPIClass::beginTransaction(uint8_t pin, SPISettings settings) {
+  setBitOrder(settings.bitOrder);
+  setDataMode(settings.dataMode);
+  setDataSize(settings.dataSize);
+  setClockDivider(determine_baud_rate(_currentSetting->spi_d, settings.clock));
+  begin();
+}
+
+void SPIClass::beginTransactionSlave(SPISettings settings) {
+  setBitOrder(settings.bitOrder);
+  setDataMode(settings.dataMode);
+  setDataSize(settings.dataSize);
+  beginSlave();
+}
+
+void SPIClass::endTransaction() { }
+
+/**
+ * I/O
+ */
+
+uint16_t SPIClass::read() {
+  while (!spi_is_rx_nonempty(_currentSetting->spi_d)) { /* nada */ }
+  return (uint16)spi_rx_reg(_currentSetting->spi_d);
+}
+
+void SPIClass::read(uint8_t *buf, uint32_t len) {
+  if (len == 0) return;
+  spi_rx_reg(_currentSetting->spi_d);   // clear the RX buffer in case a byte is waiting on it.
+  spi_reg_map * regs = _currentSetting->spi_d->regs;
+  // start sequence: write byte 0
+  regs->DR = 0x00FF;            // write the first byte
+  // main loop
+  while (--len) {
+    while(!(regs->SR & SPI_SR_TXE)) { /* nada */ } // wait for TXE flag
+    noInterrupts();    // go atomic level - avoid interrupts to surely get the previously received data
+    regs->DR = 0x00FF; // write the next data item to be transmitted into the SPI_DR register. This clears the TXE flag.
+    while (!(regs->SR & SPI_SR_RXNE)) { /* nada */ } // wait till data is available in the DR register
+    *buf++ = (uint8)(regs->DR); // read and store the received byte. This clears the RXNE flag.
+    interrupts();      // let systick do its job
+  }
+  // read remaining last byte
+  while (!(regs->SR & SPI_SR_RXNE)) { /* nada */ } // wait till data is available in the Rx register
+  *buf++ = (uint8)(regs->DR);  // read and store the received byte
+}
+
+void SPIClass::write(uint16_t data) {
+  /* Added for 16bit data Victor Perez. Roger Clark
+   * Improved speed by just directly writing the single byte to the SPI data reg and wait for completion,
+   * by taking the Tx code from transfer(byte)
+   * This almost doubles the speed of this function.
+   */
+  spi_tx_reg(_currentSetting->spi_d, data); // write the data to be transmitted into the SPI_DR register (this clears the TXE flag)
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+}
+
+void SPIClass::write16(uint16_t data) {
+  // Added by stevestrong: write two consecutive bytes in 8 bit mode (DFF=0)
+  spi_tx_reg(_currentSetting->spi_d, data>>8); // write high byte
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // Wait until TXE=1
+  spi_tx_reg(_currentSetting->spi_d, data); // write low byte
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // Wait until TXE=1
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // wait until BSY=0
+}
+
+void SPIClass::write(uint16_t data, uint32_t n) {
+  // Added by stevstrong: Repeatedly send same data by the specified number of times
+  spi_reg_map * regs = _currentSetting->spi_d->regs;
+  while (n--) {
+    regs->DR = data; // write the data to be transmitted into the SPI_DR register (this clears the TXE flag)
+    while (!(regs->SR & SPI_SR_TXE)) { /* nada */ } // wait till Tx empty
+  }
+  while (regs->SR & SPI_SR_BSY) { /* nada */ } // wait until BSY=0 before returning
+}
+
+void SPIClass::write(const void *data, uint32_t length) {
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_tx(spi_d, data, length); // data can be array of bytes or words
+  while (!spi_is_tx_empty(spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+}
+
+uint8_t SPIClass::transfer(uint8_t byte) const {
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_rx_reg(spi_d); // read any previous data
+  spi_tx_reg(spi_d, byte); // Write the data item to be transmitted into the SPI_DR register
+  while (!spi_is_tx_empty(spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+  return (uint8)spi_rx_reg(spi_d); // "... and read the last received data."
+}
+
+uint16_t SPIClass::transfer16(uint16_t data) const {
+  // Modified by stevestrong: write & read two consecutive bytes in 8 bit mode (DFF=0)
+  // This is more effective than two distinct byte transfers
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_rx_reg(spi_d);                              // read any previous data
+  spi_tx_reg(spi_d, data>>8);                     // write high byte
+  while (!spi_is_tx_empty(spi_d)) { /* nada */ }  // wait until TXE=1
+  while (spi_is_busy(spi_d)) { /* nada */ }       // wait until BSY=0
+  uint16_t ret = spi_rx_reg(spi_d)<<8;            // read and shift high byte
+  spi_tx_reg(spi_d, data);                        // write low byte
+  while (!spi_is_tx_empty(spi_d)) { /* nada */ }  // wait until TXE=1
+  while (spi_is_busy(spi_d)) { /* nada */ }       // wait until BSY=0
+  ret += spi_rx_reg(spi_d);                       // read low byte
+  return ret;
+}
+
+/**
+ * Roger Clark and Victor Perez, 2015
+ * Performs a DMA SPI transfer with at least a receive buffer.
+ * If a TX buffer is not provided, FF is sent over and over for the lenght of the transfer.
+ * On exit TX buffer is not modified, and RX buffer cotains the received data.
+ * Still in progress.
+ */
+void SPIClass::dmaTransferSet(const void *transmitBuf, void *receiveBuf) {
+  dma_init(_currentSetting->spiDmaDev);
+  //spi_rx_dma_enable(_currentSetting->spi_d);
+  //spi_tx_dma_enable(_currentSetting->spi_d);
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &_currentSetting->spi_d->regs->DR,
+      dma_bit_size, receiveBuf, dma_bit_size, (DMA_MINC_MODE | DMA_TRNS_CMPLT ));// receive buffer DMA
+  if (!transmitBuf) {
+    transmitBuf = &ff;
+    dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+        dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, (DMA_FROM_MEM));// Transmit FF repeatedly
+  }
+  else {
+    dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+        dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, (DMA_MINC_MODE |  DMA_FROM_MEM ));// Transmit buffer DMA
+  }
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, DMA_PRIORITY_LOW);
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, DMA_PRIORITY_VERY_HIGH);
+}
+
+uint8_t SPIClass::dmaTransferRepeat(uint16_t length) {
+  if (length == 0) return 0;
+  if (spi_is_rx_nonempty(_currentSetting->spi_d) == 1) spi_rx_reg(_currentSetting->spi_d);
+  _currentSetting->state = SPI_STATE_TRANSFER;
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, length);
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);// enable receive
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);// enable transmit
+  spi_rx_dma_enable(_currentSetting->spi_d);
+  spi_tx_dma_enable(_currentSetting->spi_d);
+  if (_currentSetting->receiveCallback)
+    return 0;
+
+  //uint32_t m = millis();
+  uint8_t b = 0;
+  uint32_t m = millis();
+  while (!(dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1)) {
+    // Avoid interrupts and just loop waiting for the flag to be set.
+    if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+  }
+
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+  spi_tx_dma_disable(_currentSetting->spi_d);
+  spi_rx_dma_disable(_currentSetting->spi_d);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  _currentSetting->state = SPI_STATE_READY;
+  return b;
+}
+
+/**
+ * Roger Clark and Victor Perez, 2015
+ * Performs a DMA SPI transfer with at least a receive buffer.
+ * If a TX buffer is not provided, FF is sent over and over for the length of the transfer.
+ * On exit TX buffer is not modified, and RX buffer contains the received data.
+ * Still in progress.
+ */
+uint8_t SPIClass::dmaTransfer(const void *transmitBuf, void *receiveBuf, uint16_t length) {
+  dmaTransferSet(transmitBuf, receiveBuf);
+  return dmaTransferRepeat(length);
+}
+
+/**
+ * Roger Clark and Victor Perez, 2015
+ * Performs a DMA SPI send using a TX buffer.
+ * On exit TX buffer is not modified.
+ * Still in progress.
+ * 2016 - stevstrong - reworked to automatically detect bit size from SPI setting
+ */
+void SPIClass::dmaSendSet(const void * transmitBuf, bool minc) {
+  uint32_t flags = ( (DMA_MINC_MODE*minc) | DMA_FROM_MEM | DMA_TRNS_CMPLT);
+  dma_init(_currentSetting->spiDmaDev);
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR, dma_bit_size,
+             (volatile void*)transmitBuf, dma_bit_size, flags);// Transmit buffer DMA
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, DMA_PRIORITY_LOW);
+}
+
+uint8_t SPIClass::dmaSendRepeat(uint16_t length) {
+  if (length == 0) return 0;
+
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  _currentSetting->state = SPI_STATE_TRANSMIT;
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);   // enable transmit
+  spi_tx_dma_enable(_currentSetting->spi_d);
+  if (_currentSetting->transmitCallback) return 0;
+
+  uint32_t m = millis();
+  uint8_t b = 0;
+  while (!(dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1)) {
+    // Avoid interrupts and just loop waiting for the flag to be set.
+    if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+  }
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+  spi_tx_dma_disable(_currentSetting->spi_d);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  _currentSetting->state = SPI_STATE_READY;
+  return b;
+}
+
+uint8_t SPIClass::dmaSend(const void * transmitBuf, uint16_t length, bool minc) {
+  dmaSendSet(transmitBuf, minc);
+  return dmaSendRepeat(length);
+}
+
+uint8_t SPIClass::dmaSendAsync(const void * transmitBuf, uint16_t length, bool minc) {
+  uint8_t b = 0;
+
+  if (_currentSetting->state != SPI_STATE_READY) {
+    uint32_t m = millis();
+    while (!(dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1)) {
+      //Avoid interrupts and just loop waiting for the flag to be set.
+      //delayMicroseconds(10);
+      if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+    }
+
+    while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+    while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // "... and then wait until BSY=0 before disabling the SPI."
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    _currentSetting->state = SPI_STATE_READY;
+  }
+
+  if (length == 0) return 0;
+  uint32_t flags = ( (DMA_MINC_MODE*minc) | DMA_FROM_MEM | DMA_TRNS_CMPLT);
+
+  dma_init(_currentSetting->spiDmaDev);
+  // TX
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+      dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, flags);// Transmit buffer DMA
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);// enable transmit
+  spi_tx_dma_enable(_currentSetting->spi_d);
+
+  _currentSetting->state = SPI_STATE_TRANSMIT;
+  return b;
+}
+
+
+/**
+ *  New functions added to manage callbacks.
+ *  Victor Perez 2017
+ */
+void SPIClass::onReceive(void(*callback)(void)) {
+  _currentSetting->receiveCallback = callback;
+  if (callback) {
+    switch (_currentSetting->spi_d->clk_id) {
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+    case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
+    }
+  }
+  else {
+    dma_detach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  }
+}
+
+void SPIClass::onTransmit(void(*callback)(void)) {
+  _currentSetting->transmitCallback = callback;
+  if (callback) {
+    switch (_currentSetting->spi_d->clk_id) {
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+     case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
+    }
+  }
+  else {
+    dma_detach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  }
+}
+
+/**
+ * TODO: check if better to first call the customer code, next disable the DMA requests.
+ * Also see if we need to check whether callbacks are set or not, may be better to be checked
+ * during the initial setup and only set the callback to EventCallback if they are set.
+ */
+void SPIClass::EventCallback() {
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) { /* nada */ } // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d)) { /* nada */ } // "... and then wait until BSY=0"
+  switch (_currentSetting->state) {
+  case SPI_STATE_TRANSFER:
+    while (spi_is_rx_nonempty(_currentSetting->spi_d)) { /* nada */ }
+    _currentSetting->state = SPI_STATE_READY;
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    spi_rx_dma_disable(_currentSetting->spi_d);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+    if (_currentSetting->receiveCallback)
+      _currentSetting->receiveCallback();
+    break;
+  case SPI_STATE_TRANSMIT:
+    _currentSetting->state = SPI_STATE_READY;
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    if (_currentSetting->transmitCallback)
+      _currentSetting->transmitCallback();
+    break;
+  default:
+    break;
+  }
+}
+
+void SPIClass::attachInterrupt() {
+  // Should be enableInterrupt()
+}
+
+void SPIClass::detachInterrupt() {
+  // Should be disableInterrupt()
+}
+
+/*
+ * Pin accessors
+ */
+
+uint8_t SPIClass::misoPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->miso;
+}
+
+uint8_t SPIClass::mosiPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->mosi;
+}
+
+uint8_t SPIClass::sckPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->sck;
+}
+
+uint8_t SPIClass::nssPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->nss;
+}
+
+/*
+ * Deprecated functions
+ */
+
+uint8_t SPIClass::send(uint8_t data) {
+  this->write(data);
+  return 1;
+}
+
+uint8_t SPIClass::send(uint8_t *buf, uint32_t len) {
+  this->write(buf, len);
+  return len;
+}
+
+uint8_t SPIClass::recv() {
+  return this->read();
+}
+
+/*
+ * DMA call back functions, one per port.
+ */
+#if BOARD_NR_SPI >= 1
+  void SPIClass::_spi1EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi1_this)->EventCallback();
+  }
+#endif
+#if BOARD_NR_SPI >= 2
+  void SPIClass::_spi2EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi2_this)->EventCallback();
+  }
+#endif
+#if BOARD_NR_SPI >= 3
+  void SPIClass::_spi3EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi3_this)->EventCallback();
+  }
+#endif
+
+/*
+ * Auxiliary functions
+ */
+static const spi_pins* dev_to_spi_pins(spi_dev *dev) {
+  switch (dev->clk_id) {
+    #if BOARD_NR_SPI >= 1
+      case RCC_SPI1: return board_spi_pins;
+    #endif
+    #if BOARD_NR_SPI >= 2
+      case RCC_SPI2: return board_spi_pins + 1;
+    #endif
+    #if BOARD_NR_SPI >= 3
+      case RCC_SPI3: return board_spi_pins + 2;
+    #endif
+    default: return NULL;
+  }
+}
+
+static void disable_pwm(const stm32_pin_info *i) {
+  if (i->timer_device)
+    timer_set_mode(i->timer_device, i->timer_channel, TIMER_DISABLED);
+}
+
+static void configure_gpios(spi_dev *dev, bool as_master) {
+  const spi_pins *pins = dev_to_spi_pins(dev);
+  if (!pins) return;
+
+  const stm32_pin_info *nssi = &PIN_MAP[pins->nss],
+                       *scki = &PIN_MAP[pins->sck],
+                       *misoi = &PIN_MAP[pins->miso],
+                       *mosii = &PIN_MAP[pins->mosi];
+
+  disable_pwm(nssi);
+  disable_pwm(scki);
+  disable_pwm(misoi);
+  disable_pwm(mosii);
+
+  spi_config_gpios(dev, as_master, nssi->gpio_device, nssi->gpio_bit,
+  scki->gpio_device, scki->gpio_bit, misoi->gpio_bit,
+  mosii->gpio_bit);
+}
+
+static const spi_baud_rate baud_rates[8] __FLASH__ = {
+  SPI_BAUD_PCLK_DIV_2,
+  SPI_BAUD_PCLK_DIV_4,
+  SPI_BAUD_PCLK_DIV_8,
+  SPI_BAUD_PCLK_DIV_16,
+  SPI_BAUD_PCLK_DIV_32,
+  SPI_BAUD_PCLK_DIV_64,
+  SPI_BAUD_PCLK_DIV_128,
+  SPI_BAUD_PCLK_DIV_256,
+};
+
+/**
+ * Note: This assumes you're on a LeafLabs-style board
+ * (CYCLES_PER_MICROSECOND == 72, APB2 at 72MHz, APB1 at 36MHz).
+ */
+static spi_baud_rate determine_baud_rate(spi_dev *dev, uint32_t freq) {
+  uint32_t clock = 0;
+  switch (rcc_dev_clk(dev->clk_id)) {
+    case RCC_AHB:
+    case RCC_APB2: clock = STM32_PCLK2; break; // 72 Mhz
+    case RCC_APB1: clock = STM32_PCLK1; break; // 36 Mhz
+  }
+  clock >>= 1;
+
+  uint8_t i = 0;
+  while (i < 7 && freq < clock) { clock >>= 1; i++; }
+  return baud_rates[i];
+}
+
+SPIClass SPI(1);
+
+#endif // __STM32F1__
@@ -0,0 +1,409 @@
+/******************************************************************************
+ * The MIT License
+ *
+ * Copyright (c) 2010 Perry Hung.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *****************************************************************************/
+#pragma once
+
+#include <libmaple/libmaple_types.h>
+#include <libmaple/spi.h>
+#include <libmaple/dma.h>
+
+#include <boards.h>
+#include <stdint.h>
+#include <wirish.h>
+
+// SPI_HAS_TRANSACTION means SPI has
+//   - beginTransaction()
+//   - endTransaction()
+//   - usingInterrupt()
+//   - SPISetting(clock, bitOrder, dataMode)
+//#define SPI_HAS_TRANSACTION
+
+#define SPI_CLOCK_DIV2   SPI_BAUD_PCLK_DIV_2
+#define SPI_CLOCK_DIV4   SPI_BAUD_PCLK_DIV_4
+#define SPI_CLOCK_DIV8   SPI_BAUD_PCLK_DIV_8
+#define SPI_CLOCK_DIV16  SPI_BAUD_PCLK_DIV_16
+#define SPI_CLOCK_DIV32  SPI_BAUD_PCLK_DIV_32
+#define SPI_CLOCK_DIV64  SPI_BAUD_PCLK_DIV_64
+#define SPI_CLOCK_DIV128 SPI_BAUD_PCLK_DIV_128
+#define SPI_CLOCK_DIV256 SPI_BAUD_PCLK_DIV_256
+
+/*
+ * Roger Clark. 20150106
+ * Commented out redundant AVR defined
+ *
+#define SPI_MODE_MASK 0x0C     // CPOL = bit 3, CPHA = bit 2 on SPCR
+#define SPI_CLOCK_MASK 0x03    // SPR1 = bit 1, SPR0 = bit 0 on SPCR
+#define SPI_2XCLOCK_MASK 0x01  // SPI2X = bit 0 on SPSR
+
+// define SPI_AVR_EIMSK for AVR boards with external interrupt pins
+#ifdef EIMSK
+  #define SPI_AVR_EIMSK EIMSK
+#elif defined(GICR)
+  #define SPI_AVR_EIMSK GICR
+#elif defined(GIMSK)
+  #define SPI_AVR_EIMSK GIMSK
+#endif
+*/
+
+#ifndef STM32_LSBFIRST
+  #define STM32_LSBFIRST 0
+#endif
+#ifndef STM32_MSBFIRST
+  #define STM32_MSBFIRST 1
+#endif
+
+// PC13 or PA4
+#define BOARD_SPI_DEFAULT_SS PA4
+//#define BOARD_SPI_DEFAULT_SS PC13
+
+#define SPI_MODE0 SPI_MODE_0
+#define SPI_MODE1 SPI_MODE_1
+#define SPI_MODE2 SPI_MODE_2
+#define SPI_MODE3 SPI_MODE_3
+
+#define DATA_SIZE_8BIT SPI_CR1_DFF_8_BIT
+#define DATA_SIZE_16BIT SPI_CR1_DFF_16_BIT
+
+typedef enum {
+  SPI_STATE_IDLE,
+  SPI_STATE_READY,
+  SPI_STATE_RECEIVE,
+  SPI_STATE_TRANSMIT,
+  SPI_STATE_TRANSFER
+} spi_mode_t;
+
+class SPISettings {
+public:
+  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, bitOrder, dataMode, DATA_SIZE_8BIT);
+    else
+      init_MightInline(clock, bitOrder, dataMode, DATA_SIZE_8BIT);
+  }
+  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, bitOrder, dataMode, dataSize);
+    else
+      init_MightInline(clock, bitOrder, dataMode, dataSize);
+  }
+  SPISettings(uint32_t clock) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+    else
+      init_MightInline(clock, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+  }
+  SPISettings() {
+    init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+  }
+private:
+  void init_MightInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) {
+    init_AlwaysInline(clock, bitOrder, dataMode, dataSize);
+  }
+  void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) __attribute__((__always_inline__)) {
+    this->clock = clock;
+    this->bitOrder = bitOrder;
+    this->dataMode = dataMode;
+    this->dataSize = dataSize;
+  }
+  uint32_t clock;
+  uint32_t dataSize;
+  uint32_t clockDivider;
+  BitOrder bitOrder;
+  uint8_t dataMode;
+  uint8_t _SSPin;
+  volatile spi_mode_t state;
+  spi_dev *spi_d;
+  dma_channel spiRxDmaChannel, spiTxDmaChannel;
+  dma_dev* spiDmaDev;
+  void (*receiveCallback)(void) = NULL;
+  void (*transmitCallback)(void) = NULL;
+
+  friend class SPIClass;
+};
+
+/*
+ * Kept for compat.
+ */
+static const uint8_t ff = 0xFF;
+
+/**
+ * @brief Wirish SPI interface.
+ *
+ * This implementation uses software slave management, so the caller
+ * is responsible for controlling the slave select line.
+ */
+class SPIClass {
+
+public:
+  /**
+   * @param spiPortNumber Number of the SPI port to manage.
+   */
+  SPIClass(uint32_t spiPortNumber);
+
+  /**
+   * @brief Equivalent to begin(SPI_1_125MHZ, MSBFIRST, 0).
+   */
+  void begin();
+
+  /**
+   * @brief Turn on a SPI port and set its GPIO pin modes for use as a slave.
+   *
+   * SPI port is enabled in full duplex mode, with software slave management.
+   *
+   * @param bitOrder Either LSBFIRST (little-endian) or MSBFIRST(big-endian)
+   * @param mode SPI mode to use
+   */
+  void beginSlave(uint32_t bitOrder, uint32_t mode);
+
+  /**
+   * @brief Equivalent to beginSlave(MSBFIRST, 0).
+   */
+  void beginSlave();
+
+  /**
+   * @brief Disables the SPI port, but leaves its GPIO pin modes unchanged.
+   */
+  void end();
+
+  void beginTransaction(SPISettings settings) { beginTransaction(BOARD_SPI_DEFAULT_SS, settings); }
+  void beginTransaction(uint8_t pin, SPISettings settings);
+  void endTransaction();
+
+  void beginTransactionSlave(SPISettings settings);
+
+  void setClockDivider(uint32_t clockDivider);
+  void setBitOrder(BitOrder bitOrder);
+  void setDataMode(uint8_t dataMode);
+
+  // SPI Configuration methods
+  void attachInterrupt();
+  void detachInterrupt();
+
+  /* Victor Perez. Added to change datasize from 8 to 16 bit modes on the fly.
+   * Input parameter should be SPI_CR1_DFF set to 0 or 1 on a 32bit word.
+   * Requires an added function spi_data_size on STM32F1 / cores / maple / libmaple / spi.c
+   */
+  void setDataSize(uint32_t ds);
+
+  /* Victor Perez 2017. Added to set and clear callback functions for callback
+   * on DMA transfer completion.
+   * onReceive used to set the callback in case of dmaTransfer (tx/rx), once rx is completed
+   * onTransmit used to set the callback in case of dmaSend (tx only). That function
+   * will NOT be called in case of TX/RX
+   */
+  void onReceive(void(*)(void));
+  void onTransmit(void(*)(void));
+
+  /*
+   * I/O
+   */
+
+  /**
+   * @brief Return the next unread byte/word.
+   *
+   * If there is no unread byte/word waiting, this function will block
+   * until one is received.
+   */
+  uint16_t read();
+
+  /**
+   * @brief Read length bytes, storing them into buffer.
+   * @param buffer Buffer to store received bytes into.
+   * @param length Number of bytes to store in buffer. This
+   *               function will block until the desired number of
+   *               bytes have been read.
+   */
+  void read(uint8_t *buffer, uint32_t length);
+
+  /**
+   * @brief Transmit one byte/word.
+   * @param data to transmit.
+   */
+  void write(uint16_t data);
+  void write16(uint16_t data); // write 2 bytes in 8 bit mode (DFF=0)
+
+  /**
+   * @brief Transmit one byte/word a specified number of times.
+   * @param data to transmit.
+   */
+  void write(uint16_t data, uint32_t n);
+
+  /**
+   * @brief Transmit multiple bytes/words.
+   * @param buffer Bytes/words to transmit.
+   * @param length Number of bytes/words in buffer to transmit.
+   */
+  void write(const void * buffer, uint32_t length);
+
+  /**
+   * @brief Transmit a byte, then return the next unread byte.
+   *
+   * This function transmits before receiving.
+   *
+   * @param data Byte to transmit.
+   * @return Next unread byte.
+   */
+  uint8_t transfer(uint8_t data) const;
+  uint16_t transfer16(uint16_t data) const;
+
+  /**
+   * @brief Sets up a DMA Transfer for "length" bytes.
+   * The transfer mode (8 or 16 bit mode) is evaluated from the SPI peripheral setting.
+   *
+   * This function transmits and receives to buffers.
+   *
+   * @param transmitBuf buffer Bytes to transmit. If passed as 0, it sends FF repeatedly for "length" bytes
+   * @param receiveBuf buffer Bytes to save received data.
+   * @param length Number of bytes in buffer to transmit.
+   */
+  uint8_t dmaTransfer(const void * transmitBuf, void * receiveBuf, uint16_t length);
+  void dmaTransferSet(const void *transmitBuf, void *receiveBuf);
+  uint8_t dmaTransferRepeat(uint16_t length);
+
+  /**
+   * @brief Sets up a DMA Transmit for SPI 8 or 16 bit transfer mode.
+   * The transfer mode (8 or 16 bit mode) is evaluated from the SPI peripheral setting.
+   *
+   * This function only transmits and does not care about the RX fifo.
+   *
+   * @param data buffer half words to transmit,
+   * @param length Number of bytes in buffer to transmit.
+   * @param minc Set to use Memory Increment mode, clear to use Circular mode.
+   */
+  uint8_t dmaSend(const void * transmitBuf, uint16_t length, bool minc = 1);
+  void dmaSendSet(const void * transmitBuf, bool minc);
+  uint8_t dmaSendRepeat(uint16_t length);
+
+  uint8_t dmaSendAsync(const void * transmitBuf, uint16_t length, bool minc = 1);
+  /*
+   * Pin accessors
+   */
+
+  /**
+   * @brief Return the number of the MISO (master in, slave out) pin
+   */
+  uint8_t misoPin();
+
+  /**
+   * @brief Return the number of the MOSI (master out, slave in) pin
+   */
+  uint8_t mosiPin();
+
+  /**
+   * @brief Return the number of the SCK (serial clock) pin
+   */
+  uint8_t sckPin();
+
+  /**
+   * @brief Return the number of the NSS (slave select) pin
+   */
+  uint8_t nssPin();
+
+  /* Escape hatch */
+
+  /**
+   * @brief Get a pointer to the underlying libmaple spi_dev for
+   *        this HardwareSPI instance.
+   */
+  spi_dev* c_dev(void) { return _currentSetting->spi_d; }
+
+  spi_dev* dev() { return _currentSetting->spi_d; }
+
+  /**
+   * @brief Sets the number of the SPI peripheral to be used by
+   *        this HardwareSPI instance.
+   *
+   * @param spi_num Number of the SPI port. 1-2 in low density devices
+   *     or 1-3 in high density devices.
+   */
+  void setModule(int spi_num) {
+    _currentSetting=&_settings[spi_num-1];// SPI channels are called 1 2 and 3 but the array is zero indexed
+  }
+
+  /* -- The following methods are deprecated --------------------------- */
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::transfer() instead.
+   *
+   * @see HardwareSPI::transfer()
+   */
+  uint8_t send(uint8_t data);
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::write() in combination with
+   * HardwareSPI::read() (or HardwareSPI::transfer()) instead.
+   *
+   * @see HardwareSPI::write()
+   * @see HardwareSPI::read()
+   * @see HardwareSPI::transfer()
+   */
+  uint8_t send(uint8_t *data, uint32_t length);
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::read() instead.
+   *
+   * @see HardwareSPI::read()
+   */
+  uint8_t recv();
+
+private:
+
+  SPISettings _settings[BOARD_NR_SPI];
+  SPISettings *_currentSetting;
+
+  void updateSettings();
+
+  /*
+   * Functions added for DMA transfers with Callback.
+   * Experimental.
+   */
+
+  void EventCallback();
+
+  #if BOARD_NR_SPI >= 1
+    static void _spi1EventCallback();
+  #endif
+  #if BOARD_NR_SPI >= 2
+    static void _spi2EventCallback();
+  #endif
+  #if BOARD_NR_SPI >= 3
+    static void _spi3EventCallback();
+  #endif
+  /*
+  spi_dev *spi_d;
+  uint8_t _SSPin;
+  uint32_t clockDivider;
+  uint8_t dataMode;
+  BitOrder bitOrder;
+  */
+};
+
+extern SPIClass SPI;
@@ -29,8 +29,8 @@

 uint8_t ServoCount = 0;

-#include "HAL_Servo_STM32F1.h"
-#include "HAL_timers_STM32F1.h"
+#include "Servo.h"
+#include "timers.h"

 //#include "Servo.h"

@@ -0,0 +1,56 @@
+;
+; STMicroelectronics Communication Device Class driver installation file
+; (C)2006 Copyright STMicroelectronics
+;
+
+[Version]
+Signature="$Windows NT$"
+Class=Ports
+ClassGuid={4D36E978-E325-11CE-BFC1-08002BE10318}
+Provider=%STM%
+LayoutFile=layout.inf
+
+[Manufacturer]
+%MFGNAME%=VirComDevice,NT,NTamd64
+
+[DestinationDirs]
+DefaultDestDir = 12
+
+[VirComDevice.NT]
+%DESCRIPTION%=DriverInstall,USB\VID_1EAF&PID_0029&MI_01
+%DESCRIPTION%=DriverInstall,USB\VID_1EAF&PID_0029&MI_01
+
+[VirComDevice.NTamd64]
+%DESCRIPTION%=DriverInstall,USB\VID_1EAF&PID_0029&MI_01
+%DESCRIPTION%=DriverInstall,USB\VID_1EAF&PID_0029&MI_01
+
+[DriverInstall.NT]
+Include=mdmcpq.inf
+CopyFiles=FakeModemCopyFileSection
+AddReg=DriverInstall.NT.AddReg
+
+[DriverInstall.NT.AddReg]
+HKR,,DevLoader,,*ntkern
+HKR,,NTMPDriver,,usbser.sys
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
+
+[DriverInstall.NT.Services]
+AddService=usbser, 0x00000002, DriverServiceInst
+
+[DriverServiceInst]
+DisplayName=%SERVICE%
+ServiceType=1
+StartType=3
+ErrorControl=1
+ServiceBinary=%12%\usbser.sys
+
+;------------------------------------------------------------------------------
+;  String Definitions
+;------------------------------------------------------------------------------
+
+
+[Strings]
+STM         = "LeafLabs"
+MFGNAME     = "LeafLabs"
+DESCRIPTION = "Maple R3"
+SERVICE     = "USB Virtual COM port"
@@ -0,0 +1,64 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifdef USE_USB_COMPOSITE
+
+#include "msc_sd.h"
+#include "SPI.h"
+
+#define PRODUCT_ID 0x29
+
+USBMassStorage MarlinMSC;
+USBCompositeSerial MarlinCompositeSerial;
+
+#include "../../inc/MarlinConfig.h"
+
+#ifdef HAS_ONBOARD_SD
+
+  #include "onboard_sd.h"
+
+  static bool MSC_Write(const uint8_t *writebuff, uint32_t startSector, uint16_t numSectors) {
+    return (disk_write(0, writebuff, startSector, numSectors) == RES_OK);
+  }
+  static bool MSC_Read(uint8_t *readbuff, uint32_t startSector, uint16_t numSectors) {
+    return (disk_read(0, readbuff, startSector, numSectors) == RES_OK);
+  }
+
+#endif
+
+void MSC_SD_init() {
+  USBComposite.setProductId(PRODUCT_ID);
+  // Just set MarlinCompositeSerial enabled to true
+  // because when MarlinCompositeSerial.begin() is used in setup()
+  // it clears all USBComposite devices.
+  MarlinCompositeSerial.begin();
+  USBComposite.end();
+  USBComposite.clear();
+  // Set api and register mass storage
+  #ifdef HAS_ONBOARD_SD
+    uint32_t cardSize;
+    if (disk_initialize(0) == RES_OK) {
+      if (disk_ioctl(0, GET_SECTOR_COUNT, (void *)(&cardSize)) == RES_OK) {
+        MarlinMSC.setDriveData(0, cardSize, MSC_Read, MSC_Write);
+        MarlinMSC.registerComponent();
+      }
+    }
+  #endif
+  // Register composite Serial
+  MarlinCompositeSerial.registerComponent();
+  USBComposite.begin();
+}
+
+#endif // USE_USB_COMPOSITE
@@ -0,0 +1,24 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <USBComposite.h>
+
+extern USBMassStorage MarlinMSC;
+extern USBCompositeSerial MarlinCompositeSerial;
+
+void MSC_SD_init();
@@ -0,0 +1,558 @@
+/*------------------------------------------------------------------------*/
+/* STM32F1: MMCv3/SDv1/SDv2 (SPI mode) control module                     */
+/*------------------------------------------------------------------------*/
+/*
+/ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+/ * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
+/ * Copyright (C) 2015, ChaN, all right reserved.
+/
+/ * This software is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/-------------------------------------------------------------------------*/
+#include "../../inc/MarlinConfig.h"
+
+#ifdef HAS_ONBOARD_SD
+
+#include "onboard_sd.h"
+#include "spi.h"
+#include "fastio.h"
+
+#ifdef SHARED_SD_CARD
+  #ifndef ON_BOARD_SPI_DEVICE
+    #define ON_BOARD_SPI_DEVICE SPI_DEVICE
+  #endif
+  #define ONBOARD_SD_SPI SPI
+#else
+  SPIClass OnBoardSPI(ON_BOARD_SPI_DEVICE)
+  #define ONBOARD_SD_SPI OnBoardSPI
+#endif
+
+#if ON_BOARD_SPI_DEVICE == 1
+  #define SPI_CLOCK_MAX SPI_BAUD_PCLK_DIV_4
+#else
+  #define SPI_CLOCK_MAX SPI_BAUD_PCLK_DIV_2
+#endif
+
+#define CS_LOW()  {WRITE(ONBOARD_SD_CS_PIN, LOW);}  /* Set OnBoardSPI cs low */
+#define CS_HIGH() {WRITE(ONBOARD_SD_CS_PIN, HIGH);} /* Set OnBoardSPI cs high */
+
+#define FCLK_FAST() ONBOARD_SD_SPI.setClockDivider(SPI_CLOCK_MAX)
+#define FCLK_SLOW() ONBOARD_SD_SPI.setClockDivider(SPI_BAUD_PCLK_DIV_256)
+
+/*--------------------------------------------------------------------------
+   Module Private Functions
+---------------------------------------------------------------------------*/
+
+#include "onboard_sd.h"
+
+/* MMC/SD command */
+#define CMD0  (0)     /* GO_IDLE_STATE */
+#define CMD1  (1)     /* SEND_OP_COND (MMC) */
+#define ACMD41  (0x80+41) /* SEND_OP_COND (SDC) */
+#define CMD8  (8)     /* SEND_IF_COND */
+#define CMD9  (9)     /* SEND_CSD */
+#define CMD10 (10)    /* SEND_CID */
+#define CMD12 (12)    /* STOP_TRANSMISSION */
+#define ACMD13  (0x80+13) /* SD_STATUS (SDC) */
+#define CMD16 (16)    /* SET_BLOCKLEN */
+#define CMD17 (17)    /* READ_SINGLE_BLOCK */
+#define CMD18 (18)    /* READ_MULTIPLE_BLOCK */
+#define CMD23 (23)    /* SET_BLOCK_COUNT (MMC) */
+#define ACMD23  (0x80+23) /* SET_WR_BLK_ERASE_COUNT (SDC) */
+#define CMD24 (24)    /* WRITE_BLOCK */
+#define CMD25 (25)    /* WRITE_MULTIPLE_BLOCK */
+#define CMD32 (32)    /* ERASE_ER_BLK_START */
+#define CMD33 (33)    /* ERASE_ER_BLK_END */
+#define CMD38 (38)    /* ERASE */
+#define CMD48 (48)    /* READ_EXTR_SINGLE */
+#define CMD49 (49)    /* WRITE_EXTR_SINGLE */
+#define CMD55 (55)    /* APP_CMD */
+#define CMD58 (58)    /* READ_OCR */
+
+static volatile DSTATUS Stat = STA_NOINIT;  /* Physical drive status */
+static volatile UINT timeout;
+static BYTE CardType;      /* Card type flags */
+
+/*-----------------------------------------------------------------------*/
+/* Send/Receive data to the MMC  (Platform dependent)                    */
+/*-----------------------------------------------------------------------*/
+
+/* Exchange a byte */
+static BYTE xchg_spi (
+  BYTE dat  /* Data to send */
+) {
+  BYTE returnByte = ONBOARD_SD_SPI.transfer(dat);
+  return returnByte;
+}
+
+/* Receive multiple byte */
+static void rcvr_spi_multi (
+  BYTE *buff,   /* Pointer to data buffer */
+  UINT btr    /* Number of bytes to receive (16, 64 or 512) */
+) {
+  ONBOARD_SD_SPI.dmaTransfer(0, const_cast<uint8_t*>(buff), btr);
+}
+
+#if _DISKIO_WRITE
+
+  /* Send multiple bytes */
+  static void xmit_spi_multi (
+    const BYTE *buff, /* Pointer to the data */
+    UINT btx      /* Number of bytes to send (multiple of 16) */
+  ) {
+    ONBOARD_SD_SPI.dmaSend(const_cast<uint8_t*>(buff), btx);
+  }
+
+#endif // _DISKIO_WRITE
+
+/*-----------------------------------------------------------------------*/
+/* Wait for card ready                                                   */
+/*-----------------------------------------------------------------------*/
+
+static int wait_ready (  /* 1:Ready, 0:Timeout */
+  UINT wt     /* Timeout [ms] */
+) {
+  BYTE d;
+
+  timeout = millis() + wt;
+  do {
+    d = xchg_spi(0xFF);
+    /* This loop takes a while. Insert rot_rdq() here for multitask environment. */
+  } while (d != 0xFF && (timeout > millis()));  /* Wait for card goes ready or timeout */
+
+  return (d == 0xFF) ? 1 : 0;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Deselect card and release SPI                                         */
+/*-----------------------------------------------------------------------*/
+
+static void deselect(void) {
+  CS_HIGH();    /* CS = H */
+  xchg_spi(0xFF); /* Dummy clock (force DO hi-z for multiple slave SPI) */
+}
+
+/*-----------------------------------------------------------------------*/
+/* Select card and wait for ready                                        */
+/*-----------------------------------------------------------------------*/
+
+static int select(void) { /* 1:OK, 0:Timeout */
+  CS_LOW();   /* CS = L */
+  xchg_spi(0xFF); /* Dummy clock (force DO enabled) */
+
+  if (wait_ready(500)) return 1;  /* Leading busy check: Wait for card ready */
+
+  deselect();   /* Timeout */
+  return 0;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Control SPI module (Platform dependent)                               */
+/*-----------------------------------------------------------------------*/
+
+static void power_on(void) {  /* Enable SSP module and attach it to I/O pads */
+  ONBOARD_SD_SPI.setModule(ON_BOARD_SPI_DEVICE);
+  ONBOARD_SD_SPI.begin();
+  ONBOARD_SD_SPI.setBitOrder(MSBFIRST);
+  ONBOARD_SD_SPI.setDataMode(SPI_MODE0);
+  OUT_WRITE(ONBOARD_SD_CS_PIN, HIGH); /* Set CS# high */
+}
+
+static void power_off(void) {   /* Disable SPI function */
+  select();       /* Wait for card ready */
+  deselect();
+}
+
+/*-----------------------------------------------------------------------*/
+/* Receive a data packet from the MMC                                    */
+/*-----------------------------------------------------------------------*/
+
+static int rcvr_datablock (  /* 1:OK, 0:Error */
+  BYTE *buff,     /* Data buffer */
+  UINT btr      /* Data block length (byte) */
+) {
+  BYTE token;
+
+  timeout = millis() + 200;
+  do {              /* Wait for DataStart token in timeout of 200ms */
+    token = xchg_spi(0xFF);
+    /* This loop will take a while. Insert rot_rdq() here for multitask environment. */
+  } while ((token == 0xFF) && (timeout > millis()));
+  if (token != 0xFE) return 0;   /* Function fails if invalid DataStart token or timeout */
+
+  rcvr_spi_multi(buff, btr);    /* Store trailing data to the buffer */
+  xchg_spi(0xFF); xchg_spi(0xFF); /* Discard CRC */
+
+  return 1;           /* Function succeeded */
+}
+
+/*-----------------------------------------------------------------------*/
+/* Send a data packet to the MMC                                         */
+/*-----------------------------------------------------------------------*/
+
+#if _DISKIO_WRITE
+
+  static int xmit_datablock (  /* 1:OK, 0:Failed */
+    const BYTE *buff, /* Ponter to 512 byte data to be sent */
+    BYTE token      /* Token */
+  ) {
+    BYTE resp;
+
+    if (!wait_ready(500)) return 0;   /* Leading busy check: Wait for card ready to accept data block */
+
+    xchg_spi(token);          /* Send token */
+    if (token == 0xFD) return 1;    /* Do not send data if token is StopTran */
+
+    xmit_spi_multi(buff, 512);      /* Data */
+    xchg_spi(0xFF); xchg_spi(0xFF);   /* Dummy CRC */
+
+    resp = xchg_spi(0xFF);        /* Receive data resp */
+
+    return (resp & 0x1F) == 0x05 ? 1 : 0; /* Data was accepted or not */
+
+    /* Busy check is done at next transmission */
+  }
+
+#endif // _DISKIO_WRITE
+
+/*-----------------------------------------------------------------------*/
+/* Send a command packet to the MMC                                      */
+/*-----------------------------------------------------------------------*/
+
+static BYTE send_cmd (   /* Return value: R1 resp (bit7==1:Failed to send) */
+  BYTE cmd,   /* Command index */
+  DWORD arg   /* Argument */
+) {
+  BYTE n, res;
+
+  if (cmd & 0x80) { /* Send a CMD55 prior to ACMD<n> */
+    cmd &= 0x7F;
+    res = send_cmd(CMD55, 0);
+    if (res > 1) return res;
+  }
+
+  /* Select the card and wait for ready except to stop multiple block read */
+  if (cmd != CMD12) {
+    deselect();
+    if (!select()) return 0xFF;
+  }
+
+  /* Send command packet */
+  xchg_spi(0x40 | cmd);       /* Start + command index */
+  xchg_spi((BYTE)(arg >> 24));    /* Argument[31..24] */
+  xchg_spi((BYTE)(arg >> 16));    /* Argument[23..16] */
+  xchg_spi((BYTE)(arg >> 8));     /* Argument[15..8] */
+  xchg_spi((BYTE)arg);        /* Argument[7..0] */
+  n = 0x01;             /* Dummy CRC + Stop */
+  if (cmd == CMD0) n = 0x95;      /* Valid CRC for CMD0(0) */
+  if (cmd == CMD8) n = 0x87;      /* Valid CRC for CMD8(0x1AA) */
+  xchg_spi(n);
+
+  /* Receive command resp */
+  if (cmd == CMD12) xchg_spi(0xFF); /* Diacard following one byte when CMD12 */
+  n = 10;               /* Wait for response (10 bytes max) */
+  do
+    res = xchg_spi(0xFF);
+  while ((res & 0x80) && --n);
+
+  return res;             /* Return received response */
+}
+
+/*--------------------------------------------------------------------------
+   Public Functions
+---------------------------------------------------------------------------*/
+
+/*-----------------------------------------------------------------------*/
+/* Initialize disk drive                                                 */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+  BYTE drv    /* Physical drive number (0) */
+) {
+  BYTE n, cmd, ty, ocr[4];
+
+  if (drv) return STA_NOINIT;     /* Supports only drive 0 */
+  power_on();             /* Initialize SPI */
+
+  if (Stat & STA_NODISK) return Stat; /* Is a card existing in the soket? */
+
+  FCLK_SLOW();
+  for (n = 10; n; n--) xchg_spi(0xFF);  /* Send 80 dummy clocks */
+
+  ty = 0;
+  if (send_cmd(CMD0, 0) == 1) {     /* Put the card SPI state */
+    timeout = millis() + 1000;            /* Initialization timeout = 1 sec */
+    if (send_cmd(CMD8, 0x1AA) == 1) { /* Is the catd SDv2? */
+      for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);  /* Get 32 bit return value of R7 resp */
+      if (ocr[2] == 0x01 && ocr[3] == 0xAA) {       /* Does the card support 2.7-3.6V? */
+        while ((timeout > millis()) && send_cmd(ACMD41, 1UL << 30)) ; /* Wait for end of initialization with ACMD41(HCS) */
+        if ((timeout > millis()) && send_cmd(CMD58, 0) == 0) {    /* Check CCS bit in the OCR */
+          for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);
+          ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;  /* Check if the card is SDv2 */
+        }
+      }
+    } else {  /* Not an SDv2 card */
+      if (send_cmd(ACMD41, 0) <= 1)   { /* SDv1 or MMCv3? */
+        ty = CT_SD1; cmd = ACMD41;  /* SDv1 (ACMD41(0)) */
+      } else {
+        ty = CT_MMC; cmd = CMD1;  /* MMCv3 (CMD1(0)) */
+      }
+      while ((timeout > millis()) && send_cmd(cmd, 0)) ;    /* Wait for the card leaves idle state */
+      if (!(timeout > millis()) || send_cmd(CMD16, 512) != 0) /* Set block length: 512 */
+        ty = 0;
+    }
+  }
+  CardType = ty;  /* Card type */
+  deselect();
+
+  if (ty) {   /* OK */
+    FCLK_FAST();      /* Set fast clock */
+    Stat &= ~STA_NOINIT;  /* Clear STA_NOINIT flag */
+  } else {    /* Failed */
+    power_off();
+    Stat = STA_NOINIT;
+  }
+
+  return Stat;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Get disk status                                                       */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+  BYTE drv    /* Physical drive number (0) */
+) {
+  if (drv) return STA_NOINIT;   /* Supports only drive 0 */
+  return Stat;  /* Return disk status */
+}
+
+/*-----------------------------------------------------------------------*/
+/* Read sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read (
+  BYTE drv,   /* Physical drive number (0) */
+  BYTE *buff,   /* Pointer to the data buffer to store read data */
+  DWORD sector, /* Start sector number (LBA) */
+  UINT count    /* Number of sectors to read (1..128) */
+) {
+  BYTE cmd;
+
+  if (drv || !count) return RES_PARERR;   /* Check parameter */
+  if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check if drive is ready */
+  if (!(CardType & CT_BLOCK)) sector *= 512;  /* LBA ot BA conversion (byte addressing cards) */
+  FCLK_FAST();
+  cmd = count > 1 ? CMD18 : CMD17;      /*  READ_MULTIPLE_BLOCK : READ_SINGLE_BLOCK */
+  if (send_cmd(cmd, sector) == 0) {
+    do {
+      if (!rcvr_datablock(buff, 512)) break;
+      buff += 512;
+    } while (--count);
+    if (cmd == CMD18) send_cmd(CMD12, 0); /* STOP_TRANSMISSION */
+  }
+  deselect();
+
+  return count ? RES_ERROR : RES_OK;  /* Return result */
+}
+
+/*-----------------------------------------------------------------------*/
+/* Write sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+#if _DISKIO_WRITE
+
+  DRESULT disk_write(
+    BYTE drv,     /* Physical drive number (0) */
+    const BYTE *buff, /* Ponter to the data to write */
+    DWORD sector,   /* Start sector number (LBA) */
+    UINT count      /* Number of sectors to write (1..128) */
+  ) {
+    if (drv || !count) return RES_PARERR;   /* Check parameter */
+    if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check drive status */
+    if (Stat & STA_PROTECT) return RES_WRPRT; /* Check write protect */
+    FCLK_FAST();
+    if (!(CardType & CT_BLOCK)) sector *= 512;  /* LBA ==> BA conversion (byte addressing cards) */
+
+    if (count == 1) { /* Single sector write */
+      if ((send_cmd(CMD24, sector) == 0)  /* WRITE_BLOCK */
+        && xmit_datablock(buff, 0xFE)) {
+        count = 0;
+      }
+    }
+    else {        /* Multiple sector write */
+      if (CardType & CT_SDC) send_cmd(ACMD23, count); /* Predefine number of sectors */
+      if (send_cmd(CMD25, sector) == 0) { /* WRITE_MULTIPLE_BLOCK */
+        do {
+          if (!xmit_datablock(buff, 0xFC)) break;
+          buff += 512;
+        } while (--count);
+        if (!xmit_datablock(0, 0xFD)) count = 1;  /* STOP_TRAN token */
+      }
+    }
+    deselect();
+
+    return count ? RES_ERROR : RES_OK;  /* Return result */
+  }
+
+#endif // _DISKIO_WRITE
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous drive controls other than data read/write               */
+/*-----------------------------------------------------------------------*/
+
+#if _DISKIO_IOCTL
+
+  DRESULT disk_ioctl (
+    BYTE drv,   /* Physical drive number (0) */
+    BYTE cmd,   /* Control command code */
+    void *buff    /* Pointer to the conrtol data */
+  ) {
+    DRESULT res;
+    BYTE n, csd[16], *ptr = (BYTE *)buff;
+    DWORD *dp, st, ed, csize;
+    #if _DISKIO_ISDIO
+      SDIO_CMD *sdio = buff;
+      BYTE rc, *buf;
+      UINT dc;
+    #endif
+
+    if (drv) return RES_PARERR;         /* Check parameter */
+    if (Stat & STA_NOINIT) return RES_NOTRDY; /* Check if drive is ready */
+
+    res = RES_ERROR;
+    FCLK_FAST();
+    switch (cmd) {
+      case CTRL_SYNC:     /* Wait for end of internal write process of the drive */
+        if (select()) res = RES_OK;
+        break;
+
+      case GET_SECTOR_COUNT:  /* Get drive capacity in unit of sector (DWORD) */
+        if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {
+          if ((csd[0] >> 6) == 1) { /* SDC ver 2.00 */
+            csize = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1;
+            *(DWORD*)buff = csize << 10;
+          } else {          /* SDC ver 1.XX or MMC ver 3 */
+            n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
+            csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
+            *(DWORD*)buff = csize << (n - 9);
+          }
+          res = RES_OK;
+        }
+        break;
+
+      case GET_BLOCK_SIZE:  /* Get erase block size in unit of sector (DWORD) */
+        if (CardType & CT_SD2) {  /* SDC ver 2.00 */
+          if (send_cmd(ACMD13, 0) == 0) { /* Read SD status */
+            xchg_spi(0xFF);
+            if (rcvr_datablock(csd, 16)) {        /* Read partial block */
+              for (n = 64 - 16; n; n--) xchg_spi(0xFF); /* Purge trailing data */
+              *(DWORD*)buff = 16UL << (csd[10] >> 4);
+              res = RES_OK;
+            }
+          }
+        } else {          /* SDC ver 1.XX or MMC */
+          if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {  /* Read CSD */
+            if (CardType & CT_SD1) {  /* SDC ver 1.XX */
+              *(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
+            } else {          /* MMC */
+              *(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
+            }
+            res = RES_OK;
+          }
+        }
+        break;
+
+      case CTRL_TRIM:   /* Erase a block of sectors (used when _USE_TRIM in ffconf.h is 1) */
+        if (!(CardType & CT_SDC)) break;        /* Check if the card is SDC */
+        if (disk_ioctl(drv, MMC_GET_CSD, csd)) break; /* Get CSD */
+        if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break; /* Check if sector erase can be applied to the card */
+        dp = (DWORD *)buff; st = dp[0]; ed = dp[1];       /* Load sector block */
+        if (!(CardType & CT_BLOCK)) {
+          st *= 512; ed *= 512;
+        }
+        if (send_cmd(CMD32, st) == 0 && send_cmd(CMD33, ed) == 0 && send_cmd(CMD38, 0) == 0 && wait_ready(30000)) { /* Erase sector block */
+          res = RES_OK; /* FatFs does not check result of this command */
+        }
+        break;
+
+      /* Following commands are never used by FatFs module */
+
+      case MMC_GET_TYPE:    /* Get MMC/SDC type (BYTE) */
+        *ptr = CardType;
+        res = RES_OK;
+        break;
+
+      case MMC_GET_CSD:   /* Read CSD (16 bytes) */
+        if (send_cmd(CMD9, 0) == 0 && rcvr_datablock(ptr, 16)) {  /* READ_CSD */
+          res = RES_OK;
+        }
+        break;
+
+      case MMC_GET_CID:   /* Read CID (16 bytes) */
+        if (send_cmd(CMD10, 0) == 0 && rcvr_datablock(ptr, 16)) { /* READ_CID */
+          res = RES_OK;
+        }
+        break;
+
+      case MMC_GET_OCR:   /* Read OCR (4 bytes) */
+        if (send_cmd(CMD58, 0) == 0) {  /* READ_OCR */
+          for (n = 4; n; n--) *ptr++ = xchg_spi(0xFF);
+          res = RES_OK;
+        }
+        break;
+
+      case MMC_GET_SDSTAT:  /* Read SD status (64 bytes) */
+        if (send_cmd(ACMD13, 0) == 0) { /* SD_STATUS */
+          xchg_spi(0xFF);
+          if (rcvr_datablock(ptr, 64)) res = RES_OK;
+        }
+        break;
+
+      #if _DISKIO_ISDIO
+
+        case ISDIO_READ:
+          sdio = buff;
+          if (send_cmd(CMD48, 0x80000000 | sdio->func << 28 | sdio->addr << 9 | ((sdio->ndata - 1) & 0x1FF)) == 0) {
+            for (Timer1 = 1000; (rc = xchg_spi(0xFF)) == 0xFF && Timer1; ) ;
+            if (rc == 0xFE) {
+              for (buf = sdio->data, dc = sdio->ndata; dc; dc--) *buf++ = xchg_spi(0xFF);
+              for (dc = 514 - sdio->ndata; dc; dc--) xchg_spi(0xFF);
+              res = RES_OK;
+            }
+          }
+          break;
+        case ISDIO_WRITE:
+          sdio = buff;
+          if (send_cmd(CMD49, 0x80000000 | sdio->func << 28 | sdio->addr << 9 | ((sdio->ndata - 1) & 0x1FF)) == 0) {
+            xchg_spi(0xFF); xchg_spi(0xFE);
+            for (buf = sdio->data, dc = sdio->ndata; dc; dc--) xchg_spi(*buf++);
+            for (dc = 514 - sdio->ndata; dc; dc--) xchg_spi(0xFF);
+            if ((xchg_spi(0xFF) & 0x1F) == 0x05) res = RES_OK;
+          }
+          break;
+        case ISDIO_MRITE:
+          sdio = buff;
+          if (send_cmd(CMD49, 0x84000000 | sdio->func << 28 | sdio->addr << 9 | sdio->ndata >> 8) == 0) {
+            xchg_spi(0xFF); xchg_spi(0xFE);
+            xchg_spi(sdio->ndata);
+            for (dc = 513; dc; dc--) xchg_spi(0xFF);
+            if ((xchg_spi(0xFF) & 0x1F) == 0x05) res = RES_OK;
+          }
+          break;
+
+      #endif // _DISKIO_ISDIO
+
+      default: res = RES_PARERR;
+    }
+
+    deselect();
+    return res;
+  }
+
+#endif // _DISKIO_IOCTL
+
+#endif // HAS_ONBOARD_SD
--- a/Show More
+++ b/Show More