1. 描述

本文主要描述QNX SPI Drvier的相关内容，并以SA8155P处理器为例讲解SPI框架。

2. 目录结构

2.1 HW Drivers:

路径：apps/qnx_ap/AMSS/platform/hwdrivers/wired_peripherals/spi

├── aarch64
│   ├── Makefile
│   └── so-le
├── arm
│   ├── Makefile
│   └── so-le-v7
│       └── Makefile
├── common.mk
├── device
│   ├── inc
│   │   ├── SpiDalProps.h
│   │   ├── SpiDeviceError.h
│   │   ├── SpiDevice.h
│   │   ├── SpiDeviceInternal.h
│   │   ├── SpiDeviceOsSvc.h
│   │   ├── SpiDevicePlatSvc.h
│   │   ├── SpiDeviceTransfer.h
│   │   └── SpiDeviceTypes.h
│   ├── SpiDalProps.c
│   ├── SpiDevice.c
│   ├── SpiDeviceOsSvc.c
│   ├── SpiDevicePlatSvc.c
│   └── SpiDeviceTransfer.c
├── driver
│   ├── inc
│   │   └── SpiDriverTypes.h
│   └── SpiDriver.c
├── logs
│   ├── inc
│   │   └── SpiLog.h
│   └── SpiLog.c
├── Makefile
└── public
    └── amss
        └── core

2.2. SPI Resource(SPI资源管理器)

apps/qnx_ap/AMSS/platform/resources/spi_drv

├── aarch64
│   ├── Makefile
│   └── so-le
├── arm
│   ├── Makefile
│   └── so-le-v7
│       └── Makefile
├── common.mk
├── Makefile
├── protected
│   ├── spi_devctls.h
│   └── spi_lib.h
└── spi_drv.c
 

2.3. SPI Service(SPI服务进程) 

/apps/qnx_ap/AMSS/platform/services/daemons/spi_service

├── aarch64
│   ├── Makefile
│   └── o-le
├── arm
│   ├── Makefile
│   └── o-le-v7
│       └── Makefile
├── common.mk
├── Makefile
└── src
    └── spi_service.c

2.4. API

apps/qnx_ap/AMSS/platform/qal/clients/spi_client

app/qnx_ap/qnx_bins/prebuilt_QNX700/target/qnx7/usr/include/hw/spi-master.h

├── aarch64
│   ├── Makefile
│   └── so-le
├── arm
│   ├── Makefile
│   └── so-le-v7
│       └── Makefile
├── common.mk
├── Makefile
├── pinfo.mk
├── public
│   └── amss
│       └── spi_client.h
└── src
    └── spi_client.c

3. API 

3.1 API接口

 app/qnx_ap/qnx_bins/prebuilt_QNX700/target/qnx7/usr/include/hw/spi-master.h

 * SPI API calls
 */
int	spi_open(const char *path);
int spi_close(int fd);
int spi_setcfg(int fd, uint32_t device, spi_cfg_t *cfg);
int spi_getdevinfo(int fd, uint32_t device, spi_devinfo_t *devinfo);
int spi_getdrvinfo(int fd, spi_drvinfo_t *drvinfo);
int spi_read(int fd, uint32_t device, void *buf, int len);
int spi_write(int fd, uint32_t device, void *buf, int len);
int spi_xchange(int fd, uint32_t device, void *wbuf, void *rbuf, int len);
int spi_cmdread(int fd, uint32_t device, void *cbuf, int16_t clen, void *rbuf, int rlen);
int spi_dma_xchange(int fd, uint32_t device, void *wbuf, void *rbuf, int len);
int spi_dma_xfer(int fd, uint32_t device, void *paddr, int len);

4. SPI资源管理器设计

在QNX下开发驱动程序，最主要的工作除了了解底层硬件具体工作流程外，就是建立一个能与操
作系统兼容且支持POSIX的Resource manger框架了。在任何一段程序的执行过程中一段都是从
main函数开始的，然而在操作系统中的main函数还传递了两个参数：int argc, char argv，这两个
参数是用来传递从shell命令行或者buildfile中传来对Resource manger具体参数的，使用options
(int argc, char argv);函数实现，所以这个函数在main函数中最开始的位置，可以开发的driver具有
不同可选的特性，提供使用的便利性。

4.1 Spi Service Demo进程

spi_service.c 基本没做什么，就是一个壳子，核心工作如下

• 调用spi_drv.c资源管理初始化spi驱动spi_drv_init()
• 启动服务spi_service(后台进程)

4.2  spi资源管理器核心spi_drv.c 

入口函数：spi_drv_init

/*===========================================================================
FUNCTION: spi_drv_init

DESCRIPTION : This function init the SPI-RM
===========================================================================*/
int spi_drv_init(void)
{
   int i = 0, idx = 0, rc = 0;
   uint64_t chip_id = 0;
   const void *fdt_paddr = 0;
   pthread_t threadID;
   DALSYSPropertyVar PropVar;
   DALSYS_PROPERTY_HANDLE_DECLARE(hDALProps);

   DALSYS_InitMod(NULL);
   DALSYS_RegisterMod(&gDALModDriverInfoList);

   fdt_paddr = fdt_get_root();
   if (!fdt_paddr) {
      SPI_SLOGE("SPI_RM: Failed to load device tree");
      return -1;
   }
   rc = fdt_foreach_subnode_byname((void*) fdt_paddr , "/chip_info",
                                   &get_chip_info, &chip_id);
   if (rc) {
      SPI_SLOGE("SPI_RM: Failed to find dt chip_info");
      return -1;
   }

   /* Create RM's for each active SPI bus */
   int ret = EOK;

   int policy;
   struct sched_param param;
   pthread_attr_t attr;

   if (waitfor_attach(QCORE_SERVICE, 5000))
   {
      SPI_SLOGE("Timed out waiting for %s to be ready", QCORE_SERVICE);
      return -1;
   }

   //线程配置
   pthread_attr_init(&attr);
   pthread_getschedparam(pthread_self(), &policy, &param);
   param.sched_priority = 100;
   pthread_attr_setschedparam(&attr, &param);

   //资源管理器创建
   for (i = 0; i < MAX_NUM_SPI_DEVS; i++)
   {
      if(DALSYS_GetDALPropertyHandle(DeviceID[i], hDALProps)==DAL_SUCCESS)
      {
         if (DAL_SUCCESS != DALSYS_GetPropertyValue(hDALProps, "SPI_ENABLED", 0, &PropVar)
             || PropVar.Val.dwVal == 0)
         {
            continue;
         }

         devs[idx] = calloc(1, sizeof(spi_dev_t));
         if (devs[idx] == NULL)
         {
            pthread_attr_destroy(&attr);
            return -1;
         }

         snprintf(devs[idx]->devname, MAX_DEVNAME_LENGTH, "/dev/spi%d", i+1);
         devs[idx]->spi_idx = i;
         devs[idx]->initialized = 0;
#ifdef SPI_LPM_TIMER
         devs[idx]->timer_created = 0;
#endif

         if (DAL_SUCCESS != DALSYS_GetPropertyValue(hDALProps, "CLOCK_SE_NAME", 0, &PropVar)
             || PropVar.Val.pszVal == 0)
         {
            pthread_attr_destroy(&attr);
            return -1;
         }

         if (!strncmp(PropVar.Val.pszVal, "scc", 3)) {
            devs[idx]->is_ssc = true;
         }

         //具体实现核心代码
         ret = pthread_create(&threadID, &attr, (void *)&spi_device_main_thread,
                              (void *)devs[idx]);

         if (ret == EOK)
         {
            pthread_setname_np(threadID, devs[idx]->devname);
            SPI_SLOGD("SPI_RM: Created RM thread for device-%d:name-%s", DeviceID[i], devs[idx]->devname);
            idx++;
         }
         else
         {
            SPI_SLOGE("Couldn't create RM thread for device-%d:name-%s:ret-%d",
            DeviceID[i], devs[idx]->devname, ret);
         }
      }
   }

   SPI_SLOGI("SPI_RM created %d threads.", idx);

   if (ID_6155 == chip_id) {
      if ((rc = spi_register_ssr())) {
         SPI_SLOGE("SPI_RM: Failed to register for SSR ret=%x\n", ret);
         return -1;
      }

      SPI_SLOGI("SPI_RM registered for SSR.");
   }

   return 0;
}

 资源管理器创建线程实现：

 标准步骤：

1. 建立一个上下文切换句柄dpp = dispatch_create();这个东东主要用在mainloop中产生一个block特性，可以让我们等待接受消息；
2. iofunc初始化。这一步是将自己实现的函数与POSIX层函数进行接口，解析从read、write、devctl等函数传来的消息进行解析，以实现底层与应用层函数之间的交互，通过io_funcs.read = io_read，io_funcs.write = io_write，进行函数重载；
3. 注册设备名，使设备在命名空间中产生相应的名称，这一点是整个过程的关键了，形如 pathID = resmgr_attach (dpp, &rattr, "/dev/Null",_FTYPE_ANY, 0, &connect_funcs,&io_funcs, &ioattr)，这样不仅注册了一个设备名，还让系统知道了我们实习的IO函数对应关系；
4. 为之前创建的上下文句柄分配空间，例如ctp = dispatch_context_alloc (dpp);为了第六步使用；
5. 通过不断循环等待dispatch_block()来调用MsgReceive()使Resource manger处于receive block状态，以接收上层发送来的消息，通过dispatch_handler (ctp)去调用我们自己定义的IO函数

SA8155平台是如何做的呢？

看下代码，基本类似。

/*===========================================================================
FUNCTION: spi_device_main_thread

DESCRIPTION : main thread to create and handle device.
===========================================================================*/
int spi_device_main_thread(spi_dev_t *dev)
{
   resmgr_connect_funcs_t connect_funcs;
   resmgr_io_funcs_t io_funcs;
   resmgr_attr_t rattr;
   iofunc_funcs_t ocb_funcs = { _IOFUNC_NFUNCS, _ocb_calloc, _ocb_free };
   iofunc_mount_t mount = { 0, 0, 0, 0, &ocb_funcs };
   int pathID;

   /*
    * Without this InterruptLock() in dalinterrupt will cause SIGSEGV
    * when calling from multiple threads
    */
   ThreadCtl(_NTO_TCTL_IO, 0);

#ifdef SPI_LPM_TIMER
   pthread_cond_init(&dev->clk_mutex, NULL);
#endif /* SPI_LPM_TIMER */
   //创建一个通讯Channel，返回chid
   dev->chid = ChannelCreate(_NTO_CHF_DISCONNECT | _NTO_CHF_UNBLOCK);
   if (dev->chid == -1) {
      SPI_SLOGE("ChannelCreate() failed, err=%d\n", errno);
      goto exit;
   }
   //1. 建立一个上下文切换句柄dpp

   /*
    * allocate and initialize a dispatch structure for use by our
    * main loop
    */
   dev->dpp = dispatch_create_channel( dev->chid, 0 );
   if (dev->dpp == NULL) {
      SPI_SLOGE("SPI_RM: couldn't dispatch_create. ");
      goto exit;
   }

   /* register internal communication channel */
   dev->int_coid = ConnectAttach(ND_LOCAL_NODE, 0 /* pid */, dev->chid, _NTO_SIDE_CHANNEL, 0);
   if (-1 == dev->int_coid) {
      SPI_SLOGE("SPI_RM internal ConnectAttach failed (%s)", strerror(errno));
      goto exit;
   }

   /*
    * set up the resource manager attributes structure, we'll
    * use this as a way of passing information to resmgr_attach().
    * For now, we just use defaults.
    */

   memset(&rattr, 0, sizeof(rattr)); /* using the defaults for rattr */
   rattr.nparts_max = 10;
   rattr.msg_max_size = (64 *4* 1024); //Max HW allowed transaction 64k

   //2. 调用iofunc_func_init初始化iofunc，connect_funcs
   /*
    * intialize the connect functions and I/O functions tables to
    * their defaults by calling iofunc_func_init().
    *
    * connect_funcs, and io_funcs variables are already declared.
    *
    */

   iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs, _RESMGR_IO_NFUNCS,
                    &io_funcs);

   /* over-ride the connect_funcs handler for open with our io_open,
    * and over-ride the io_funcs handlers for read and write with our
    * io_read and io_write handlers
    */
   connect_funcs.open = io_open;
   io_funcs.devctl = io_devctl;
   io_funcs.write = io_write;
   io_funcs.close_ocb = io_close;

   /* initialize our device description structure
   */
   /* io_attr 其实可以想像成一个文件相关的参数，比如读写权限等等 */
   iofunc_attr_init(&dev->hdr, S_IFCHR | 0666, NULL, NULL);

   dev->hdr.mount = &mount; // so we can alloc an OCB per open

   //3. resmgr_attach注册设备，注册一个资源设备名为dev->devname
   /*
    *  call resmgr_attach to register our prefix with the
    *  process manager, and also to let it know about our connect
    *  and I/O functions.
    *
    *  On error, returns -1 and errno is set.
    */
   pathID = resmgr_attach(dev->dpp, &rattr, dev->devname, _FTYPE_ANY, 0,
                          &connect_funcs, &io_funcs, (IOFUNC_ATTR_T*)dev);
   if (pathID == -1) {
      SPI_SLOGE("SPI_RM: Couldn't attach pathname: %s", strerror(errno));
      exit(1);
   }

#ifdef SPI_LPM_TIMER
   if ((dev->pulse_code = pulse_attach(dev->dpp, MSG_FLAG_ALLOC_PULSE, 0,
                                        &spi_stop_timer, (void*)dev)) == -1) {
      SPI_SLOGE("SPI_RM: pulse_attach failed - %s", strerror(errno));
      exit(1);
   }
#endif

   //4. 为之前创建的上下文句柄分配空间
   dev->ctp = dispatch_context_alloc(dev->dpp);
   if (dev->ctp == NULL) {
      SPI_SLOGE("SPI_RM: Could't alloc resmgr context - %s", strerror(errno));
      dispatch_destroy(dev->dpp);
      exit(1);
   }

   /* Notify bmetrics this device is ready */
   int fd = open("/dev/bmetrics", O_WRONLY);
   if (fd == -1) {
      SPI_SLOGE("SPI_RM: Couldn't open /dev/bmetrics");
   } else {
      char buf[30];
      snprintf(buf, 30, "bootmarker %s ready", dev->devname);
      if (-1 == write(fd, buf, 30)) {
         SPI_SLOGE("SPI_RM: Couldn't write /dev/bmetrics");
      }
      close(fd);
   }

   /* register LPM pulses */
   if (EOK != spi_register_lpm_pulse(dev))
   {
      SPI_SLOGE("SPI_RM: Failed to register pulses for %s(%s)", dev->devname, strerror(errno));
   }

   /* register internal pulses */
   if (EOK != spi_register_timeout_pulse(dev))
   {
      SPI_SLOGE("SPI_RM: Failed to register timeout pulse for %s(%s)", dev->devname, strerror(errno));
   }

   /* Initialize Spi device */
   if (EOK != spi_hwd_init(dev))
   {
      SPI_SLOGE("SPI_RM: Failed to init spi hardware %s(%s)", dev->devname, strerror(errno));
      dispatch_destroy(dev->dpp);
      exit(1);
   }

   /**5. 通过不断循环等待dispatch_block()与dispatch_handler (ctp)执行IO
    函数处理。
dispath_block() 相当于阻塞并等待，而 dispatch_handle() 则根据不同的挂接，调用不同的回调函
数进行处理。其实在_spi_register_interface里进行了dispatch_context_alloc的操作。通过不断循环
等待dispatch_block()来调用MsgReceive()使Resource manger处于receive block状态，以接收上层
发送来的消息，通过dispatch_handler (ctp)去调用我们自己定义的IO函数。
    */

   /*Message handling*/
   while (1)
   {
      if (dispatch_block(dev->ctp))
      {
         dispatch_handler(dev->ctp);
      }
      else if (errno != EFAULT)
      {
         break;
      }
      else
      {
         /* Do nothing */
      }
   }

exit:
   return -1;
}

 4.3  API与资源管理器之间的关联

devctl：

extern int devctl(int fd, int dcmd, void *dev_data_ptr, size_t nbytes, int *dev_info_ptr);
extern int devctlv(int fd, int dcmd, int sparts, int rparts, const struct iovec *sv, const struct iovec *rv, int *dev_info_ptr);

 

 

 open：

 

 5. APP例子

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "mmdefs.h"
#include "log.h"
#include "spi_driver.h"

#ifdef __QNX__
#include "spi_client.h"
#include "SpiDriver.h"
#endif

/* SPI driver handle */
static int fd = 0;

static const char *device_name = "/dev/spi1";

/* Main Interface */
int SPI_Init()
{
    int rc = -1;

    /* *******************************************************************************
     * During application mode both SPI0 and SPI1 operate as slaves and, by default,
     * configured in mode 1 (CPOL=0, CPHA=1) and for operation at a speed of 10MHz.
     * *******************************************************************************/
    fd = spi_open(device_name);
    if(fd == -1)
    {
        LOG("spi_open failed, fd=%d\n", fd);
        fd = 0;
    }
    else
    {
        LOG("spi_open successful, fd=%d\n", fd);

        spi_cfg_t cfg;
        // need bits_per_word as LSB in spi cfg
        cfg.mode = SPI_MODE_BODER_MSB | SPI_MODE_CSHOLD_HIGH | SPI_MODE_CKPHASE_HALF | ((0 << SPI_MODE_DEASSERT_WAIT_SHFT) & SPI_MODE_DEASSERT_WAIT_MASK) | 8;
        cfg.clock_rate = 2000000;
        LOG("spi_setcfg mode %x, rate %x\n", cfg.mode, cfg.clock_rate);
        rc = spi_setcfg(fd, SPI_DEVICE_1, &cfg);
        if(rc)
        {
            LOG("spi_setcfg failed, rc=%d\n", rc);
            close(fd);
            fd = 0;
        }
        else
        {
            LOG("spi_setcfg successful, rc=%d\n", rc);
        }
    }
	return rc;
}

void SPI_Deinit()
{
    if(fd)
    {
        spi_close(fd);
        fd = 0;
    }
}

/* SPI write functions */
int SPI_Write(uint8_t* buf, uint32_t len)
{
    int rc = 0;

    if(fd)
    {
        rc = spi_write(fd, SPI_DEVICE_1, buf, len);
        //rc = spi_cmdread(fd, SPI_DEVICE_1, buf, len, NULL, 0);
        if(rc != len)
        {
            LOG("spi_write failed, rc=%d\n", rc);
        }
    }
    else
    {
        rc = -1;
    }

    return rc;
}

/* SPI read functions */
int SPI_Read(uint8_t* buf, uint32_t len)
{
    int rc = 0;

    if(fd)
    {
        rc = spi_cmdread(fd, SPI_DEVICE_1, NULL, 0, buf, len);
        if(rc != len)
        {
            LOG("spi_read failed, rc=%d\n", rc);
        }
    }
    else
    {
        rc = -1;
    }

    return rc;
}

/* SPI write & read function */
int SPI_Write_Read(uint8_t* tx_buf, uint8_t* rx_buf, uint32_t len)
{
    int rc = 0;

    if( fd )
    {
        rc = spi_cmdread(fd, SPI_DEVICE_1, tx_buf, len, rx_buf, len);
        if( rc != len )
        {
            LOG("spi_cmdread failed, rc=%d\n", rc);
        }
    }
    else
    {
        rc = -1;
    }

    return rc;
}