Use ioctl for read

Regular reads from the spidev handle end up reading too many bytes due
to read-ahead buffering. Using the ioctl avoids this issue and allows
specifying per-transfer options if desired.

Author: tomstokes

spi.py

@@ -365,26 +365,34 @@ def mode(self, mode):
     def write(self, data):
         """Perform half-duplex SPI write.
 
-        Chip select is deactivated during write.
-
         Args:
             data: Binary string of data to write
         """
         self.handle.write(data)
         self.handle.flush()
 
-    def read(self, length):
+    def read(self, length, speed=0, bits_per_word=0, delay=0):
         """Perform half-duplex SPI read
 
-        Chip select is deactivated during read.
-
         Args:
             length: Integer count of bytes to read
+            speed: Optional temporary bitrate override in Hz. 0 (default)
+                uses existing spidev speed setting.
+            bits_per_word: Optional temporary bits_per_word override. 0 (
+                default) is equivalent to 8 bits per word.
+            delay: Optional delay in usecs between sending the last bit and
+                deselecting the chip select line. 0 (default) for no delay.
 
         Returns:
             Binary string of data read from device
         """
-        return self.handle.read(length)
+        receive_buffer = ctypes.create_string_buffer(length)
+        spi_ioc_transfer = struct.pack(SPI._IOC_TRANSFER_FORMAT, 0,
+                                       ctypes.addressof(receive_buffer),
+                                       length, speed, delay, bits_per_word, 0,
+                                       0, 0, 0)
+        fcntl.ioctl(self.handle, SPI._IOC_MESSAGE, spi_ioc_transfer)
+        return ctypes.string_at(receive_buffer, length)
 
     def transfer(self, data, speed=0, bits_per_word=0, delay=0):
         """Perform full-duplex SPI transfer