void mcp_driver_unregister(struct mcp_driver *mcpdrv)
{
driver_unregister(&mcpdrv->drv);
}
void of_unregister_driver(struct of_platform_driver *drv)
{
driver_unregister(&drv->driver);
}
/**
* mmc_unregister_driver - unregister a media driver
* @drv: MMC media driver
*/
void mmc_unregister_driver(struct mmc_driver *drv)
{
drv->drv.bus = &mmc_bus_type;
driver_unregister(&drv->drv);
}
void xenbus_unregister_driver(struct xenbus_driver *drv)
{
driver_unregister(&drv->driver);
}
/* sa11x0_pcmcia_exit()
* ^^^^^^^^^^^^^^^^^^^^
* Invokes the low-level kernel service to free IRQs associated with this
* socket controller and reset GPIO edge detection.
*/
static void __exit sa11x0_pcmcia_exit(void)
{
driver_unregister(&sa11x0_pcmcia_driver);
}
void vlynq_unregister_driver(struct vlynq_driver *driver)
{
driver_unregister(&driver->driver);
}
/**
* rio_unregister_driver - unregister a RIO driver
* @rdrv: the RIO driver structure to unregister
*
* Deletes the &struct rio_driver from the list of registered RIO
* drivers, gives it a chance to clean up by calling its remove()
* function for each device it was responsible for, and marks those
* devices as driverless.
*/
void rio_unregister_driver(struct rio_driver *rdrv)
{
driver_unregister(&rdrv->driver);
}
static void __exit
snd_bebob_exit(void)
{
driver_unregister(&bebob_driver.driver);
}
void ipack_driver_unregister(struct ipack_driver *edrv)
{
driver_unregister(&edrv->driver);
}
static void __exit ohci_hcd_omap_cleanup (void)
{
driver_unregister(&ohci_hcd_omap_driver);
}
static void __exit tahvo_usb_exit(void)
{
driver_unregister(&omap_otg_driver);
platform_device_unregister(&tahvo_usb_device);
driver_unregister(&tahvo_usb_driver);
}
/**
* amba_driver_unregister - remove an AMBA device driver
* @drv: AMBA device driver structure to remove
*
* Unregister an AMBA device driver from the Linux device
* model. The device model will call the drivers remove function
* for each device the device driver is currently handling.
*/
void amba_driver_unregister(struct amba_driver *drv)
{
driver_unregister(&drv->drv);
}
void phy_driver_unregister(struct phy_driver *drv)
{
driver_unregister(&drv->driver);
}
void nvec_unregister_driver(struct nvec_driver *drv)
{
drv->driver.bus = &nvec_bus_type;
driver_unregister(&drv->driver);
}
static void __exit pxa2xx_ac97_exit(void)
{
driver_unregister(&pxa2xx_ac97_driver);
}
void vio_unregister_driver(struct vio_driver *viodrv)
{
driver_unregister(&viodrv->driver);
}
static void __exit ixp4xx_flash_exit(void)
{
driver_unregister(&ixp4xx_flash_driver);
}
void omap_dss_unregister_driver(struct omap_dss_driver *dssdriver)
{
driver_unregister(&dssdriver->driver);
}
/**
* fsl_mc_driver_unregister - unregisters a device driver from the
* MC bus
*/
void fsl_mc_driver_unregister(struct fsl_mc_driver *mc_driver)
{
driver_unregister(&mc_driver->driver);
}
void ntb_unregister_client(struct ntb_client *client)
{
driver_unregister(&client->drv);
}
static void __exit sa1100_serial_exit(void)
{
driver_unregister(&sa11x0_serial_driver);
uart_unregister_driver(&sa1100_reg);
}
static void __exit ide_gd_exit(void)
{
driver_unregister(&ide_gd_driver.gen_driver);
}
static int __init brf6150_init(void)
{
struct brf6150_info *info;
int irq, err;
info = kmalloc(sizeof(struct brf6150_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
memset(info, 0, sizeof(struct brf6150_info));
brf6150_device.dev.driver_data = info;
init_completion(&info->init_completion);
init_completion(&info->fw_completion);
info->pm_enabled = 0;
info->rx_pm_enabled = 0;
info->tx_pm_enabled = 0;
info->garbage_bytes = 0;
tasklet_init(&info->tx_task, brf6150_tx_tasklet, (unsigned long)info);
spin_lock_init(&info->lock);
skb_queue_head_init(&info->txq);
init_timer(&info->pm_timer);
info->pm_timer.function = brf6150_pm_timer;
info->pm_timer.data = (unsigned long)info;
exit_info = NULL;
info->btinfo = omap_get_config(OMAP_TAG_NOKIA_BT, struct omap_bluetooth_config);
if (info->btinfo == NULL)
return -1;
NBT_DBG("RESET gpio: %d\n", info->btinfo->reset_gpio);
NBT_DBG("BTWU gpio: %d\n", info->btinfo->bt_wakeup_gpio);
NBT_DBG("HOSTWU gpio: %d\n", info->btinfo->host_wakeup_gpio);
NBT_DBG("Uart: %d\n", info->btinfo->bt_uart);
NBT_DBG("sysclk: %d\n", info->btinfo->bt_sysclk);
err = omap_request_gpio(info->btinfo->reset_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line %d",
info->btinfo->reset_gpio);
kfree(info);
return err;
}
err = omap_request_gpio(info->btinfo->bt_wakeup_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line 0x%d",
info->btinfo->bt_wakeup_gpio);
omap_free_gpio(info->btinfo->reset_gpio);
kfree(info);
return err;
}
err = omap_request_gpio(info->btinfo->host_wakeup_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line %d",
info->btinfo->host_wakeup_gpio);
omap_free_gpio(info->btinfo->reset_gpio);
omap_free_gpio(info->btinfo->bt_wakeup_gpio);
kfree(info);
return err;
}
omap_set_gpio_direction(info->btinfo->reset_gpio, 0);
omap_set_gpio_direction(info->btinfo->bt_wakeup_gpio, 0);
omap_set_gpio_direction(info->btinfo->host_wakeup_gpio, 1);
set_irq_type(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio), IRQ_TYPE_NONE);
switch (info->btinfo->bt_uart) {
case 1:
irq = INT_UART1;
info->uart_ck = clk_get(NULL, "uart1_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART1_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
case 2:
irq = INT_UART2;
info->uart_ck = clk_get(NULL, "uart2_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART2_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
case 3:
irq = INT_UART3;
info->uart_ck = clk_get(NULL, "uart3_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART3_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
default:
printk(KERN_ERR "No uart defined\n");
goto cleanup;
}
info->irq = irq;
err = request_irq(irq, brf6150_interrupt, 0, "brf6150", (void *)info);
if (err < 0) {
printk(KERN_ERR "brf6150: unable to get IRQ %d\n", irq);
goto cleanup;
}
err = request_irq(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio),
brf6150_wakeup_interrupt, 0, "brf6150_wkup", (void *)info);
if (err < 0) {
printk(KERN_ERR "brf6150: unable to get wakeup IRQ %d\n",
OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio));
free_irq(irq, (void *)info);
goto cleanup;
}
/* Register with LDM */
if (platform_device_register(&brf6150_device)) {
printk(KERN_ERR "failed to register brf6150 device\n");
err = -ENODEV;
goto cleanup_irq;
}
/* Register the driver with LDM */
if (driver_register(&brf6150_driver)) {
printk(KERN_WARNING "failed to register brf6150 driver\n");
platform_device_unregister(&brf6150_device);
err = -ENODEV;
goto cleanup_irq;
}
if (brf6150_register_hdev(info) < 0) {
printk(KERN_WARNING "failed to register brf6150 hci device\n");
platform_device_unregister(&brf6150_device);
driver_unregister(&brf6150_driver);
goto cleanup_irq;
}
exit_info = info;
return 0;
cleanup_irq:
free_irq(irq, (void *)info);
free_irq(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio), (void *)info);
cleanup:
omap_free_gpio(info->btinfo->reset_gpio);
omap_free_gpio(info->btinfo->bt_wakeup_gpio);
omap_free_gpio(info->btinfo->host_wakeup_gpio);
kfree(info);
return err;
}
void dio_unregister_driver(struct dio_driver *drv)
{
driver_unregister(&drv->driver);
}
/**
* rmi_unregister_function_driver - unregister given RMI function driver
* @fn_drv: RMI driver that should be unregistered.
*
* This function unregisters given function driver from RMI core which
* causes it to be unbound from the function devices.
*/
void rmi_unregister_function_driver(struct rmi_function_driver *fn_drv)
{
driver_unregister(&fn_drv->driver);
}
void lm_driver_unregister(struct lm_driver *drv)
{
driver_unregister(&drv->drv);
}
static void __exit cpm_uart_exit(void)
{
driver_unregister(&cpm_scc_uart_driver);
driver_unregister(&cpm_smc_uart_driver);
uart_unregister_driver(&cpm_reg);
}
static void __exit ehci_hcd_ppc_soc_cleanup(void)
{
driver_unregister(&ehci_hcd_ppc_soc_driver);
}
/**
* unregister_rpmsg_driver() - unregister an rpmsg driver from the rpmsg bus
* @rpdrv: pointer to a struct rpmsg_driver
*
* Returns 0 on success, and an appropriate error value on failure.
*/
void unregister_rpmsg_driver(struct rpmsg_driver *rpdrv)
{
driver_unregister(&rpdrv->drv);
}
void zorro_unregister_driver(struct zorro_driver *drv)
{
driver_unregister(&drv->driver);
}