Esempio n. 1
0
void mcp_driver_unregister(struct mcp_driver *mcpdrv)
{
	driver_unregister(&mcpdrv->drv);
}
Esempio n. 2
0
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);
}
Esempio n. 4
0
void xenbus_unregister_driver(struct xenbus_driver *drv)
{
	driver_unregister(&drv->driver);
}
Esempio n. 5
0
/* 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);
}
Esempio n. 6
0
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);
}
Esempio n. 8
0
static void __exit
snd_bebob_exit(void)
{
	driver_unregister(&bebob_driver.driver);
}
Esempio n. 9
0
void ipack_driver_unregister(struct ipack_driver *edrv)
{
	driver_unregister(&edrv->driver);
}
Esempio n. 10
0
static void __exit ohci_hcd_omap_cleanup (void)
{
	driver_unregister(&ohci_hcd_omap_driver);
}
Esempio n. 11
0
static void __exit tahvo_usb_exit(void)
{
	driver_unregister(&omap_otg_driver);
	platform_device_unregister(&tahvo_usb_device);
	driver_unregister(&tahvo_usb_driver);
}
Esempio n. 12
0
/**
 *	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);
}
Esempio n. 13
0
void phy_driver_unregister(struct phy_driver *drv)
{
	driver_unregister(&drv->driver);
}
Esempio n. 14
0
void nvec_unregister_driver(struct nvec_driver *drv)
{
	drv->driver.bus = &nvec_bus_type;
	driver_unregister(&drv->driver);
}
Esempio n. 15
0
static void __exit pxa2xx_ac97_exit(void)
{
	driver_unregister(&pxa2xx_ac97_driver);
}
Esempio n. 16
0
void vio_unregister_driver(struct vio_driver *viodrv)
{
	driver_unregister(&viodrv->driver);
}
Esempio n. 17
0
static void __exit ixp4xx_flash_exit(void)
{
	driver_unregister(&ixp4xx_flash_driver);
}
Esempio n. 18
0
void omap_dss_unregister_driver(struct omap_dss_driver *dssdriver)
{
	driver_unregister(&dssdriver->driver);
}
Esempio n. 19
0
/**
 * 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);
}
Esempio n. 20
0
void ntb_unregister_client(struct ntb_client *client)
{
	driver_unregister(&client->drv);
}
Esempio n. 21
0
static void __exit sa1100_serial_exit(void)
{
	driver_unregister(&sa11x0_serial_driver);
	uart_unregister_driver(&sa1100_reg);
}
Esempio n. 22
0
static void __exit ide_gd_exit(void)
{
    driver_unregister(&ide_gd_driver.gen_driver);
}
Esempio n. 23
0
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;
}
Esempio n. 24
0
void dio_unregister_driver(struct dio_driver *drv)
{
	driver_unregister(&drv->driver);
}
Esempio n. 25
0
/**
 * 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);
}
Esempio n. 26
0
File: lm.c Progetto: aircross/ray
void lm_driver_unregister(struct lm_driver *drv)
{
	driver_unregister(&drv->drv);
}
Esempio n. 27
0
static void __exit cpm_uart_exit(void)
{
	driver_unregister(&cpm_scc_uart_driver);
	driver_unregister(&cpm_smc_uart_driver);
	uart_unregister_driver(&cpm_reg);
}
Esempio n. 28
0
static void __exit ehci_hcd_ppc_soc_cleanup(void)
{
	driver_unregister(&ehci_hcd_ppc_soc_driver);
}
Esempio n. 29
0
/**
 * 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);
}
Esempio n. 30
0
void zorro_unregister_driver(struct zorro_driver *drv)
{
    driver_unregister(&drv->driver);
}