SPI.cxx

Go to the documentation of this file.

 
#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif
 
#include <cstdint>
#include <fcntl.h>
#include "Devtab.hxx"
#include "SPI.hxx"
 
__attribute__((optimize("-O3")))
int SPI::transfer_messages(struct spi_ioc_transfer *msgs, int num)
{
    //HASSERT(num > 0);
 
    int count = 0;
    int result;
 
    lock_.lock();
    bus_lock();
    for (int i = 0; i < num; ++i, ++msgs)
    {
        count += msgs->len;
        csAssert();
        result = transfer(msgs);
        if (UNLIKELY(result < 0))
        {
            /* something bad happened, reset the bus and bail */
            csDeassert();
            bus_unlock();
            lock_.unlock();
            return result;
        }
        if (msgs->cs_change)
        {
            if (UNLIKELY(msgs->delay_usec))
            {
                usleep(msgs->delay_usec);
            }
            csDeassert();
        }
    }
    bus_unlock();
    lock_.unlock();
 
    return count;
}
 
__attribute__((optimize("-O3")))
ssize_t SPI::read(File *file, void *buf, size_t count)
{
    int result;
 
    if ((file->flags & O_ACCMODE) == O_WRONLY)
    {
        return -EBADF;
    }
 
    struct spi_ioc_transfer msg;
    msg.tx_buf = 0;
    msg.rx_buf = (uint64_t)buf;
    msg.len = count;
    msg.speed_hz = speedHz;
    msg.delay_usec = 0;
    msg.bits_per_word = bitsPerWord;
    msg.cs_change = true;
 
    lock_.lock();
    bus_lock();
    csAssert();
    result = transfer(&msg);
    csDeassert();
    bus_unlock();
    lock_.unlock();
 
    return result;
}
 
__attribute__((optimize("-O3")))
ssize_t SPI::write(File *file, const void *buf, size_t count)
{
    int result;
 
    if ((file->flags & O_ACCMODE) == O_RDONLY)
    {
        return -EBADF;
    }
 
    struct spi_ioc_transfer msg;
    msg.tx_buf = (uint64_t)buf;
    msg.rx_buf = 0;
    msg.len = count;
    msg.speed_hz = speedHz;
    msg.delay_usec = 0;
    msg.bits_per_word = bitsPerWord;
    msg.cs_change = true;
 
    lock_.lock();
    bus_lock();
    csAssert();
    result = transfer(&msg);
    csDeassert();
    bus_unlock();
    lock_.unlock();
 
    return result;
}
 
__attribute__((optimize("-O3")))
int SPI::ioctl(File *file, unsigned long int key, unsigned long data)
{
    HASSERT(IOC_TYPE(key) == SPI_IOC_MAGIC);
 
    if (IOC_NR(key) == 0)
    {
        /* message transfer */
        struct spi_ioc_transfer *msgs = (struct spi_ioc_transfer*)data;
        int result = transfer_messages(msgs, IOC_SIZE(key) /
                                             sizeof(struct spi_ioc_transfer));
        if (result < 0)
        {
            return result;
        }
        return 0;
    }
    switch (key)
    {
        default:
            return -EINVAL;
        case SPI_IOC_GET_OBJECT_REFERENCE:
        {
            SPI **self = (SPI**)data;
            *self = this;
            return 0;
        }
        case SPI_IOC_RD_MODE:
        {
            uint8_t *m = (uint8_t*)data;
            *m = mode;
            break;
        }
        case SPI_IOC_WR_MODE:
        {
            uint8_t *m = (uint8_t*)data;
            HASSERT(*m <= SPI_MODE_3);
            mode = *m;
            break;
        }
        case SPI_IOC_RD_LSB_FIRST:
        {
            uint8_t *lsbf = (uint8_t*)data;
            *lsbf = lsbFirst;
            break;
        }
        case SPI_IOC_WR_LSB_FIRST:
        {
            uint8_t *lsbf = (uint8_t*)data;
            lsbFirst = *lsbf;
            break;
        }
        case SPI_IOC_RD_BITS_PER_WORD:
        {
            uint8_t *bpw = (uint8_t*)data;
            *bpw = bitsPerWord;
            break;
        }
        case SPI_IOC_WR_BITS_PER_WORD:
        {
            uint8_t *bpw = (uint8_t*)data;
            bitsPerWord = *bpw;
            break;
        }
        case SPI_IOC_RD_MAX_SPEED_HZ:
        {
            uint32_t *hz = (uint32_t*)data;
            *hz = speedHz;
            break;
        }
        case SPI_IOC_WR_MAX_SPEED_HZ:
        {
            uint32_t *hz = (uint32_t*)data;
            speedHz = *hz;
            break;
        }
    }
 
    lock_.lock();
    bus_lock();
    int result = update_configuration();
    lock_.unlock();
    bus_unlock();
 
    return result;
}