rtems/testsuites/libtests/spi01/init.c

/* SPDX-License-Identifier: BSD-2-Clause */

/*
 * Copyright (c) 2016 embedded brains GmbH.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <dev/spi/spi.h>

#include <sys/ioctl.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <rtems/libcsupport.h>

#include "tmacros.h"

static uint8_t mode_8 = 0xA5;
static uint32_t mode_32 = 0x5A5A5A5A;
static uint32_t speed = 12345678;
static uint8_t bits_per_word = 12;
static uint8_t lsb_first = 1;

const char rtems_test_name[] = "SPI 1";

static const char bus_path[] = "/dev/spi-0";

typedef struct test_device test_device;

struct test_device {
  int (*transfer)(
    spi_bus *bus,
    const spi_ioc_transfer *msgs,
    uint32_t msg_count,
    test_device *dev
  );
};

typedef struct {
  test_device base;
  char buf[3];
} test_device_simple_read_write;

typedef struct {
  spi_bus base;
  unsigned long clock;
  test_device *device;
  uint32_t msg_count;
  uint32_t max_speed_hz;
  test_device_simple_read_write simple_read_write;
} test_bus;

static int test_simple_read_write_transfer(
  spi_bus *bus,
  const spi_ioc_transfer *msgs,
  uint32_t msg_count,
  test_device *base
)
{
  (void)bus;

  test_device_simple_read_write *dev = (test_device_simple_read_write *) base;

  if (msg_count == 1 && msgs[0].len == sizeof(dev->buf)) {
    if (msgs[0].rx_buf == 0){
        memcpy(&dev->buf[0], msgs[0].tx_buf, sizeof(dev->buf));
    } else if (msgs[0].tx_buf == 0){
        memcpy(msgs[0].rx_buf, &dev->buf[0], sizeof(dev->buf));
    } else {
        return -EIO;
    }
  } else {
    return -EIO;
  }
  return 0;
}

static int test_transfer(
  spi_bus *base,
  const spi_ioc_transfer *msgs,
  uint32_t msg_count
)
{
  test_bus *bus = (test_bus *) base;
  test_device *dev;

  dev = bus->device;
  bus->msg_count = msg_count;

  return (*dev->transfer)(&bus->base, msgs, msg_count, dev);
}

static int test_setup(spi_bus *base)
{
  test_bus *bus = (test_bus *) base;

  if ((base->speed_hz > bus->max_speed_hz) ||
    ((base->bits_per_word < 8) || (base->bits_per_word > 16))) {
    return 1;
  }

  return 0;
}

static void test_destroy(spi_bus *base)
{
  spi_bus_destroy_and_free(base);
}

static void test_simple_read_write(test_bus *bus, int fd)
{
  static const char zero[] = { 0, 0, 0 };
  static const char abc[] = { 'a', 'b', 'c' };

  int rv;
  char buf[3];
  ssize_t n;

  errno = 0;
  rv = ioctl(fd, 0xb00b);
  rtems_test_assert(rv == -1);
  rtems_test_assert(errno == EINVAL);

  errno = 0;
  n = write(fd, &buf[0], 1000);
  rtems_test_assert(n == -1);
  rtems_test_assert(errno == EIO);

  errno = 0;
  n = read(fd, &buf[0], 1000);
  rtems_test_assert(n == -1);
  rtems_test_assert(errno == EIO);

  rtems_test_assert(
    memcmp(&bus->simple_read_write.buf[0], &zero[0], sizeof(buf)) == 0
  );

  n = write(fd, &abc[0], sizeof(buf));
  rtems_test_assert(n == (ssize_t) sizeof(buf));

  rtems_test_assert(
    memcmp(&bus->simple_read_write.buf[0], &abc[0], sizeof(buf)) == 0
  );

  n = read(fd, &buf[0], sizeof(buf));
  rtems_test_assert(n == (ssize_t) sizeof(buf));

  rtems_test_assert(memcmp(&buf[0], &abc[0], sizeof(buf)) == 0);
}

static void test(void)
{
  rtems_resource_snapshot snapshot;
  test_bus *bus;
  int rv;
  int fd;
  uint8_t read_mode_8;
  uint32_t read_mode_32;
  uint32_t read_speed;
  uint8_t read_bits_per_word;
  uint8_t read_lsb_first;
  spi_ioc_transfer msg;

  rtems_resource_snapshot_take(&snapshot);

  bus = (test_bus *) spi_bus_alloc_and_init(sizeof(*bus));
  rtems_test_assert(bus != NULL);

  bus->base.transfer = test_transfer;
  bus->base.destroy = test_destroy;
  bus->base.setup = test_setup;

  bus->simple_read_write.base.transfer = test_simple_read_write_transfer;
  bus->device = &bus->simple_read_write.base;

  bus->max_speed_hz = 50000000;

  rv = spi_bus_register(&bus->base, &bus_path[0]);
  rtems_test_assert(rv == 0);

  fd = open(&bus_path[0], O_RDWR);
  rtems_test_assert(fd >= 0);

  rv = ioctl(fd, SPI_BUS_OBTAIN);
  rtems_test_assert(rv == 0);

  rv = ioctl(fd, SPI_BUS_RELEASE);
  rtems_test_assert(rv == 0);

  rv = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
  rtems_test_assert(rv == 0);
  rv = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &read_speed);
  rtems_test_assert(rv == 0);
  rtems_test_assert(read_speed == speed);

  speed = 60000000;
  rv = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
  rtems_test_assert(rv == -1);

  rv = ioctl(fd, SPI_IOC_WR_LSB_FIRST, &lsb_first);
  rtems_test_assert(rv == 0);
  rv = ioctl(fd, SPI_IOC_RD_LSB_FIRST, &read_lsb_first);
  rtems_test_assert(rv == 0);
  rtems_test_assert(read_lsb_first == lsb_first);

  rv = ioctl(fd, SPI_IOC_WR_MODE, &mode_8);
  rtems_test_assert(rv == 0);
  rv = ioctl(fd, SPI_IOC_RD_MODE, &read_mode_8);
  rtems_test_assert(rv == 0);
  rtems_test_assert(read_mode_8 == mode_8);

  rv = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits_per_word);
  rtems_test_assert(rv == 0);
  rv = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &read_bits_per_word);
  rtems_test_assert(rv == 0);
  rtems_test_assert(read_bits_per_word == bits_per_word);

  bits_per_word = 7;
  rv = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits_per_word);
  rtems_test_assert(rv == -1);

  rv = ioctl(fd, SPI_IOC_WR_MODE32, &mode_32);
  rtems_test_assert(rv == 0);
  rv = ioctl(fd, SPI_IOC_RD_MODE32, &read_mode_32);
  rtems_test_assert(rv == 0);
  rtems_test_assert(read_mode_32 == mode_32);

  bus->msg_count = 1;
  ioctl(fd, SPI_IOC_MESSAGE(8192), &msg);
  rtems_test_assert(bus->msg_count == 0);

  test_simple_read_write(bus, fd);

  rv = close(fd);
  rtems_test_assert(rv == 0);

  rv = unlink(&bus_path[0]);
  rtems_test_assert(rv == 0);

  rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
}

static void Init(rtems_task_argument arg)
{
  (void)arg;

  TEST_BEGIN();

  test();

  TEST_END();
  rtems_test_exit(0);
}

#define CONFIGURE_MICROSECONDS_PER_TICK 2000

#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER

#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 7

#define CONFIGURE_MAXIMUM_TASKS 1

#define CONFIGURE_MAXIMUM_SEMAPHORES 1

#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION

#define CONFIGURE_RTEMS_INIT_TASKS_TABLE

#define CONFIGURE_INIT

#include <rtems/confdefs.h>