src/adafruit_blinka/microcontroller/am65xx/spi.py

   1 # SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
   2 #
   3 # SPDX-License-Identifier: MIT
   4 """am65xx SPI class using PureIO's SPI class"""
   5
   6 from Adafruit_PureIO import spi
   7
   8 # import Adafruit_PureIO.spi as spi
   9 from adafruit_blinka.agnostic import detector
  10
  11
  12 class SPI:
  13     """SPI Class"""
  14
  15     MSB = 0
  16     LSB = 1
  17     CPHA = 1
  18     CPOL = 2
  19
  20     baudrate = 100000
  21     mode = 0
  22     bits = 8
  23
  24     def __init__(self, portid):
  25         if isinstance(portid, tuple):
  26             self._spi = spi.SPI(device=portid)
  27         else:
  28             self._spi = spi.SPI(device=(portid, 0))
  29         self.clock_pin = None
  30         self.mosi_pin = None
  31         self.miso_pin = None
  32         self.chip = None
  33
  34     # pylint: disable=too-many-arguments,unused-argument
  35     def init(
  36         self,
  37         baudrate=100000,
  38         polarity=0,
  39         phase=0,
  40         bits=8,
  41         firstbit=MSB,
  42         sck=None,
  43         mosi=None,
  44         miso=None,
  45     ):
  46         """Initialize SPI"""
  47         mode = 0
  48         if polarity:
  49             mode |= self.CPOL
  50         if phase:
  51             mode |= self.CPHA
  52         self.baudrate = baudrate
  53         self.mode = mode
  54         self.bits = bits
  55         self.chip = detector.chip
  56
  57         # Pins are not used
  58         self.clock_pin = sck
  59         self.mosi_pin = mosi
  60         self.miso_pin = miso
  61
  62     # pylint: enable=too-many-arguments,unused-argument
  63
  64     # pylint: disable=unnecessary-pass
  65     def set_no_cs(self):
  66         """Setting so that SPI doesn't automatically set the CS pin"""
  67         # No kernel seems to support this, so we're just going to pass
  68         pass
  69
  70     # pylint: enable=unnecessary-pass
  71
  72     @property
  73     def frequency(self):
  74         """Return the current baudrate"""
  75         return self.baudrate
  76
  77     def write(self, buf, start=0, end=None):
  78         """Write data from the buffer to SPI"""
  79         if not buf:
  80             return
  81         if end is None:
  82             end = len(buf)
  83         try:
  84             # self._spi.open(self._port, 0)
  85             self.set_no_cs()
  86             self._spi.max_speed_hz = self.baudrate
  87             self._spi.mode = self.mode
  88             self._spi.bits_per_word = self.bits
  89             self._spi.writebytes(buf[start:end])
  90             # self._spi.close()
  91         except FileNotFoundError:
  92             print("Could not open SPI device - check if SPI is enabled in kernel!")
  93             raise
  94
  95     def readinto(self, buf, start=0, end=None, write_value=0):
  96         """Read data from SPI and into the buffer"""
  97         if not buf:
  98             return
  99         if end is None:
 100             end = len(buf)
 101         try:
 102             # self._spi.open(self._port, 0)
 103             # self.set_no_cs()
 104             self._spi.max_speed_hz = self.baudrate
 105             self._spi.mode = self.mode
 106             self._spi.bits_per_word = self.bits
 107             data = self._spi.transfer([write_value] * (end - start))
 108             for i in range(end - start):  # 'readinto' the given buffer
 109                 buf[start + i] = data[i]
 110             # self._spi.close()
 111         except FileNotFoundError:
 112             print("Could not open SPI device - check if SPI is enabled in kernel!")
 113             raise
 114
 115     # pylint: disable=too-many-arguments
 116     def write_readinto(
 117         self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
 118     ):
 119         """Perform a half-duplex write from buffer_out and then
 120         read data into buffer_in
 121         """
 122         if not buffer_out or not buffer_in:
 123             return
 124         if out_end is None:
 125             out_end = len(buffer_out)
 126         if in_end is None:
 127             in_end = len(buffer_in)
 128         if out_end - out_start != in_end - in_start:
 129             raise RuntimeError("Buffer slices must be of equal length.")
 130         try:
 131             # self._spi.open(self._port, 0)
 132             # self.set_no_cs()
 133             self._spi.max_speed_hz = self.baudrate
 134             self._spi.mode = self.mode
 135             self._spi.bits_per_word = self.bits
 136             data = self._spi.transfer(list(buffer_out[out_start : out_end + 1]))
 137             for i in range((in_end - in_start)):
 138                 buffer_in[i + in_start] = data[i]
 139             # self._spi.close()
 140         except FileNotFoundError:
 141             print("Could not open SPI device - check if SPI is enabled in kernel!")
 142             raise
 143
 144     # pylint: enable=too-many-arguments