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