spidev.h

/* Copyright © 2018-2025 Pascal JEAN, All rights reserved.
 * This file is part of the Piduino Library.
 *
 * The Piduino Library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * The Piduino 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the Piduino Library; if not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <deque>
#include <map>
#include <string>
#include <piduino/iodevice.h>
#include <piduino/gpiopin.h>
#include <piduino/system.h>
#include <linux/spi/spidev.h>
 
namespace Piduino {
 
  class SpiDev : public IoDevice {
    public:
 
      class Cs {
        public:
          friend class SpiDev;
 
          Cs() : _id (-1), _pin (0), _mode (Pin::ModeUnknown),
            _driverControl (true), _activeLevel (false) {}
 
          inline int id() const {
            return _id;
          }
 
          inline Pin * pin() const {
            return _pin;
          }
 
          inline Pin::Mode mode() const {
            return _mode;
          }
 
          inline bool driverControl() const {
            return _driverControl;
          }
 
          inline bool activeLevel() const {
            return _activeLevel;
          }
 
          bool setDriverControl (bool enable = false, bool activeLevel = false);
          bool get() const;
          void set (bool value);
 
        protected:
          inline void setId (int value) {
            _id = value;
          }
          inline void setPin (Pin * value) {
            _pin = value;
          }
          inline void setMode (Pin::Mode value) {
            _mode = value;
          }
 
        private:
          int _id;
          Pin * _pin;
          Pin::Mode _mode;
          bool _driverControl;
          bool _activeLevel;
      };
 
      class Info {
        public:
          static const int MaxBuses = 32;
          static const int MaxCs = 32;
 
          Info (int bus = 0, int cs = 0) {
            setId (bus, cs);
          }
 
          void setId (int bus, int cs = 0);
          bool setPath (const std::string & path);
 
          inline int busId() const {
            return _bus;
          }
 
          inline int csId() const {
            return _cs;
          }
 
          inline const std::string & path() const {
            return _path;
          }
 
          inline const std::map<int, Cs> & csList() const {
            return _csList;
          }
 
          inline const Cs & cs() const   {
            return _csList.at (_cs);
          }
          
          inline bool exists() const {
            return System::charFileExists(_path);
          }
 
          bool operator== (const Info & other) {
            return (_path == other._path) ;
          }
 
          bool operator!= (const Info & other) {
            return (_path != other._path) ;
          }
 
          static std::deque<SpiDev::Info> availableBuses ();
 
          static Info defaultBus ();
 
          static std::string busPath (int bus, int cs = 0);
 
        private:
          int _bus; 
          int _cs; 
          std::string _path; 
          std::map<int, Cs> _csList; 
      };
 
      class Settings {
        public:
          enum {
            MsbFirst = true, 
            LsbFirst = false 
          };
 
          Settings (uint32_t clock = 10000000, bool bitOrder = MsbFirst, uint8_t dataMode = SPI_MODE_0, uint8_t dataBits = 8) :
            mode (dataMode), bitOrder (bitOrder), bitsPerWord (dataBits), speedHz (clock) {}
 
          bool operator== (const Settings & other) {
            return (mode == other.mode) && (bitOrder == other.bitOrder) &&
                   (bitsPerWord == other.bitsPerWord) && (speedHz == other.speedHz);
          }
 
          bool operator!= (const Settings & other) {
            return ! (*this == other);
          }
 
          /*
            SPI_CPHA    0x01
            SPI_CPOL    0x02
 
            SPI_MODE_0    (0|0)
            SPI_MODE_1    (0|SPI_CPHA)
            SPI_MODE_2    (SPI_CPOL|0)
            SPI_MODE_3    (SPI_CPOL|SPI_CPHA)
 
            SPI_CS_HIGH   0x04
            SPI_LSB_FIRST   0x08
            SPI_3WIRE   0x10
            SPI_LOOP    0x20
            SPI_NO_CS   0x40
            SPI_READY   0x80
          */
          uint8_t mode;
          bool bitOrder;
          uint8_t bitsPerWord;
          uint32_t speedHz;
      };
 
      class Transfer {
        public:
          const uint8_t * txBuf;
          uint8_t * rxBuf;
          uint32_t len;
          uint32_t speedHz;
          uint8_t bitsPerWord;
          bool releaseCsAfter;
          uint16_t delayBeforeReleaseCs;
          Transfer (const uint8_t * txbuf = 0, uint8_t * rxbuf = 0, uint32_t count = 0) :
            txBuf (txbuf), rxBuf (rxbuf), len (count), speedHz (0),
            bitsPerWord (0), releaseCsAfter (false), delayBeforeReleaseCs (0) {}
          bool operator== (const Transfer & other) {
            return (txBuf == other.txBuf) && (rxBuf == other.rxBuf) &&
                   (len == other.len) && (speedHz == other.speedHz) &&
                   (delayBeforeReleaseCs == other.delayBeforeReleaseCs) &&
                   (bitsPerWord == other.bitsPerWord) &&
                   (releaseCsAfter == other.releaseCsAfter);
          }
      };
 
      SpiDev ();
 
      SpiDev (const Info & bus);
 
      explicit SpiDev (int idBus, int idCs = 0);
 
      explicit SpiDev (const std::string & path);
 
      explicit SpiDev (const char * path);
 
      virtual ~SpiDev();
 
      virtual bool open (OpenMode mode = IoDevice::ReadWrite);
 
      virtual void close();
 
      void setBus (int idBus, int idCs = 0);
 
      void setBus (const Info & bus);
 
      void setBusPath (const std::string & path);
 
      void setBusPath (const char * path);
 
      const Info & bus() const;
 
      int transfer (const uint8_t * txbuf, uint8_t * rxbuf, uint32_t len);
 
      int read (uint8_t * buffer, uint32_t len);
 
      int write (const uint8_t *buffer, uint32_t len);
 
      void pushTransfer (Transfer & t);
 
      int transfer ();
 
      void clear();
 
      void setSettings (const Settings & settings);
 
      void setMode (uint8_t mode);
 
      void setSpeedHz (uint32_t speedHz);
 
      void setBitsPerWord (uint8_t bit);
 
      void setBitOrder (bool bitOrder);
 
      const Settings & settings() const;
 
      uint8_t mode() const;
 
      uint32_t speedHz () const;
 
      uint8_t bitsPerWord () const;
 
      bool bitOrder() const;
 
    protected:
      class Private;
      SpiDev (Private &dd);
 
    private:
      PIMP_DECLARE_PRIVATE (SpiDev)
  };
  // ---------------------------------------------------------------------------
  //
  //                      Piduino SpiDev Global Object
  //
  // ---------------------------------------------------------------------------
  extern SpiDev SPI; 
}
/* ========================================================================== */