void cobalt_memdev_cleanup(void)
{
rtdm_dev_unregister(&sysmem_device);
rtdm_dev_unregister(umm_devices + UMM_SHARED);
rtdm_dev_unregister(umm_devices + UMM_PRIVATE);
cobalt_umm_free(&cobalt_kernel_ppd.umm, nkvdso);
cobalt_umm_destroy(&cobalt_kernel_ppd.umm);
}
/* Module exit */
void __exit moduleTerm(
void) {
uint32_t i;
for (i = 0u; i < CFG_MAX_DEVICES; i++) {
struct rtdm_device * dev;
dev = Devs[i];
if (NULL != dev) {
int retval;
retval = rtdm_dev_unregister(
dev,
2000u);
if (0 != retval) {
LOG_WARN("SPI device %d failed to unregister cleanly, err: %d", i, -retval);
}
lldDevTerm(
dev);
portDevDisable(
dev);
portDevDestroy(
dev);
}
}
}
void __exit __rtdmtest_exit(void)
{
rtdm_task_destroy(&task);
rtdm_task_join_nrt(&task, 100);
printk("%s: unregistering device %s\n",
__FUNCTION__, device.device_name);
rtdm_dev_unregister(&device, 1000);
}
static void __exit omap_uart_exit_driver(void)
{
rtdm_printk("omap_uart_exit_driver exit\n");
platform_driver_unregister(&omap_uart_driver);
rtdm_dev_unregister(&uart_device, 1000);
}
void __exit rpi_gpio_exit(void)
{
rtdm_printk("RPI_GPIO RTDM, unloading\n");
// Unmap addr
iounmap (virt_addr);
rtdm_dev_unregister (&device, 1000);
}
int cobalt_memdev_init(void)
{
int ret;
ret = cobalt_umm_init(&cobalt_kernel_ppd.umm,
CONFIG_XENO_OPT_SHARED_HEAPSZ * 1024, NULL);
if (ret)
return ret;
cobalt_umm_set_name(&cobalt_kernel_ppd.umm, "shared heap");
nkvdso = cobalt_umm_alloc(&cobalt_kernel_ppd.umm, sizeof(*nkvdso));
if (nkvdso == NULL) {
ret = -ENOMEM;
goto fail_vdso;
}
init_vdso();
ret = rtdm_dev_register(umm_devices + UMM_PRIVATE);
if (ret)
goto fail_private;
ret = rtdm_dev_register(umm_devices + UMM_SHARED);
if (ret)
goto fail_shared;
ret = rtdm_dev_register(&sysmem_device);
if (ret)
goto fail_sysmem;
return 0;
fail_sysmem:
rtdm_dev_unregister(umm_devices + UMM_SHARED);
fail_shared:
rtdm_dev_unregister(umm_devices + UMM_PRIVATE);
fail_private:
cobalt_umm_free(&cobalt_kernel_ppd.umm, nkvdso);
fail_vdso:
cobalt_umm_destroy(&cobalt_kernel_ppd.umm);
return ret;
}
static void __exit mpu9150_i2c_exit_driver(void)
{
if( mpu9150_device )
sleep_mpu9150( mpu9150_device );
cleanup_mpu9150_irq();
i2c_del_driver( &mpu9150_i2c_driver );
// Poll at 1kHs for pending users
rtdm_dev_unregister(&mpu9150_driver, 1000);
}
/** Clear an RTDM device.
*/
void ec_rtdm_dev_clear(
ec_rtdm_dev_t *rtdm_dev /**< EtherCAT RTDM device. */
)
{
int ret;
EC_MASTER_INFO(rtdm_dev->master, "Unregistering RTDM device %s.\n",
rtdm_dev->dev->driver_name);
ret = rtdm_dev_unregister(rtdm_dev->dev, 1000 /* poll delay [ms] */);
if (ret < 0) {
EC_MASTER_WARN(rtdm_dev->master,
"Failed to unregister RTDM device (code %i).\n", ret);
}
kfree(rtdm_dev->dev);
}
void __switchtest_exit(void)
{
rtdm_dev_unregister(&device, 1000);
rtdm_nrtsig_destroy(&rtswitch_wake_utask);
}
int tdma_dev_release(struct rtmac_tdma *tdma)
{
return rtdm_dev_unregister(&tdma->api_device);
}
void a4l_unregister(void)
{
int i;
for (i = 0; i < A4L_NB_DEVICES; i++)
rtdm_dev_unregister(&(rtdm_devs[i]), 1000);
}
/**
* This function is called when the module is unloaded
*
* It unregister the RTDM device, polling at 1000 ms for pending users.
*
*/
void __exit simple_rtdm_exit(void)
{
rtdm_dev_unregister(&device, 1000);
}
void __switchtest_exit(void)
{
rtdm_dev_unregister(&device, 1000);
}
