HAL SPI pin init cleanup

Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp

  */
 
 /**
- * Originally from Arduino Sd2Card Library
+ * Adapted from Arduino Sd2Card Library
  * Copyright (C) 2009 by William Greiman
  */
 
 /**
- * Description: HAL for AVR - SPI functions
+ * HAL for AVR - SPI functions
  */
 
 #ifdef __AVR__
 
 #include "../../inc/MarlinConfig.h"
 
-// --------------------------------------------------------------------------
-// Public Variables
-// --------------------------------------------------------------------------
-
-
-// --------------------------------------------------------------------------
-// Public functions
-// --------------------------------------------------------------------------
-
-void spiBegin (void) {
-  SET_OUTPUT(SS_PIN);
-  WRITE(SS_PIN, HIGH);
+void spiBegin(void) {
+  OUT_WRITE(SS_PIN, HIGH);
   SET_OUTPUT(SCK_PIN);
   SET_INPUT(MISO_PIN);
   SET_OUTPUT(MOSI_PIN);
 
   #if DISABLED(SOFTWARE_SPI)
     // SS must be in output mode even it is not chip select
-    SET_OUTPUT(SS_PIN);
+    //SET_OUTPUT(SS_PIN);
     // set SS high - may be chip select for another SPI device
-    #if SET_SPI_SS_HIGH
-      WRITE(SS_PIN, HIGH);
-    #endif  // SET_SPI_SS_HIGH
+    //#if SET_SPI_SS_HIGH
+      //WRITE(SS_PIN, HIGH);
+    //#endif
     // set a default rate
     spiInit(1);
-  #endif  // SOFTWARE_SPI
+  #endif
 }
 
-
 #if DISABLED(SOFTWARE_SPI, FORCE_SOFT_SPI)
 
   //------------------------------------------------------------------------------
   }
 
 
-#else
+#else // SOFTWARE_SPI || FORCE_SOFT_SPI
+
+  //------------------------------------------------------------------------------
+  // Software SPI
+  //------------------------------------------------------------------------------
 
-  /** nop to tune soft SPI timing */
+  // nop to tune soft SPI timing
   #define nop asm volatile ("\tnop\n")
 
-  /** Set SPI rate */
+  // Set SPI rate
   void spiInit(uint8_t spiRate) {
     UNUSED(spiRate);  // nothing to do
   }
 
-  /** Begin SPI transaction, set clock, bit order, data mode */
+  // Begin SPI transaction, set clock, bit order, data mode
   void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
     UNUSED(spiBeginTransaction);  // nothing to do
   }
 
-  /** Soft SPI receive byte */
+  // Soft SPI receive byte
   uint8_t spiRec() {
     uint8_t data = 0;
     // no interrupts during byte receive - about 8µs
     return data;
   }
 
-  /** Soft SPI read data */
+  // Soft SPI read data
   void spiRead(uint8_t* buf, uint16_t nbyte) {
     for (uint16_t i = 0; i < nbyte; i++)
       buf[i] = spiRec();
   }
 
-  /** Soft SPI send byte */
+  // Soft SPI send byte
   void spiSend(uint8_t data) {
     // no interrupts during byte send - about 8µs
     cli();
     sei();
   }
 
-  /** Soft SPI send block */
+  // Soft SPI send block
   void spiSendBlock(uint8_t token, const uint8_t* buf) {
     spiSend(token);
     for (uint16_t i = 0; i < 512; i++)
       spiSend(buf[i]);
   }
 
-#endif // SOFTWARE_SPI, FORCE_SOFT_SPI
+#endif // SOFTWARE_SPI || FORCE_SOFT_SPI
 
 #endif // __AVR__

Marlin/src/HAL/HAL_TEENSY31_32/HAL_spi_Teensy.cpp

   #if !PIN_EXISTS(SS)
     #error "SS_PIN not defined!"
   #endif
-  SET_OUTPUT(SS_PIN);
-  WRITE(SS_PIN, HIGH);
+  OUT_WRITE(SS_PIN, HIGH);
   SET_OUTPUT(SCK_PIN);
   SET_INPUT(MISO_PIN);
   SET_OUTPUT(MOSI_PIN);
 
-  //#if DISABLED(SOFTWARE_SPI)
-  #if 0
+  #if 0 && DISABLED(SOFTWARE_SPI)
     // set SS high - may be chip select for another SPI device
     #if SET_SPI_SS_HIGH
       WRITE(SS_PIN, HIGH);

Marlin/src/HAL/HAL_TEENSY35_36/HAL_Servo_Teensy.h

 
 #include <Servo.h>
 
-// Inherit and expand on the official library
+// Inherit and expand on core Servo library
 class libServo : public Servo {
   public:
     int8_t attach(const int pin);
   private:
      uint16_t min_ticks;
      uint16_t max_ticks;
-     uint8_t servoIndex;               // index into the channel data for this servo
+     uint8_t servoIndex; // Index into the channel data for this servo
 };

Marlin/src/HAL/HAL_TEENSY35_36/HAL_spi_Teensy.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2019 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/>.
+ *
+ */
 #if defined(__MK64FX512__) || defined(__MK66FX1M0__)
 
 #include "HAL.h"
 
 static SPISettings spiConfig;
 
-// Standard SPI functions
-/** Initialize SPI bus */
 void spiBegin(void) {
   #if !PIN_EXISTS(SS)
     #error SS_PIN not defined!
   #endif
-  SET_OUTPUT(SS_PIN);
-  WRITE(SS_PIN, HIGH);
+  OUT_WRITE(SS_PIN, HIGH);
   SET_OUTPUT(SCK_PIN);
   SET_INPUT(MISO_PIN);
   SET_OUTPUT(MOSI_PIN);
 
-  //#if DISABLED(SOFTWARE_SPI)
-  #if 0
+  #if 0 && DISABLED(SOFTWARE_SPI)
     // set SS high - may be chip select for another SPI device
     #if SET_SPI_SS_HIGH
       WRITE(SS_PIN, HIGH);
-    #endif  // SET_SPI_SS_HIGH
+    #endif
     // set a default rate
     spiInit(SPI_HALF_SPEED); // 1
-  #endif  // SOFTWARE_SPI
+  #endif
 }
 
-/** Configure SPI for specified SPI speed */
 void spiInit(uint8_t spiRate) {
-  // Use datarates Marlin uses
+  // Use Marlin data-rates
   uint32_t clock;
   switch (spiRate) {
   case SPI_FULL_SPEED:    clock = 10000000; break;
   SPI.begin();
 }
 
-//------------------------------------------------------------------------------
-/** SPI receive a byte */
 uint8_t spiRec(void) {
   SPI.beginTransaction(spiConfig);
   uint8_t returnByte = SPI.transfer(0xFF);
   SPI.endTransaction();
   return returnByte;
-//  SPDR = 0xFF;
-//  while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-//  return SPDR;
+  //SPDR = 0xFF;
+  //while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  //return SPDR;
 }
-//------------------------------------------------------------------------------
-/** SPI read data  */
+
 void spiRead(uint8_t* buf, uint16_t nbyte) {
   SPI.beginTransaction(spiConfig);
   SPI.transfer(buf, nbyte);
   SPI.endTransaction();
-//if (nbyte-- == 0) return;
-//  SPDR = 0xFF;
-//for (uint16_t i = 0; i < nbyte; i++) {
-//  while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-//  buf[i] = SPDR;
-//  SPDR = 0xFF;
-//}
-//while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-//buf[nbyte] = SPDR;
+  //if (nbyte-- == 0) return;
+  //  SPDR = 0xFF;
+  //for (uint16_t i = 0; i < nbyte; i++) {
+  //  while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  //  buf[i] = SPDR;
+  //  SPDR = 0xFF;
+  //}
+  //while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  //buf[nbyte] = SPDR;
 }
-//------------------------------------------------------------------------------
-/** SPI send a byte */
+
 void spiSend(uint8_t b) {
   SPI.beginTransaction(spiConfig);
   SPI.transfer(b);
   SPI.endTransaction();
-//  SPDR = b;
-//  while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  //SPDR = b;
+  //while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
 }
-//------------------------------------------------------------------------------
-/** SPI send block  */
+
 void spiSendBlock(uint8_t token, const uint8_t* buf) {
   SPI.beginTransaction(spiConfig);
   SPDR = token;
   SPI.endTransaction();
 }
 
-
-/** Begin SPI transaction, set clock, bit order, data mode */
+// Begin SPI transaction, set clock, bit order, data mode
 void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
   spiConfig = SPISettings(spiClock, bitOrder, dataMode);
-
   SPI.beginTransaction(spiConfig);
 }
 

Marlin/src/HAL/HAL_TEENSY35_36/HAL_timers_Teensy.cpp

  *
  */
 
-
 /**
  * Teensy3.5 __MK64FX512__
  * Teensy3.6 __MK66FX1M0__

Marlin/src/HAL/shared/SpiEeprom.cpp

   delay(7);   // wait for page write to complete
 }
 
-
-#endif // ENABLED(SPI_EEPROM)
+#endif // SPI_EEPROM