src/spi/spi.c

   1 /*
   2  * Author: Thomas Ingleby <thomas.c.ingleby@intel.com>
   3  * Copyright (c) 2014 Intel Corporation.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/ioctl.h>
  28 #include <linux/spi/spidev.h>
  29 #include <stdio.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32
  33 #include "spi.h"
  34 #include "mraa_internal.h"
  35
  36 #define MAX_SIZE 64
  37 #define SPI_MAX_LENGTH 4096
  38
  39 /**
  40  * A structure representing the SPI device
  41  */
  42 struct _spi {
  43     /*@{*/
  44     int devfd; /**< File descriptor to SPI Device */
  45     uint32_t mode; /**< Spi mode see spidev.h */
  46     int clock; /**< clock to run transactions at */
  47     mraa_boolean_t lsb; /**< least significant bit mode */
  48     unsigned int bpw; /**< Bits per word */
  49     /*@}*/
  50 };
  51
  52 mraa_spi_context
  53 mraa_spi_init(int bus)
  54 {
  55     if (plat == NULL) {
  56         syslog(LOG_ERR, "spi: Platform Not Initialised");
  57         return NULL;
  58     }
  59     if (plat->spi_bus_count == 0) {
  60         syslog(LOG_ERR, "spi: no spi buses defined in platform");
  61         return NULL;
  62     }
  63     if (plat->spi_bus_count == 1) {
  64         bus = plat->def_spi_bus;
  65     }
  66     if (bus >= plat->spi_bus_count) {
  67         syslog(LOG_ERR, "spi: requested bus above spi bus count");
  68         return NULL;
  69     }
  70     if (advance_func->spi_init_pre != NULL) {
  71         if (advance_func->spi_init_pre(bus) != MRAA_SUCCESS)
  72             return NULL;
  73     }
  74
  75     int pos = plat->spi_bus[bus].sclk;
  76     if (plat->pins[pos].spi.mux_total > 0) {
  77         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS) {
  78             syslog(LOG_ERR, "spi: failed to set-up spi sclk multiplexer");
  79             return NULL;
  80         }
  81     }
  82
  83     pos = plat->spi_bus[bus].mosi;
  84     if (plat->pins[pos].spi.mux_total > 0) {
  85         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS) {
  86             syslog(LOG_ERR, "spi: failed to set-up spi mosi multiplexer");
  87             return NULL;
  88         }
  89     }
  90
  91     pos = plat->spi_bus[bus].miso;
  92     if (plat->pins[pos].spi.mux_total > 0) {
  93         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS) {
  94             syslog(LOG_ERR, "spi: failed to set-up spi miso multiplexer");
  95             return NULL;
  96         }
  97     }
  98
  99     pos = plat->spi_bus[bus].cs;
 100     if (plat->pins[pos].spi.mux_total > 0) {
 101         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS) {
 102             syslog(LOG_ERR, "spi: failed to set-up spi cs multiplexer");
 103             return NULL;
 104         }
 105     }
 106     mraa_spi_context dev = mraa_spi_init_raw(plat->spi_bus[bus].bus_id, plat->spi_bus[bus].slave_s);
 107
 108     if (advance_func->spi_init_post != NULL) {
 109         mraa_result_t ret = advance_func->spi_init_post(dev);
 110         if (ret != MRAA_SUCCESS) {
 111             free(dev);
 112             return NULL;
 113         }
 114     }
 115
 116     return dev;
 117 }
 118
 119 mraa_spi_context
 120 mraa_spi_init_raw(unsigned int bus, unsigned int cs)
 121 {
 122     mraa_spi_context dev = (mraa_spi_context) malloc(sizeof(struct _spi));
 123     if (dev == NULL) {
 124         syslog(LOG_CRIT, "spi: Failed to allocate memory for context");
 125         return NULL;
 126     }
 127     memset(dev, 0, sizeof(struct _spi));
 128
 129     char path[MAX_SIZE];
 130     sprintf(path, "/dev/spidev%u.%u", bus, cs);
 131
 132     dev->devfd = open(path, O_RDWR);
 133     if (dev->devfd < 0) {
 134         syslog(LOG_ERR, "spi: Failed opening SPI Device. bus:%s", path);
 135         free(dev);
 136         return NULL;
 137     }
 138
 139     int speed = 0;
 140     if ((ioctl(dev->devfd, SPI_IOC_RD_MAX_SPEED_HZ, &speed) != -1) && (speed < 4000000)) {
 141         dev->clock = speed;
 142     }
 143     else {
 144         dev->clock = 4000000;
 145     }
 146
 147     if (mraa_spi_mode(dev, MRAA_SPI_MODE0) != MRAA_SUCCESS) {
 148         free(dev);
 149         return NULL;
 150     }
 151
 152     if (mraa_spi_lsbmode(dev, 0) != MRAA_SUCCESS) {
 153         free(dev);
 154         return NULL;
 155     }
 156
 157     if (mraa_spi_bit_per_word(dev, 8) != MRAA_SUCCESS) {
 158         free(dev);
 159         return NULL;
 160     }
 161
 162     return dev;
 163 }
 164
 165 mraa_result_t
 166 mraa_spi_mode(mraa_spi_context dev, mraa_spi_mode_t mode)
 167 {
 168     uint8_t spi_mode = 0;
 169     switch (mode) {
 170         case MRAA_SPI_MODE0:
 171             spi_mode = SPI_MODE_0;
 172             break;
 173         case MRAA_SPI_MODE1:
 174             spi_mode = SPI_MODE_1;
 175             break;
 176         case MRAA_SPI_MODE2:
 177             spi_mode = SPI_MODE_2;
 178             break;
 179         case MRAA_SPI_MODE3:
 180             spi_mode = SPI_MODE_3;
 181             break;
 182         default:
 183             spi_mode = SPI_MODE_0;
 184             break;
 185     }
 186
 187     if (ioctl (dev->devfd, SPI_IOC_WR_MODE, &spi_mode) < 0) {
 188         syslog(LOG_ERR, "spi: Failed to set spi mode");
 189         return MRAA_ERROR_INVALID_RESOURCE;
 190     }
 191
 192     dev->mode = spi_mode;
 193     return MRAA_SUCCESS;
 194 }
 195
 196 mraa_result_t
 197 mraa_spi_frequency(mraa_spi_context dev, int hz)
 198 {
 199     int speed = 0;
 200     dev->clock = hz;
 201     if (ioctl(dev->devfd, SPI_IOC_RD_MAX_SPEED_HZ, &speed) != -1) {
 202         if (speed < hz) {
 203             dev->clock = speed;
 204             syslog(LOG_WARNING, "spi: Selected speed reduced to max allowed speed");
 205         }
 206     }
 207     return MRAA_SUCCESS;
 208 }
 209
 210 mraa_result_t
 211 mraa_spi_lsbmode(mraa_spi_context dev, mraa_boolean_t lsb)
 212 {
 213     uint8_t lsb_mode = (uint8_t) lsb;
 214     if (ioctl (dev->devfd, SPI_IOC_WR_LSB_FIRST, &lsb_mode) < 0) {
 215         syslog(LOG_ERR, "spi: Failed to set bit order");
 216         return MRAA_ERROR_INVALID_RESOURCE;
 217     }
 218     if (ioctl (dev->devfd, SPI_IOC_RD_LSB_FIRST, &lsb_mode) < 0) {
 219         syslog(LOG_ERR, "spi: Failed to set bit order");
 220         return MRAA_ERROR_INVALID_RESOURCE;
 221     }
 222     dev->lsb = lsb;
 223     return MRAA_SUCCESS;
 224 }
 225
 226 mraa_result_t
 227 mraa_spi_bit_per_word(mraa_spi_context dev, unsigned int bits)
 228 {
 229     if (ioctl(dev->devfd, SPI_IOC_WR_BITS_PER_WORD, &bits) < 0) {
 230         syslog(LOG_ERR, "spi: Failed to set bit per word");
 231         return MRAA_ERROR_INVALID_RESOURCE;
 232     }
 233     dev->bpw = bits;
 234     return MRAA_SUCCESS;
 235 }
 236
 237 int
 238 mraa_spi_write(mraa_spi_context dev, uint8_t data)
 239 {
 240     struct spi_ioc_transfer msg;
 241     memset(&msg, 0, sizeof(msg));
 242
 243     uint16_t length = 1;
 244
 245     unsigned long recv = 0;
 246     msg.tx_buf = (unsigned long) &data;
 247     msg.rx_buf = (unsigned long) &recv;
 248     msg.speed_hz = dev->clock;
 249     msg.bits_per_word = dev->bpw;
 250     msg.delay_usecs = 0;
 251     msg.len = length;
 252     if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
 253         syslog(LOG_ERR, "spi: Failed to perform dev transfer");
 254         return -1;
 255     }
 256     return (int) recv;
 257 }
 258
 259 uint16_t
 260 mraa_spi_write_word(mraa_spi_context dev, uint16_t data)
 261 {
 262     struct spi_ioc_transfer msg;
 263     memset(&msg, 0, sizeof(msg));
 264
 265     uint16_t length = 2;
 266
 267     uint16_t recv = 0;
 268     msg.tx_buf = (unsigned long) &data;
 269     msg.rx_buf = (unsigned long) &recv;
 270     msg.speed_hz = dev->clock;
 271     msg.bits_per_word = dev->bpw;
 272     msg.delay_usecs = 0;
 273     msg.len = length;
 274     if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
 275         syslog(LOG_ERR, "spi: Failed to perform dev transfer");
 276         return -1;
 277     }
 278     return recv;
 279 }
 280
 281 mraa_result_t
 282 mraa_spi_transfer_buf(mraa_spi_context dev, uint8_t* data, uint8_t* rxbuf, int length)
 283 {
 284     struct spi_ioc_transfer msg;
 285     memset(&msg, 0, sizeof(msg));
 286
 287     msg.tx_buf = (unsigned long) data;
 288     msg.rx_buf = (unsigned long) rxbuf;
 289     msg.speed_hz = dev->clock;
 290     msg.bits_per_word = dev->bpw;
 291     msg.delay_usecs = 0;
 292     msg.len = length;
 293     if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
 294         syslog(LOG_ERR, "spi: Failed to perform dev transfer");
 295         return MRAA_ERROR_INVALID_RESOURCE;
 296     }
 297     return MRAA_SUCCESS;
 298 }
 299
 300 mraa_result_t
 301 mraa_spi_transfer_buf_word(mraa_spi_context dev, uint16_t* data, uint16_t* rxbuf, int length)
 302 {
 303     struct spi_ioc_transfer msg;
 304     memset(&msg, 0, sizeof(msg));
 305
 306     msg.tx_buf = (unsigned long) data;
 307     msg.rx_buf = (unsigned long) rxbuf;
 308     msg.speed_hz = dev->clock;
 309     msg.bits_per_word = dev->bpw;
 310     msg.delay_usecs = 0;
 311     msg.len = length;
 312     if (ioctl(dev->devfd, SPI_IOC_MESSAGE(1), &msg) < 0) {
 313         syslog(LOG_ERR, "spi: Failed to perform dev transfer");
 314         return MRAA_ERROR_INVALID_RESOURCE;
 315     }
 316     return MRAA_SUCCESS;
 317 }
 318
 319 uint8_t*
 320 mraa_spi_write_buf(mraa_spi_context dev, uint8_t* data, int length)
 321 {
 322     uint8_t* recv = malloc(sizeof(uint8_t) * length);
 323
 324     if (mraa_spi_transfer_buf(dev, data, recv, length) != MRAA_SUCCESS) {
 325         free(recv);
 326         return NULL;
 327     }
 328     return recv;
 329 }
 330
 331 uint16_t*
 332 mraa_spi_write_buf_word(mraa_spi_context dev, uint16_t *data, int length)
 333 {
 334     uint16_t* recv = malloc(sizeof(uint16_t) * length);
 335
 336     if (mraa_spi_transfer_buf_word(dev, data, recv, length) != MRAA_SUCCESS) {
 337         free(recv);
 338         return NULL;
 339     }
 340     return recv;
 341 }
 342
 343 mraa_result_t
 344 mraa_spi_stop(mraa_spi_context dev)
 345 {
 346     close(dev->devfd);
 347     free(dev);
 348     return MRAA_SUCCESS;
 349 }