ISSDK  1.8
IoT Sensing Software Development Kit
register_io_spi.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc.
3  * Copyright 2016-2017 NXP
4  * All rights reserved.
5  *
6  * SPDX-License-Identifier: BSD-3-Clause
7  */
8 
9 /**
10  * @file register_io_spi.c
11  * @brief The register_io_spi.c file contains definitions for low-level interface functions
12  * for reading and writing sensor registers using CMSIS APIs.
13  */
14 
15 /* Standard C Includes */
16 #include <string.h>
17 
18 /* ISSDK Includes */
19 #include "issdk_hal.h"
20 #include "gpio_driver.h"
21 #include "register_io_spi.h"
22 
23 /*******************************************************************************
24  * Types
25  ******************************************************************************/
26 #define SPI_COUNT (sizeof(spiBases) / sizeof(void *))
27 
28 /*******************************************************************************
29  * Variables
30  ******************************************************************************/
33 volatile bool b_SPI_CompletionFlag[SPI_COUNT] = {false};
34 volatile uint32_t g_SPI_ErrorEvent[SPI_COUNT] = {ARM_SPI_EVENT_TRANSFER_COMPLETE};
35 
36 /*******************************************************************************
37  * Code
38  ******************************************************************************/
39 #if defined(SPI0)
40 /* The SPI0 Signal Event Handler function. */
41 void SPI0_SignalEvent_t(uint32_t event)
42 {
43  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
44  {
45  g_SPI_ErrorEvent[0] = event;
46  }
47  b_SPI_CompletionFlag[0] = true;
48 }
49 #endif
50 
51 #if defined(SPI1)
52 /* The SPI1 Signal Event Handler function. */
53 void SPI1_SignalEvent_t(uint32_t event)
54 {
55  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
56  {
57  g_SPI_ErrorEvent[1] = event;
58  }
59  b_SPI_CompletionFlag[1] = true;
60 }
61 #endif
62 
63 #if defined(SPI2)
64 /* The SPI2 Signal Event Handler function. */
65 void SPI2_SignalEvent_t(uint32_t event)
66 {
67  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
68  {
69  g_SPI_ErrorEvent[2] = event;
70  }
71  b_SPI_CompletionFlag[2] = true;
72 }
73 #endif
74 
75 #if defined(SPI3)
76 /* The SPI3 Signal Event Handler function. */
77 void SPI3_SignalEvent_t(uint32_t event)
78 {
79  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
80  {
81  g_SPI_ErrorEvent[3] = event;
82  }
83  b_SPI_CompletionFlag[3] = true;
84 }
85 #endif
86 
87 #if defined(SPI4)
88 /* The SPI4 Signal Event Handler function. */
89 void SPI4_SignalEvent_t(uint32_t event)
90 {
91  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
92  {
93  g_SPI_ErrorEvent[4] = event;
94  }
95  b_SPI_CompletionFlag[4] = true;
96 }
97 #endif
98 
99 #if defined(SPI5)
100 /* The SPI5 Signal Event Handler function. */
101 void SPI5_SignalEvent_t(uint32_t event)
102 {
103  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
104  {
105  g_SPI_ErrorEvent[5] = event;
106  }
107  b_SPI_CompletionFlag[5] = true;
108 }
109 #endif
110 
111 #if defined(SPI6)
112 /* The SPI6 Signal Event Handler function. */
113 void SPI6_SignalEvent_t(uint32_t event)
114 {
115  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
116  {
117  g_SPI_ErrorEvent[6] = event;
118  }
119  b_SPI_CompletionFlag[6] = true;
120 }
121 #endif
122 
123 #ifndef CPU_LPC55S06JBD64
124 #if defined(SPI7)
125 /* The SPI7 Signal Event Handler function. */
126 void SPI7_SignalEvent_t(uint32_t event)
127 {
128  if (event != ARM_SPI_EVENT_TRANSFER_COMPLETE)
129  {
130  g_SPI_ErrorEvent[7] = event;
131  }
132  b_SPI_CompletionFlag[7] = true;
133 }
134 #endif
135 #endif
136 
137 /* Control Slave Select based on inactive/active and active low/high. */
139 {
140  if (ssControl->cmdCode == ssControl->activeValue)
141  {
142  pDspiGpioDriver->set_pin(ssControl->pTargetSlavePinID);
143  }
144  else
145  {
146  pDspiGpioDriver->clr_pin(ssControl->pTargetSlavePinID);
147  }
148 }
149 
150 /*! The interface function to block write sensor registers. */
151 int32_t Register_SPI_BlockWrite(ARM_DRIVER_SPI *pCommDrv,
152  registerDeviceInfo_t *devInfo,
153  void *pWriteParams,
154  uint8_t offset,
155  const uint8_t *pBuffer,
156  uint8_t bytesToWrite)
157 {
158  int32_t status;
159  spiCmdParams_t slaveWriteCmd;
160  spiSlaveSpecificParams_t *pSlaveParams = pWriteParams;
161 
162  spiControlParams_t ss_en_cmd = {
163  .cmdCode = ARM_SPI_SS_ACTIVE,
164  .activeValue = pSlaveParams->ssActiveValue,
165  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
166  };
167  spiControlParams_t ss_dis_cmd = {
168  .cmdCode = ARM_SPI_SS_INACTIVE,
169  .activeValue = pSlaveParams->ssActiveValue,
170  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
171  };
172 
173  pSlaveParams->pWritePreprocessFN(&slaveWriteCmd, offset, bytesToWrite, (void *)pBuffer);
174  b_SPI_CompletionFlag[devInfo->deviceInstance] = false;
175  g_SPI_ErrorEvent[devInfo->deviceInstance] = ARM_SPI_EVENT_TRANSFER_COMPLETE;
176  /*! Write and the value.*/
177  register_spi_control(&ss_en_cmd);
178  status = pCommDrv->Transfer(slaveWriteCmd.pWriteBuffer, slaveWriteCmd.pReadBuffer, slaveWriteCmd.size);
179  if (ARM_DRIVER_OK == status)
180  {
181  /* Wait for completion */
182  while (!b_SPI_CompletionFlag[devInfo->deviceInstance])
183  {
184  if (devInfo->idleFunction)
185  {
186  devInfo->idleFunction(devInfo->functionParam);
187  }
188  else
189  {
190  __NOP();
191  }
192  }
193  if (g_SPI_ErrorEvent[devInfo->deviceInstance] != ARM_SPI_EVENT_TRANSFER_COMPLETE)
194  {
195  status = ARM_DRIVER_ERROR;
196  pCommDrv->Control(ARM_SPI_ABORT_TRANSFER, 0);
197  }
198  }
199  register_spi_control(&ss_dis_cmd);
200 
201  return status;
202 }
203 
204 /*! The interface function to write a sensor register. */
205 int32_t Register_SPI_Write(ARM_DRIVER_SPI *pCommDrv,
206  registerDeviceInfo_t *devInfo,
207  void *pWriteParams,
208  uint8_t offset,
209  uint8_t value,
210  uint8_t mask)
211 {
212  int32_t status;
213  uint8_t regValue;
214  spiCmdParams_t slaveReadCmd, slaveWriteCmd;
215  spiSlaveSpecificParams_t *pSlaveParams = pWriteParams;
216 
217  spiControlParams_t ss_en_cmd = {
218  .cmdCode = ARM_SPI_SS_ACTIVE,
219  .activeValue = pSlaveParams->ssActiveValue,
220  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
221  };
222  spiControlParams_t ss_dis_cmd = {
223  .cmdCode = ARM_SPI_SS_INACTIVE,
224  .activeValue = pSlaveParams->ssActiveValue,
225  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
226  };
227 
228  /*! Set the register based on the values in the register value pair configuration.*/
229  if (mask)
230  {
231  /* Get the formatted SPI Read Command. */
232  pSlaveParams->pReadPreprocessFN(&slaveReadCmd, offset, 1);
233  b_SPI_CompletionFlag[devInfo->deviceInstance] = false;
234  g_SPI_ErrorEvent[devInfo->deviceInstance] = ARM_SPI_EVENT_TRANSFER_COMPLETE;
235  /*! Read the register value.*/
236  register_spi_control(&ss_en_cmd);
237  status = pCommDrv->Transfer(slaveReadCmd.pWriteBuffer, slaveReadCmd.pReadBuffer, slaveReadCmd.size);
238  if (ARM_DRIVER_OK == status)
239  {
240  /* Wait for completion */
241  while (!b_SPI_CompletionFlag[devInfo->deviceInstance])
242  {
243  if (devInfo->idleFunction)
244  {
245  devInfo->idleFunction(devInfo->functionParam);
246  }
247  else
248  {
249  __NOP();
250  }
251  }
252  if (g_SPI_ErrorEvent[devInfo->deviceInstance] != ARM_SPI_EVENT_TRANSFER_COMPLETE)
253  {
254  status = ARM_DRIVER_ERROR;
255  pCommDrv->Control(ARM_SPI_ABORT_TRANSFER, 0);
256  }
257  }
258  register_spi_control(&ss_dis_cmd);
259 
260  /*! 'OR' in the requested values to the current contents of the register */
261  regValue = *(slaveReadCmd.pReadBuffer + pSlaveParams->spiCmdLen);
262  regValue = (regValue & ~mask) | value;
263  }
264  else
265  {
266  /*! Overwrite the register with specified value.*/
267  regValue = value;
268  }
269 
270  pSlaveParams->pWritePreprocessFN(&slaveWriteCmd, offset, 1, &regValue);
271  b_SPI_CompletionFlag[devInfo->deviceInstance] = false;
272  g_SPI_ErrorEvent[devInfo->deviceInstance] = ARM_SPI_EVENT_TRANSFER_COMPLETE;
273  /*! Write and the value.*/
274  register_spi_control(&ss_en_cmd);
275  status = pCommDrv->Transfer(slaveWriteCmd.pWriteBuffer, slaveWriteCmd.pReadBuffer, slaveWriteCmd.size);
276  if (ARM_DRIVER_OK == status)
277  {
278  /* Wait for completion */
279  while (!b_SPI_CompletionFlag[devInfo->deviceInstance])
280  {
281  if (devInfo->idleFunction)
282  {
283  devInfo->idleFunction(devInfo->functionParam);
284  }
285  else
286  {
287  __NOP();
288  }
289  }
290  if (g_SPI_ErrorEvent[devInfo->deviceInstance] != ARM_SPI_EVENT_TRANSFER_COMPLETE)
291  {
292  status = ARM_DRIVER_ERROR;
293  pCommDrv->Control(ARM_SPI_ABORT_TRANSFER, 0);
294  }
295  }
296  register_spi_control(&ss_dis_cmd);
297 
298  return status;
299 }
300 
301 /*! The interface function to read a sensor register. */
302 int32_t Register_SPI_Read(ARM_DRIVER_SPI *pCommDrv,
303  registerDeviceInfo_t *devInfo,
304  void *pReadParams,
305  uint8_t offset,
306  uint8_t length,
307  uint8_t *pOutBuffer)
308 {
309  int32_t status;
310  spiCmdParams_t slaveReadCmd;
311  spiSlaveSpecificParams_t *pSlaveParams = pReadParams;
312 
313  spiControlParams_t ss_en_cmd = {
314  .cmdCode = ARM_SPI_SS_ACTIVE,
315  .activeValue = pSlaveParams->ssActiveValue,
316  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
317  };
318  spiControlParams_t ss_dis_cmd = {
319  .cmdCode = ARM_SPI_SS_INACTIVE,
320  .activeValue = pSlaveParams->ssActiveValue,
321  .pTargetSlavePinID = pSlaveParams->pTargetSlavePinID,
322  };
323 
324  pSlaveParams->pReadPreprocessFN(&slaveReadCmd, offset, length);
325  b_SPI_CompletionFlag[devInfo->deviceInstance] = false;
326  g_SPI_ErrorEvent[devInfo->deviceInstance] = ARM_SPI_EVENT_TRANSFER_COMPLETE;
327  /*! Read the value.*/
328  register_spi_control(&ss_en_cmd);
329  status = pCommDrv->Transfer(slaveReadCmd.pWriteBuffer, slaveReadCmd.pReadBuffer, slaveReadCmd.size);
330  if (ARM_DRIVER_OK == status)
331  {
332  /* Wait for completion */
333  while (!b_SPI_CompletionFlag[devInfo->deviceInstance])
334  {
335  if (devInfo->idleFunction)
336  {
337  devInfo->idleFunction(devInfo->functionParam);
338  }
339  else
340  {
341  __NOP();
342  }
343  }
344  if (g_SPI_ErrorEvent[devInfo->deviceInstance] != ARM_SPI_EVENT_TRANSFER_COMPLETE)
345  {
346  status = ARM_DRIVER_ERROR;
347  pCommDrv->Control(ARM_SPI_ABORT_TRANSFER, 0);
348  }
349  }
350  register_spi_control(&ss_dis_cmd);
351 
352  memcpy(pOutBuffer, slaveReadCmd.pReadBuffer + pSlaveParams->spiCmdLen, length);
353 
354  return status;
355 }
void(* set_pin)(pinID_t aPinId)
Definition: Driver_GPIO.h:46
#define SPI_COUNT
SPI_Type *const spiBases[]
This structure defines the device specific info required by register I/O.
Definition: sensor_drv.h:102
int32_t status
The register_io_spi.h file declares low-level interface functions for reading and writing sensor regi...
#define SPI_BASE_PTRS
Definition: frdm_ke15z.h:133
This structure defines the spi slave command format.
volatile bool b_SPI_CompletionFlag[SPI_COUNT]
int32_t Register_SPI_Write(ARM_DRIVER_SPI *pCommDrv, registerDeviceInfo_t *devInfo, void *pWriteParams, uint8_t offset, uint8_t value, uint8_t mask)
The interface function to write a sensor register.
Access structure of the GPIO Driver.
Definition: Driver_GPIO.h:38
void(* clr_pin)(pinID_t aPinId)
Definition: Driver_GPIO.h:47
typedef int32_t(DATA_FORMAT_Append_t))(void *pData
The interface function to append the data on the formated stream.
fpSpiReadPreprocessFn_t pReadPreprocessFN
The SPI Slave Transfer Command Params SDK2.0 Driver.
GENERIC_DRIVER_GPIO Driver_GPIO_KSDK
Definition: gpio_driver.c:177
GENERIC_DRIVER_GPIO * pDspiGpioDriver
volatile uint32_t g_SPI_ErrorEvent[SPI_COUNT]
The SPI Slave Control Command Params SDK2.0 Driver.
#define SPI_Type
Definition: frdm_ke15z.h:131
int32_t Register_SPI_BlockWrite(ARM_DRIVER_SPI *pCommDrv, registerDeviceInfo_t *devInfo, void *pWriteParams, uint8_t offset, const uint8_t *pBuffer, uint8_t bytesToWrite)
The interface function to block write to a sensor register.
void register_spi_control(spiControlParams_t *ssControl)
fpSpiWritePreprocessFn_t pWritePreprocessFN
int32_t Register_SPI_Read(ARM_DRIVER_SPI *pCommDrv, registerDeviceInfo_t *devInfo, void *pReadParams, uint8_t offset, uint8_t length, uint8_t *pOutBuffer)
The interface function to read a sensor register.
registeridlefunction_t idleFunction
Definition: sensor_drv.h:104