HardwareSPI/src/include/HSPI/Controller.h

Go to the documentation of this file.

/****
 * Controller.h
 *
 * Copyright 2018 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the HardwareSPI Library
 *
 * This library 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, version 3 or later.
 *
 * 
 * This library 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 library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 * @author: 11 December 2018 - mikee47 <mike@sillyhouse.net>
 *
 ****/

#pragma once

#include <cstdint>
#include <esp_attr.h>
#include "Request.h"
#include <bitset>
#include "Common.h"
#include <ControllerBase.h>

namespace HSPI
{
class Device;

static constexpr uint8_t SPI_PIN_NONE{0xff};
static constexpr uint8_t SPI_PIN_DEFAULT{0xfe};

struct SpiPins {
    uint8_t sck{SPI_PIN_DEFAULT};
    uint8_t miso{SPI_PIN_DEFAULT};
    uint8_t mosi{SPI_PIN_DEFAULT};
};

class Controller : public ControllerBase
{
public:
    using SelectDevice = void (*)(uint8_t chipSelect, bool active);

    Controller(SpiBus id = SpiBus::DEFAULT) : ControllerBase(), busId(id)
    {
    }

    Controller(SpiBus id, SpiPins pins) : ControllerBase(), busId(id), mPins(pins)
    {
    }

    virtual ~Controller()
    {
        end();
    }

    /* @brief Initialize the HSPI controller
     */
    bool begin();

    void end();

    IoModes getSupportedIoModes(const Device& dev) const;

    void onSelectDevice(SelectDevice callback)
    {
        selectDeviceCallback = callback;
    }

    virtual bool startDevice(Device& dev, PinSet pinSet, uint8_t chipSelect, uint32_t clockSpeed);

    virtual void stopDevice(Device& dev);

    void configChanged(Device& dev);

    SpiBus getBusId() const
    {
        return busId;
    }

#ifdef HSPI_ENABLE_STATS
    struct Stats {
        uint32_t requestCount;   
        uint32_t transCount;     
        uint32_t waitCycles;     
        uint32_t tasksQueued;   
        uint32_t tasksCancelled; 

        void clear() volatile
        {
            requestCount = 0;
            transCount = 0;
            waitCycles = 0;
            tasksQueued = 0;
            tasksCancelled = 0;
        }
    };
    static volatile Stats stats;
#endif

    PinSet IRAM_ATTR getActivePinSet() const
    {
        return activePinSet;
    }

    void wait(Request& request);

    bool loopback(bool enable);

    const SpiPins& pins{mPins};

protected:
    friend Device;

    virtual void execute(Request& request);

    void assignDefaultPins(const SpiPins& defPins)
    {
        if(pins.sck == SPI_PIN_DEFAULT) {
            mPins.sck = defPins.sck;
        }
        if(pins.miso == SPI_PIN_DEFAULT) {
            mPins.miso = defPins.miso;
        }
        if(pins.mosi == SPI_PIN_DEFAULT) {
            mPins.mosi = defPins.mosi;
        }
    }

private:
#if defined(ARCH_ESP32)
    static void IRAM_ATTR pre_transfer_callback(spi_transaction_t* t);
    static void IRAM_ATTR post_transfer_callback(spi_transaction_t* t);
#elif defined(ARCH_ESP8266) || defined(ARCH_HOST)
    static void isr(Controller* spi);
#elif defined(ARCH_RP2040)
    void configure_dma(volatile void* fifo_addr, uint8_t dreq_tx, uint8_t dreq_rx);
    void release_dma();
    void interruptHandler();
    static void staticInterruptHandler();
#endif

    static void updateConfig(Device& dev);

    void queueTask();
    void executeTask();
    void startRequest();
    void nextTransaction();
    void transactionDone();

    SpiBus busId;
    SpiPins mPins;
    PinSet activePinSet{PinSet::none};
    SelectDevice selectDeviceCallback{nullptr}; 

    // State of the current transaction in progress
    struct Transaction {
        Request* request; 
#ifdef ARCH_RP2040
        // RP2040 doesn't have a restriction on transaction size, so doesn't need to split requests
#else
        uint32_t addr;      
        uint16_t outOffset; 
        uint16_t inOffset;  
        uint8_t inlen;      
        IoMode ioMode;
#endif
        // Flags
        uint8_t bitOrder : 1;
        volatile uint8_t busy : 1;
#ifdef ARCH_ESP8266
        uint8_t addrShift;  
        uint32_t addrCmdMask; 
#endif
    };
    Transaction trans{};
};

} // namespace HSPI