rt-thread/components/drivers/spi/dev_spi_core.c

/*
 * Copyright (c) 2006-2025 RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2012-01-08     bernard      first version.
 * 2012-02-03     bernard      add const attribute to the ops.
 * 2012-05-15     dzzxzz       fixed the return value in attach_device.
 * 2012-05-18     bernard      Changed SPI message to message list.
 *                             Added take/release SPI device/bus interface.
 * 2012-09-28     aozima       fixed rt_spi_release_bus assert error.
 * 2025-10-30     wdfk-prog    enable interrupt-safe operations using spinlocks
 */

#include "drivers/dev_spi.h"

#define DBG_TAG    "spi.core"
#define DBG_LVL    DBG_INFO
#include <rtdbg.h>

#ifdef RT_USING_DM
#include "dev_spi_dm.h"
#endif

extern rt_err_t rt_spi_bus_device_init(struct rt_spi_bus *bus, const char *name);
extern rt_err_t rt_spidev_device_init(struct rt_spi_device *dev, const char *name);

rt_err_t spi_bus_register(struct rt_spi_bus       *bus,
                          const char              *name,
                          const struct rt_spi_ops *ops)
{
    rt_err_t result;

    result = rt_spi_bus_device_init(bus, name);
    if (result != RT_EOK)
        return result;

    /* initialize mutex lock */
    rt_mutex_init(&(bus->lock), name, RT_IPC_FLAG_PRIO);
#ifdef RT_USING_SPI_ISR
    rt_spin_lock_init(&bus->_spinlock);
#endif /* RT_USING_SPI_ISR */
    /* set ops */
    bus->ops = ops;
    /* initialize owner */
    bus->owner = RT_NULL;

#ifdef RT_USING_DM
    if (!bus->slave)
    {
        int pin_count = rt_pin_get_named_pin_count(&bus->parent, "cs");

        if (pin_count > 0)
        {
            pin_count = rt_max_t(int, pin_count, bus->num_chipselect);

            for (int i = 0; i < pin_count; ++i)
            {
                bus->cs_pins[i] = rt_pin_get_named_pin(&bus->parent, "cs", i,
                                                       RT_NULL, &bus->cs_active_vals[i]);
            }
        }
        else if (pin_count < 0)
        {
            result = pin_count;

            LOG_E("CS PIN find error = %s", rt_strerror(result));

            rt_device_unregister(&bus->parent);
            return result;
        }
    }

    spi_bus_scan_devices(bus);
#endif

    return RT_EOK;
}

rt_err_t rt_spi_bus_register(struct rt_spi_bus       *bus,
                             const char              *name,
                             const struct rt_spi_ops *ops)
{
    /* set bus mode */
    bus->mode = RT_SPI_BUS_MODE_SPI;

    return spi_bus_register(bus, name, ops);
}

rt_err_t rt_spi_bus_attach_device_cspin(struct rt_spi_device *device,
                                        const char           *name,
                                        const char           *bus_name,
                                        rt_base_t            cs_pin,
                                        void                 *user_data)
{
    rt_err_t result;
    rt_device_t bus;

    /* get physical spi bus */
    bus = rt_device_find(bus_name);
    if (bus != RT_NULL && bus->type == RT_Device_Class_SPIBUS)
    {
        device->bus = (struct rt_spi_bus *)bus;

        if (device->bus->owner == RT_NULL)
            device->bus->owner = device;

        /* initialize spidev device */
        result = rt_spidev_device_init(device, name);
        if (result != RT_EOK)
            return result;

        if (cs_pin != PIN_NONE)
        {
            rt_pin_mode(cs_pin, PIN_MODE_OUTPUT);
        }

        rt_memset(&device->config, 0, sizeof(device->config));
        device->parent.user_data = user_data;
        device->cs_pin = cs_pin;
        return RT_EOK;
    }

    /* not found the host bus */
    return -RT_ERROR;
}

rt_err_t rt_spi_bus_detach_device_cspin(struct rt_spi_device *device)
{
    rt_err_t result;

    RT_ASSERT(device != RT_NULL);

    result = rt_device_unregister(&device->parent);
    if (result != RT_EOK)
    {
        LOG_E("Failed to unregister spi device, result: %d", result);
        return result;
    }

    if (device->bus != RT_NULL && device->bus->owner == device)
    {
        device->bus->owner = RT_NULL;
    }

    if (device->cs_pin != PIN_NONE)
    {
        rt_pin_mode(device->cs_pin, PIN_MODE_INPUT);
    }

    device->bus = RT_NULL;

    return RT_EOK;
}

rt_err_t rt_spi_bus_attach_device(struct rt_spi_device *device,
                                  const char           *name,
                                  const char           *bus_name,
                                  void                 *user_data)
{
    return rt_spi_bus_attach_device_cspin(device, name, bus_name, PIN_NONE, user_data);
}

rt_err_t rt_spi_bus_detach_device(struct rt_spi_device *device)
{
    return rt_spi_bus_detach_device_cspin(device);
}

static rt_err_t spi_lock(struct rt_spi_bus *bus)
{
    RT_ASSERT(bus);

    rt_err_t ret = -RT_ERROR;
    /* If the scheduler is started and in thread context */
    if (rt_scheduler_is_available())
    {
        ret = rt_mutex_take(&(bus->lock), RT_WAITING_FOREVER);
    }
    else
    {
#ifdef RT_USING_SPI_ISR
        bus->_isr_lvl = rt_spin_lock_irqsave(&bus->_spinlock);
        ret = RT_EOK;
#endif /* RT_USING_SPI_ISR */
    }
    return ret;
}

static rt_err_t spi_unlock(struct rt_spi_bus *bus)
{
    RT_ASSERT(bus);

    rt_err_t ret = -RT_ERROR;
    /* If the scheduler is started and in thread context */
    if (rt_scheduler_is_available())
    {
        ret = rt_mutex_release(&(bus->lock));
    }
    else
    {
#ifdef RT_USING_SPI_ISR
        rt_spin_unlock_irqrestore(&bus->_spinlock, bus->_isr_lvl);
        ret = RT_EOK;
#endif /* RT_USING_SPI_ISR */
    }
    return ret;
}

rt_err_t rt_spi_bus_configure(struct rt_spi_device *device)
{
    rt_err_t result = -RT_ERROR;

    if (device->bus != RT_NULL)
    {
        result = spi_lock(device->bus);
        if (result == RT_EOK)
        {
            if (device->bus->owner == device)
            {
                /* current device is using, re-configure SPI bus */
                result = device->bus->ops->configure(device, &device->config);
                if (result != RT_EOK)
                {
                    /* configure SPI bus failed */
                    LOG_E("SPI device %s configuration failed", device->parent.parent.name);
                }
            }
            else
            {
                /* RT_EBUSY is not an error condition and
                 * the configuration will take effect once the device has the bus
                 */
                result = -RT_EBUSY;
            }
            /* release lock */
            spi_unlock(device->bus);
        }
    }
    else
    {
        result = RT_EOK;
    }

    return result;
}

rt_err_t rt_spi_configure(struct rt_spi_device        *device,
                          struct rt_spi_configuration *cfg)
{
    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(cfg != RT_NULL);

    /* reset the CS pin */
    if (device->cs_pin != PIN_NONE)
    {
        rt_err_t result = spi_lock(device->bus);
        if (result == RT_EOK)
        {
            if (cfg->mode & RT_SPI_CS_HIGH)
            {
                rt_pin_write(device->cs_pin, PIN_LOW);
            }
            else
            {
                rt_pin_write(device->cs_pin, PIN_HIGH);
            }
            spi_unlock(device->bus);
        }
        else
        {
            return result;
        }
    }

    /* If the configurations are the same, we don't need to set again. */
    if (device->config.data_width == cfg->data_width &&
        device->config.mode       == (cfg->mode & RT_SPI_MODE_MASK) &&
        device->config.max_hz     == cfg->max_hz)
    {
        return RT_EOK;
    }

    /* set configuration */
    device->config.data_width = cfg->data_width;
    device->config.mode       = cfg->mode & RT_SPI_MODE_MASK;
    device->config.max_hz     = cfg->max_hz;

    return rt_spi_bus_configure(device);
}

rt_err_t rt_spi_send_then_send(struct rt_spi_device *device,
                               const void           *send_buf1,
                               rt_size_t             send_length1,
                               const void           *send_buf2,
                               rt_size_t             send_length2)
{
    rt_err_t result;
    struct rt_spi_message message;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    result = spi_lock(device->bus);
    if (result == RT_EOK)
    {
        if (device->bus->owner != device)
        {
            /* not the same owner as current, re-configure SPI bus */
            result = device->bus->ops->configure(device, &device->config);
            if (result == RT_EOK)
            {
                /* set SPI bus owner */
                device->bus->owner = device;
            }
            else
            {
                /* configure SPI bus failed */
                LOG_E("SPI device %s configuration failed", device->parent.parent.name);
                goto __exit;
            }
        }

        /* send data1 */
        message.send_buf   = send_buf1;
        message.recv_buf   = RT_NULL;
        message.length     = send_length1;
        message.cs_take    = 1;
        message.cs_release = 0;
        message.next       = RT_NULL;

        result = device->bus->ops->xfer(device, &message);
        if (result < 0)
        {
            LOG_E("SPI device %s transfer failed", device->parent.parent.name);
            goto __exit;
        }

        /* send data2 */
        message.send_buf   = send_buf2;
        message.recv_buf   = RT_NULL;
        message.length     = send_length2;
        message.cs_take    = 0;
        message.cs_release = 1;
        message.next       = RT_NULL;

        result = device->bus->ops->xfer(device, &message);
        if (result < 0)
        {
            LOG_E("SPI device %s transfer failed", device->parent.parent.name);
            goto __exit;
        }

        result = RT_EOK;
    }
    else
    {
        return -RT_EIO;
    }

__exit:
    spi_unlock(device->bus);

    return result;
}

rt_err_t rt_spi_send_then_recv(struct rt_spi_device *device,
                               const void           *send_buf,
                               rt_size_t             send_length,
                               void                 *recv_buf,
                               rt_size_t             recv_length)
{
    rt_err_t result;
    struct rt_spi_message message;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    result = spi_lock(device->bus);
    if (result == RT_EOK)
    {
        if (device->bus->owner != device)
        {
            /* not the same owner as current, re-configure SPI bus */
            result = device->bus->ops->configure(device, &device->config);
            if (result == RT_EOK)
            {
                /* set SPI bus owner */
                device->bus->owner = device;
            }
            else
            {
                /* configure SPI bus failed */
                LOG_E("SPI device %s configuration failed", device->parent.parent.name);
                goto __exit;
            }
        }

        /* send data */
        message.send_buf   = send_buf;
        message.recv_buf   = RT_NULL;
        message.length     = send_length;
        message.cs_take    = 1;
        message.cs_release = 0;
        message.next       = RT_NULL;

        result = device->bus->ops->xfer(device, &message);
        if (result < 0)
        {
            LOG_E("SPI device %s transfer failed", device->parent.parent.name);
            goto __exit;
        }

        /* recv data */
        message.send_buf   = RT_NULL;
        message.recv_buf   = recv_buf;
        message.length     = recv_length;
        message.cs_take    = 0;
        message.cs_release = 1;
        message.next       = RT_NULL;

        result = device->bus->ops->xfer(device, &message);
        if (result < 0)
        {
            LOG_E("SPI device %s transfer failed", device->parent.parent.name);
            goto __exit;
        }

        result = RT_EOK;
    }
    else
    {
        return -RT_EIO;
    }

__exit:
    spi_unlock(device->bus);

    return result;
}

rt_ssize_t rt_spi_transfer(struct rt_spi_device *device,
                           const void           *send_buf,
                           void                 *recv_buf,
                           rt_size_t             length)
{
    rt_ssize_t result;
    struct rt_spi_message message;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    result = spi_lock(device->bus);
    if (result == RT_EOK)
    {
        if (device->bus->owner != device)
        {
            /* not the same owner as current, re-configure SPI bus */
            result = device->bus->ops->configure(device, &device->config);
            if (result == RT_EOK)
            {
                /* set SPI bus owner */
                device->bus->owner = device;
            }
            else
            {
                /* configure SPI bus failed */
                LOG_E("SPI device %s configuration failed", device->parent.parent.name);
                goto __exit;
            }
        }

        /* initial message */
        message.send_buf   = send_buf;
        message.recv_buf   = recv_buf;
        message.length     = length;
        message.cs_take    = 1;
        message.cs_release = 1;
        message.next       = RT_NULL;

        /* transfer message */
        result = device->bus->ops->xfer(device, &message);
        if (result < 0)
        {
            LOG_E("SPI device %s transfer failed", device->parent.parent.name);
            goto __exit;
        }
    }
    else
    {
        return -RT_EIO;
    }

__exit:
    spi_unlock(device->bus);

    return result;
}

rt_err_t rt_spi_sendrecv8(struct rt_spi_device *device,
                          rt_uint8_t            senddata,
                          rt_uint8_t           *recvdata)
{
    rt_ssize_t len = rt_spi_transfer(device, &senddata, recvdata, 1);
    if (len < 0)
    {
        return (rt_err_t)len;
    }
    else
    {
        return RT_EOK;
    }
}

rt_err_t rt_spi_sendrecv16(struct rt_spi_device *device,
                           rt_uint16_t           senddata,
                           rt_uint16_t          *recvdata)
{
    rt_ssize_t len;
    rt_uint16_t tmp;

    if (device->config.mode & RT_SPI_MSB)
    {
        tmp = ((senddata & 0xff00) >> 8) | ((senddata & 0x00ff) << 8);
        senddata = tmp;
    }

    len = rt_spi_transfer(device, &senddata, recvdata, 2);
    if (len < 0)
    {
        return (rt_err_t)len;
    }

    if (device->config.mode & RT_SPI_MSB)
    {
        tmp = ((*recvdata & 0xff00) >> 8) | ((*recvdata & 0x00ff) << 8);
        *recvdata = tmp;
    }

    return RT_EOK;
}

struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device  *device,
                                               struct rt_spi_message *message)
{
    rt_err_t result;
    struct rt_spi_message *index;

    RT_ASSERT(device != RT_NULL);

    /* get first message */
    index = message;
    if (index == RT_NULL)
        return index;

    result = spi_lock(device->bus);
    if (result != RT_EOK)
    {
        return index;
    }

    /* configure SPI bus */
    if (device->bus->owner != device)
    {
        /* not the same owner as current, re-configure SPI bus */
        result = device->bus->ops->configure(device, &device->config);
        if (result == RT_EOK)
        {
            /* set SPI bus owner */
            device->bus->owner = device;
        }
        else
        {
            /* configure SPI bus failed */
            goto __exit;
        }
    }

    /* transmit each SPI message */
    while (index != RT_NULL)
    {
        /* transmit SPI message */
        result = device->bus->ops->xfer(device, index);
        if (result < 0)
        {
            break;
        }

        index = index->next;
    }

__exit:
    /* release bus lock */
    spi_unlock(device->bus);

    return index;
}

rt_err_t rt_spi_take_bus(struct rt_spi_device *device)
{
    rt_err_t result = RT_EOK;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    result = spi_lock(device->bus);
    if (result != RT_EOK)
    {
        return -RT_EBUSY;
    }

    /* configure SPI bus */
    if (device->bus->owner != device)
    {
        /* not the same owner as current, re-configure SPI bus */
        result = device->bus->ops->configure(device, &device->config);
        if (result == RT_EOK)
        {
            /* set SPI bus owner */
            device->bus->owner = device;
        }
        else
        {
            /* configure SPI bus failed */
            spi_unlock(device->bus);

            return result;
        }
    }

    return result;
}

rt_err_t rt_spi_release_bus(struct rt_spi_device *device)
{
    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);
    RT_ASSERT(device->bus->owner == device);

    /* release lock */
    return spi_unlock(device->bus);
}

rt_err_t rt_spi_take(struct rt_spi_device *device)
{
    rt_ssize_t result;
    struct rt_spi_message message;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    rt_memset(&message, 0, sizeof(message));
    message.cs_take = 1;

    result = device->bus->ops->xfer(device, &message);
    if (result < 0)
    {
        return (rt_err_t)result;
    }

    return RT_EOK;
}

rt_err_t rt_spi_release(struct rt_spi_device *device)
{
    rt_ssize_t result;
    struct rt_spi_message message;

    RT_ASSERT(device != RT_NULL);
    RT_ASSERT(device->bus != RT_NULL);

    rt_memset(&message, 0, sizeof(message));
    message.cs_release = 1;

    result = device->bus->ops->xfer(device, &message);
    if (result < 0)
    {
        return (rt_err_t)result;
    }

    return RT_EOK;
}