sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
9d768498ce
nuttx/drivers/sensors/adxl372.c
raiden00pl 3d765616ea sensors/adxl372: add support for the new sensor framework 
adxl372 can be used with the new sensor framework
2024-04-21 18:57:33 +08:00

887 lines
26 KiB
C
Raw Blame History

/****************************************************************************
* drivers/sensors/adxl372.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_SPI) && defined(CONFIG_SENSORS_ADXL372) \
&& defined(CONFIG_SPI_EXCHANGE)
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <string.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs/fs.h>
#include <nuttx/mutex.h>
#include <nuttx/sensors/adxl372.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define ADXL372_INITIAL_CR_SIZE 7
/****************************************************************************
* Private structure definitions
****************************************************************************/
struct sensor_data_s
{
int16_t x_gyr; /* Measurement result for x axis */
int16_t y_gyr; /* Measurement result for y axis */
int16_t z_gyr; /* Measurement result for z axis */
};
struct adxl372_dev_s
{
FAR struct adxl372_dev_s *flink; /* Supports a singly linked list of
* drivers */
FAR struct spi_dev_s *spi; /* Pointer to the SPI instance */
FAR struct adxl372_config_s *config; /* Pointer to the configuration of the
* ADXL372 sensor */
mutex_t devicelock; /* Manages exclusive access to this
* device */
struct sensor_data_s data; /* The data as measured by the sensor */
uint8_t seek_address; /* Current device address. */
uint8_t readonly; /* 0 = writing to the device in enabled */
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static uint8_t adxl372_read_register(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr);
static void adxl372_read_registerblk(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr,
FAR uint8_t *reg_data,
uint8_t xfercnt);
static void adxl372_write_register(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr,
uint8_t reg_data);
static void adxl372_write_registerblk(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr,
FAR uint8_t *reg_data,
uint8_t xfercnt);
static void adxl372_reset(FAR struct adxl372_dev_s *dev);
static int adxl372_open(FAR struct file *filep);
static int adxl372_close(FAR struct file *filep);
static ssize_t adxl372_read(FAR struct file *, FAR char *, size_t);
static ssize_t adxl372_write(FAR struct file *filep,
FAR const char *buffer, size_t buflen);
static off_t adxl372_seek(FAR struct file *filep, off_t offset,
int whence);
static int adxl372_ioctl(FAR struct file *filep, int cmd,
unsigned long arg);
static int adxl372_dvr_open(FAR void *instance, int32_t arg);
static int adxl372_dvr_close(FAR void *instance, int32_t arg);
static ssize_t adxl372_dvr_read(FAR void *instance,
FAR char *buffer, size_t buflen);
static ssize_t adxl372_dvr_write(FAR void *instance,
FAR const char *buffer, size_t buflen);
static off_t adxl372_dvr_seek(FAR void *instance, off_t offset,
int whence);
static int adxl372_dvr_ioctl(FAR void *instance, int cmd,
unsigned long arg);
static void adxl372_dvr_exchange(FAR void *instance,
FAR const void *txbuffer,
FAR void *rxbuffer, size_t nwords);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_adxl372_fops =
{
adxl372_open, /* open */
adxl372_close, /* close */
adxl372_read, /* read */
adxl372_write, /* write */
adxl372_seek, /* seek */
adxl372_ioctl, /* ioctl */
};
static const struct adxl372_dvr_entry_vector_s g_adxl372_dops =
{
/* Standard sensor cluster driver entry-vector */
{
.driver_open = adxl372_dvr_open,
.driver_close = adxl372_dvr_close,
.driver_read = adxl372_dvr_read,
.driver_write = adxl372_dvr_write,
.driver_seek = adxl372_dvr_seek,
.driver_ioctl = adxl372_dvr_ioctl,
.driver_suspend = 0,
.driver_resume = 0,
},
/* adxl372 extensions follow */
.driver_spiexc = adxl372_dvr_exchange,
};
/****************************************************************************
* Private data storage
****************************************************************************/
/* Single linked list to store instances of drivers */
static struct adxl372_dev_s *g_adxl372_list = NULL;
/* Default accelerometer initialization sequence */
/* Configure ADXL372 to read live data (not using FIFO).
* 1. Set to standby mode. The below can't be set while running.
* 2. Configure the FIFO to be bypassed.
* 3. Configure interrupts as disabled, because ADXL372 irpts are used.
* 4. Configure the Output Data Rate (ODR) as 1600 Hz.
* 5. Configure normal mode (vs low noise) and 800Hz bandwidth.
* 6. Set to operational mode; 370ms filter settle; LPF=enb; HPF=dis;
*/
static struct adxl372_reg_pair_s g_initial_adxl372_cr_values[] =
{
/* Set to standby mode */
{
.addr = ADXL372_POWER_CTL,
.value = 0
},
{
.addr = ADXL372_FIFO_CTL,
.value = ADXL372_FIFO_BYPASSED
},
/* Interrupts disabled. */
{
.addr = ADXL372_INT1_MAP,
.value = 0
},
{
.addr = ADXL372_TIMING,
.value = ADXL372_TIMING_ODR1600
},
{
.addr = ADXL372_MEASURE,
.value = ADXL372_MEAS_BW800
},
{
.addr = ADXL372_POWER_CTL,
.value = ADXL372_POWER_HPF_DISABLE | ADXL372_POWER_MODE_MEASURE
}
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: adxl372_read_register
****************************************************************************/
static uint8_t adxl372_read_register(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr)
{
uint8_t reg_data;
/* Lock the SPI bus so that only one device can access it
* at the same time
*/
SPI_LOCK(dev->spi, true);
SPI_SETFREQUENCY(dev->spi, ADXL372_SPI_FREQUENCY);
SPI_SETMODE(dev->spi, ADXL372_SPI_MODE);
/* Set CS to low to select the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, true);
/* Transmit the register address from where we want to read. */
SPI_SEND(dev->spi, (reg_addr << 1) | ADXL372_READ);
/* Write an idle byte while receiving the requested data */
reg_data = (uint8_t) (SPI_SEND(dev->spi, 0xff));
/* Set CS to high to deselect the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, false);
/* Unlock the SPI bus */
SPI_LOCK(dev->spi, false);
return reg_data;
}
/****************************************************************************
* Name: adxl372_read_registerblk
****************************************************************************/
static void adxl372_read_registerblk(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr,
FAR uint8_t *reg_data,
uint8_t xfercnt)
{
/* Lock the SPI bus so that only one device can access it
* at the same time
*/
SPI_LOCK(dev->spi, true);
SPI_SETFREQUENCY(dev->spi, ADXL372_SPI_FREQUENCY);
SPI_SETMODE(dev->spi, ADXL372_SPI_MODE);
/* Set CS to low to select the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, true);
/* Transmit the register address from where we want to start reading */
SPI_SEND(dev->spi, (reg_addr << 1) | ADXL372_READ);
/* Write idle bytes while receiving the requested data */
while (0 != xfercnt--)
{
*reg_data++ = (uint8_t)SPI_SEND(dev->spi, 0xff);
}
/* Set CS to high to deselect the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, false);
/* Unlock the SPI bus */
SPI_LOCK(dev->spi, false);
}
/****************************************************************************
* Name: adxl372_write_register
****************************************************************************/
static void adxl372_write_register(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr, uint8_t reg_data)
{
/* Lock the SPI bus so that only one device can access it
* at the same time
*/
SPI_LOCK(dev->spi, true);
SPI_SETFREQUENCY(dev->spi, ADXL372_SPI_FREQUENCY);
SPI_SETMODE(dev->spi, ADXL372_SPI_MODE);
/* Set CS to low to select the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, true);
/* Transmit the register address to where we want to write */
SPI_SEND(dev->spi, (reg_addr << 1) | ADXL372_WRITE);
/* Transmit the content which should be written into the register */
SPI_SEND(dev->spi, reg_data);
/* Set CS to high to deselect the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, false);
/* Unlock the SPI bus */
SPI_LOCK(dev->spi, false);
}
/****************************************************************************
* Name: adxl372_write_registerblk
****************************************************************************/
static void adxl372_write_registerblk(FAR struct adxl372_dev_s *dev,
uint8_t reg_addr,
FAR uint8_t *reg_data,
uint8_t xfercnt)
{
/* Lock the SPI bus so that only one device can access it
* at the same time
*/
SPI_LOCK(dev->spi, true);
SPI_SETFREQUENCY(dev->spi, ADXL372_SPI_FREQUENCY);
SPI_SETMODE(dev->spi, ADXL372_SPI_MODE);
/* Set CS to low which selects the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, true);
/* Transmit the register address to where we want to start writing */
SPI_SEND(dev->spi, (reg_addr << 1) | ADXL372_WRITE);
/* Transmit the content which should be written in the register block */
while (0 != xfercnt--)
{
SPI_SEND(dev->spi, *reg_data++);
}
/* Set CS to high to deselect the ADXL372 */
SPI_SELECT(dev->spi, dev->config->spi_devid, false);
/* Unlock the SPI bus */
SPI_LOCK(dev->spi, false);
}
/****************************************************************************
* Name: adxl372_reset
*
* Description:
* ADXL Accelerometer Reset
* 1. Make sure that a reset is not in progress.
* 2. Write ADXL372_RESET_VALUE (0x52) to ADXL372_RESET register.
* 3. Wait for the reset to finish.
*
****************************************************************************/
static void adxl372_reset(FAR struct adxl372_dev_s *dev)
{
uint wdcnt = 10;
/* Wait for boot to finish (15 ms error timeout) */
up_mdelay(5);
while (wdcnt > 0 && (0 != adxl372_read_register(dev, ADXL372_RESET)))
{
up_mdelay(1);
}
/* Reset ADXL372 Accelerometer. Write only. Begin a boot. */
adxl372_write_register(dev, ADXL372_RESET, ADXL372_RESET_VALUE);
/* Wait for boot to finish (15 ms error timeout) */
up_mdelay(5);
wdcnt = 10;
while (wdcnt > 0 && (0 != adxl372_read_register(dev, ADXL372_RESET)))
{
up_mdelay(1);
}
}
/****************************************************************************
* Name: adxl372_read_id
*
* Description:
*
* Read the ADXL372 Accelerometer's ID Registers.
* There are 4 ID Registers...
*
* Manufacturer should be ADXL372_DEVID_AD_VALUE (0xAD).
* Family should be ADXL372_DEVID_MST_VALUE (0x1D).
* Part ID should be ADXL372_PARTID_VALUE (0xFA, Octal 372)
* Revision is returned, but not expected to be checked.
* All of the above are returned as an uint32_t. Should be 0xAD1DFAxx.
*
****************************************************************************/
static uint32_t adxl372_read_id(FAR struct adxl372_dev_s *dev)
{
union
{
uint32_t adxl_devid32;
uint8_t adxl_devid[4];
} un;
un.adxl_devid[3] = adxl372_read_register(dev, ADXL372_DEVID_AD);
un.adxl_devid[2] = adxl372_read_register(dev, ADXL372_DEVID_MST);
un.adxl_devid[1] = adxl372_read_register(dev, ADXL372_PARTID);
un.adxl_devid[0] = adxl372_read_register(dev, ADXL372_REVID);
return un.adxl_devid32;
}
/****************************************************************************
* Name: adxl372_dvr_open
****************************************************************************/
static int adxl372_dvr_open(FAR void *instance, int32_t arg)
{
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
FAR struct adxl372_reg_pair_s *initp;
uint32_t pnpid;
int sz;
int ret;
int i;
#ifdef CONFIG_DEBUG_SENSORS_INFO
uint8_t reg_content;
#endif
sninfo("adxl372_open: entered...\n");
DEBUGASSERT(priv != NULL);
UNUSED(arg);
ret = nxmutex_trylock(&priv->devicelock);
if (ret < 0)
{
sninfo("INFO: ADXL372 Accelerometer is already opened.\n");
return -EBUSY;
}
/* Read the ID registers */
pnpid = adxl372_read_id(priv);
priv->readonly = false;
sninfo("ADXL372_ID = 0x%08x\n", pnpid);
if ((pnpid & 0xffffff00) != (ADXL372_DEVID_AD_VALUE << 24 |
ADXL372_DEVID_MST_VALUE << 16 |
ADXL372_PARTID_VALUE << 8))
{
snwarn("ERROR: Invalid ADXL372_ID = 0x%08x\n", pnpid);
priv->readonly = true;
}
else /* ID matches */
{
adxl372_reset(priv); /* Perform a sensor reset */
/* Choose the initialization sequence */
if (priv->config->initial_cr_values_size == 0 ||
priv->config->initial_cr_values == NULL)
{
initp = g_initial_adxl372_cr_values; /* Default values */
sz = ADXL372_INITIAL_CR_SIZE;
}
else
{
initp = priv->config->initial_cr_values; /* User supplied values */
sz = priv->config->initial_cr_values_size;
}
/* Apply the initialization sequence */
for (i = 0; i < sz; i++)
{
adxl372_write_register(priv, initp[i].addr, initp[i].value);
}
#ifdef CONFIG_DEBUG_SENSORS_INFO
/* Read back the content of all control registers for debug purposes */
reg_content = adxl372_read_register(priv, ADXL372_FIFO_CTL);
sninfo("ADXL372_FIFO_CTL = 0x%02x\n", reg_content);
reg_content = adxl372_read_register(priv, ADXL372_INT1_MAP);
sninfo("ADXL372_INT1_MAP = 0x%02x\n", reg_content);
reg_content = adxl372_read_register(priv, ADXL372_TIMING);
sninfo("ADXL372_TIMING = 0x%02x\n", reg_content);
reg_content = adxl372_read_register(priv, ADXL372_MEASURE);
sninfo("ADXL372_MEASURE = 0x%02x\n", reg_content);
reg_content = adxl372_read_register(priv, ADXL372_POWER_CTL);
sninfo("ADXL372_POWER_CTL = 0x%02x\n", reg_content);
#endif
}
priv->seek_address = (uint8_t) ADXL372_XDATA_H;
return OK;
}
/****************************************************************************
* Name: adxl372_dvr_close
****************************************************************************/
static int adxl372_dvr_close(FAR void *instance, int32_t arg)
{
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
DEBUGASSERT(priv != NULL);
UNUSED(arg);
/* Perform a reset to place the sensor in standby mode. */
adxl372_reset(priv);
/* Release the sensor */
nxmutex_unlock(&priv->devicelock);
return OK;
}
/****************************************************************************
* Name: adxl372_dvr_read
****************************************************************************/
static ssize_t adxl372_dvr_read(FAR void *instance, FAR char *buffer,
size_t buflen)
{
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
union
{
int16_t d16;
char d8[2];
} un;
FAR char *p1;
FAR char *p2;
int i;
DEBUGASSERT(priv != NULL);
adxl372_read_registerblk(priv, priv->seek_address, (uint8_t *)buffer,
buflen);
/* Permute accelerometer data out fields */
if (priv->seek_address == ADXL372_XDATA_H && buflen >= 6)
{
p1 = p2 = buffer;
for (i = 0; i < 3; i++)
{
un.d8[1] = *p1++;
un.d8[0] = *p1++;
un.d16 = un.d16 >> 4;
*p2++ = un.d8[0];
*p2++ = un.d8[1];
}
}
return buflen;
}
/****************************************************************************
* Name: adxl372_dvr_write
****************************************************************************/
static ssize_t adxl372_dvr_write(FAR void *instance,
FAR const char *buffer, size_t buflen)
{
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
DEBUGASSERT(priv != NULL);
if (priv->readonly)
{
return -EROFS;
}
adxl372_write_registerblk(priv, priv->seek_address, (uint8_t *)buffer,
buflen);
return buflen;
}
/****************************************************************************
* Name: adxl372_dvr_seek
****************************************************************************/
static off_t adxl372_dvr_seek(FAR void *instance, off_t offset,
int whence)
{
off_t reg;
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
DEBUGASSERT(priv != NULL);
switch (whence)
{
case SEEK_CUR: /* Incremental seek */
reg = priv->seek_address + offset;
if (0 > reg || reg > ADXL372_LAST)
{
return -EINVAL;
}
priv->seek_address = reg;
break;
case SEEK_END: /* Seek to the 1st X-data register */
priv->seek_address = ADXL372_XDATA_H;
break;
case SEEK_SET: /* Seek to designated address */
if (0 > offset || offset > ADXL372_LAST)
{
return -EINVAL;
}
priv->seek_address = offset;
break;
default: /* invalid whence */
return -EINVAL;
}
return priv->seek_address;
}
/****************************************************************************
* Name: adxl372_dvr_ioctl
****************************************************************************/
static int adxl372_dvr_ioctl(FAR void *instance, int cmd,
unsigned long arg)
{
int ret = OK;
switch (cmd)
{
/* Command was not recognized */
default:
snerr("ERROR: Unrecognized cmd: %d\n", cmd);
ret = -ENOTTY;
break;
}
return ret;
}
/****************************************************************************
* Name: adxl372_dvr_exchange (with SPI DMA capability)
*
* Description:
* Exchange a block of data on SPI using DMA
*
* Input Parameters:
* instance - Pointer to struct adxl372_dev_s.
* txbuffer - A pointer to the buffer of data to be sent
* rxbuffer - A pointer to a buffer in which to receive data
* nwords - the length of data to be exchanged in units of words.
* The wordsize is determined by the number of bits-per-word
* selected for the SPI interface. If nbits <= 8, the data is
* packed into uint8_t's; if nbits >8, the data is packed into
* uint16_t's
*
* Returned Value:
* None
*
****************************************************************************/
static void adxl372_dvr_exchange(FAR void *instance,
FAR const void *txbuffer,
FAR void *rxbuffer, size_t nwords)
{
FAR struct adxl372_dev_s *priv = (FAR struct adxl372_dev_s *)instance;
FAR struct spi_dev_s *spi = priv->spi;
/* Lock the SPI bus so that only one device can access it
* at the same time
*/
SPI_LOCK(spi, true);
SPI_SETFREQUENCY(spi, ADXL372_SPI_FREQUENCY);
SPI_SETMODE(spi, ADXL372_SPI_MODE);
/* Set CS to low which selects the ADXL372 */
SPI_SELECT(spi, priv->config->spi_devid, true);
/* Perform an SPI exchange block operation. */
SPI_EXCHANGE(spi, txbuffer, rxbuffer, nwords);
/* Set CS to high to deselect the ADXL372 */
SPI_SELECT(spi, priv->config->spi_devid, false);
/* Unlock the SPI bus */
SPI_LOCK(spi, false);
}
/****************************************************************************
* Name: adxl372_open
****************************************************************************/
static int adxl372_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
int ret;
ret = adxl372_dvr_open((FAR void *)priv, 0);
return ret;
}
/****************************************************************************
* Name: adxl372_close
****************************************************************************/
static int adxl372_close(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
int ret;
ret = adxl372_dvr_close((FAR void *)priv, 0);
return ret;
}
/****************************************************************************
* Name: adxl372_read
****************************************************************************/
static ssize_t adxl372_read(FAR struct file *filep, FAR char *buffer,
size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
return adxl372_dvr_read(priv, buffer, buflen);
}
/****************************************************************************
* Name: adxl372_write
****************************************************************************/
static ssize_t adxl372_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
return adxl372_dvr_write(priv, buffer, buflen);
}
/****************************************************************************
* Name: adxl372_seek
****************************************************************************/
static off_t adxl372_seek(FAR struct file *filep, off_t offset, int whence)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
return adxl372_dvr_seek(priv, offset, whence);
}
/****************************************************************************
* Name: adxl372_ioctl
****************************************************************************/
static int adxl372_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct inode *inode = filep->f_inode;
FAR struct adxl372_dev_s *priv = inode->i_private;
return adxl372_dvr_ioctl(priv, cmd, arg);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: adxl372_register
*
* Description:
* Register the ADXL372 character device as 'devpath'
*
* Input Parameters:
* devpath - The full path to the driver to register. E.g., "/dev/acl0"
* spi - An instance of the SPI interface to use to communicate with
* ADXL372
* config - Configuration for the ADXL372 accelerometer driver. For
* details see description above.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
****************************************************************************/
int adxl372_register(FAR const char *devpath,
FAR struct spi_dev_s *spi,
FAR struct adxl372_config_s *config)
{
FAR struct adxl372_dev_s *priv;
int ret;
/* Sanity check */
DEBUGASSERT(spi != NULL);
DEBUGASSERT(config != NULL);
/* Initialize the ADXL372 accelerometer device structure. */
priv = kmm_malloc(sizeof(struct adxl372_dev_s));
if (priv == NULL)
{
snerr("ERROR: Failed to allocate accelerometer instance\n");
return -ENOMEM;
}
priv->spi = spi;
priv->config = config;
config->leaf_handle = NULL;
config->sc_ops = NULL;
/* Initialize sensor and sensor data access mutex */
nxmutex_init(&priv->devicelock);
/* Register the character driver */
ret = register_driver(devpath, &g_adxl372_fops, 0666, priv);
if (ret < 0)
{
snerr("ERROR: Failed to register accelerometer driver: %d\n", ret);
nxmutex_destroy(&priv->devicelock);
kmm_free(priv);
return ret;
}
/* Since we support multiple ADXL372 devices, we will need to add this new
* instance to a list of device instances so that it can be found by the
* interrupt handler based on the received IRQ number.
*/
priv->flink = g_adxl372_list;
g_adxl372_list = priv;
config->leaf_handle = (void *) priv;
config->sc_ops = &g_adxl372_dops;
return OK;
}
#endif /* CONFIG_SPI && CONFIG_SENSORS_ADXL372 && CONFIG_SPI_EXCHANGE */
Reference in New Issue View Git Blame Copy Permalink