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; }