static int sensor_accel_dev_probe(struct device *dev)
{
struct sensor_accel_info *info;
gb_debug("%s:\n",__func__);
if (!dev) {
return -EINVAL;
}
info = zalloc(sizeof(*info));
if (!info) {
return -ENOMEM;
}
info->dev = dev;
device_set_private(dev, info);
atomic_init(&txn, 0);
#ifdef CONFIG_PM
if (pm_register(&pm_callback) != OK)
{
dbg("Failed register to power management!\n");
}
#endif
return 0;
}
/**
* @brief Probe SPI device
*
* This function is called by the system to register the driver when the system
* boots up. This function allocates memory for the private SPI device
* information, and then sets up the hardware resource and interrupt handler.
*
* @param dev pointer to structure of device data
* @return 0 on success, negative errno on error
*/
static int tsb_spi_dev_probe(struct device *dev)
{
struct tsb_spi_dev_info *info;
struct device_resource *r;
int ret = 0;
if (tsb_get_rev_id() == tsb_rev_es2) {
return -ENODEV;
}
if (!dev) {
return -EINVAL;
}
info = zalloc(sizeof(*info));
if (!info) {
return -ENOMEM;
}
/* get register data from resource block */
r = device_resource_get_by_name(dev, DEVICE_RESOURCE_TYPE_REG, "reg_base");
if (!r) {
ret = -EINVAL;
goto err_freemem;
}
info->reg_base = (uint32_t)r->start;
info->state = TSB_SPI_STATE_CLOSED;
info->spi_pmstate = PM_SLEEP;
device_set_private(dev, info);
spi_dev = dev;
sem_init(&info->bus, 0, 1);
sem_init(&info->lock, 0, 1);
sem_init(&info->xfer_completed, 0, 0);
ret = tsb_pm_register(tsb_spi_pm_prepare, tsb_spi_pm_notify, dev);
if (ret) {
goto err_freemem;
}
return 0;
err_freemem:
free(info);
return ret;
}
/**
* @brief Remove SPI device
*
* This function is called by the system to unregister the driver. It should
* release the hardware resource and interrupt setting, and then free memory
* that allocated by the probe() function.
* This function should be called after probe() function. If driver was opened,
* this function should call close() function before releasing resources.
*
* @param dev pointer to structure of device data
*/
static void tsb_spi_dev_remove(struct device *dev)
{
struct tsb_spi_info *info = NULL;
/* check input parameter */
if (!dev || !device_get_private(dev)) {
return;
}
info = device_get_private(dev);
info->state = TSB_SPI_STATE_INVALID;
sem_destroy(&info->lock);
sem_destroy(&info->bus);
/* deinitialize gpio pins */
tsb_spi_hw_deinit(dev);
device_set_private(dev, NULL);
free(info);
}
static void sensor_accel_dev_remove(struct device *dev)
{
struct sensor_accel_info *info = NULL;
gb_debug("%s:\n",__func__);
if (!dev || !device_get_private(dev)) {
return;
}
info = device_get_private(dev);
if (info->flags & SENSOR_ACCEL_FLAG_OPEN) {
sensor_accel_dev_close(dev);
}
info->flags = 0;
free(info);
device_set_private(dev, NULL);
}
/**
* @brief Remove SPI device
*
* This function is called by the system to unregister the driver. It should
* release the hardware resource and interrupt setting, and then free memory
* that was allocated by the probe() function.
* This function should be called after probe() function. If driver was opened,
* this function should call close() function before releasing resources.
*
* @param dev pointer to structure of device data
*/
static void tsb_spi_dev_remove(struct device *dev)
{
struct tsb_spi_dev_info *info = NULL;
/* check input parameter */
if (!dev || !device_get_private(dev)) {
return;
}
info = device_get_private(dev);
info->state = TSB_SPI_STATE_INVALID;
sem_destroy(&info->lock);
sem_destroy(&info->bus);
sem_destroy(&info->xfer_completed);
device_set_private(dev, NULL);
spi_dev = NULL;
free(info);
}
/**
* @brief Probe SPI device
*
* This function is called by the system to register the driver when the system
* boot up. This function allocates memory for the private SPI device
* information, and then setup the hardware resource and interrupt handler.
*
* @param dev pointer to structure of device data
* @return 0 on success, negative errno on error
*/
static int tsb_spi_dev_probe(struct device *dev)
{
struct tsb_spi_info *info = NULL;
struct device_spi_caps *caps = NULL;
int ret = 0;
if (!dev) {
return -EINVAL;
}
info = zalloc(sizeof(*info));
if (!info) {
return -ENOMEM;
}
info->dev = dev;
info->state = TSB_SPI_STATE_CLOSED;
device_set_private(dev, info);
/* setup spi hardware capabilities */
caps = &info->caps;
caps->modes = SPI_MODE_CPHA |
SPI_MODE_CPOL |
SPI_MODE_CS_HIGH |
SPI_MODE_LSB_FIRST |
SPI_MODE_LOOP;
caps->flags = 0; /* Full Duplex */
caps->bpw = BIT(8-1) | BIT(16-1) | BIT(32-1);
caps->csnum = 1; /* support 1 chipselect */
info->chipselect[0] = SPI_CS;
info->selected = -1; /* select none */
info->bitexchange = tsb_spi_bitexchange0;
/* initialize gpio pins */
tsb_spi_hw_init(dev);
sem_init(&info->bus, 0, 1);
sem_init(&info->lock, 0, 1);
return ret;
}
static int gpio_wrls_tx_probe(struct device *dev)
{
struct gpio_wrls_tx_info *info = zalloc(sizeof(*info));
struct device_resource *r;
if (!info) {
dbg("failed to allocate memory\n");
return -ENOMEM;
}
r = device_resource_get_by_name(dev, DEVICE_RESOURCE_TYPE_GPIO,
"wrls_tx_cntrl");
if (!r) {
dbg("failed to get wrls_tx_cntrl gpio\n");
return -EINVAL;
}
info->gpio = r->start;
gpio_direction_out(info->gpio, WCHG_TX_ENABLE);
device_set_private(dev, info);
return 0;
}
