void bus_remove_driver(struct device_driver * drv) { if (drv->bus) { driver_remove_file(drv, &driver_attr_bind); driver_remove_file(drv, &driver_attr_unbind); driver_remove_attrs(drv->bus, drv); klist_remove(&drv->knode_bus); pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name); driver_detach(drv); module_remove_driver(drv); kobject_unregister(&drv->kobj); put_bus(drv->bus); } }
static int __devexit imx_3stack_ak4647_remove(struct platform_device *pdev) { struct mxc_audio_platform_data *dev_data = pdev->dev.platform_data; free_irq(dev_data->intr_id_hp, NULL); driver_remove_file(pdev->dev.driver, &driver_attr_headphone); return 0; }
static int dma_memcpy_remove(struct platform_device *pdev) { int ret; driver_remove_file(&pdev->dev, &driver_attr_dmamemcpy); return 0; }
static void __exit rk28_ts_ak4183_exit(void) { D("enter!\n"); driver_remove_file(&ak4183_i2c_driver.driver, &driver_attr_touchcheck); driver_remove_file(&ak4183_i2c_driver.driver, &driver_attr_touchadc); driver_remove_file(&ak4183_i2c_driver.driver, &driver_attr_calistatus); driver_remove_file(&ak4183_i2c_driver.driver, &driver_attr_debug_ak4183); i2c_del_driver(&ak4183_i2c_driver); free_irq(7, NULL); input_unregister_device(g_ts_dev->input); input_free_device(g_ts_dev->input); kfree(g_ts_dev); g_ts_dev = NULL;
static void __exit fpga_uinput_exit(void) { free_irq(UINPUT_INT_NUM, NULL); iounmap(fpga_uinput_mem); release_mem_region(UINPUT_BASE, UINPUT_SIZE); driver_remove_file(&fpga_uinput_driver, &driver_attr_fpga_uinput); driver_unregister(&fpga_uinput_driver); }
void unregister_cu3088_discipline(struct ccwgroup_driver *dcp) { if (!dcp) return; driver_remove_file(&dcp->driver, &driver_attr_group); ccwgroup_driver_unregister(dcp); }
static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv) { int i; if (bus->drv_attrs) { for (i = 0; attr_name(bus->drv_attrs[i]); i++) driver_remove_file(drv, &bus->drv_attrs[i]); } }
static int __devexit imx_3stack_ak4647_remove(struct platform_device *pdev) { struct snd_soc_machine *machine = pdev->dev.driver_data; imx_3stack_mach = NULL; driver_remove_file(pdev->dev.driver, &driver_attr_headphone); kfree(machine); return 0; }
static int __init hfc_init_module(void) { int err; hfc_msg(KERN_INFO, hfc_DRIVER_DESCR " loading\n"); atomic_set(&module_refcnt, 0); hfc_hdlc_framer_class = ks_feature_register("hdlc_framer"); if (!hfc_hdlc_framer_class) { err = -ENOMEM; goto err_register_hdlc_framer; } hfc_hdlc_deframer_class = ks_feature_register("hdlc_deframer"); if (!hfc_hdlc_deframer_class) { err = -ENOMEM; goto err_register_hdlc_deframer; } hfc_octet_reverser_class = ks_feature_register("octet_reverser"); if (!hfc_octet_reverser_class) { err = -ENOMEM; goto err_register_octet_reverser; } err = pci_register_driver(&hfc_driver); if (err < 0) goto err_pci_register_driver; #ifdef DEBUG_CODE err = driver_create_file( &hfc_driver.driver, &driver_attr_debug_level); if (err < 0) goto err_create_file_debug_level; #endif return 0; #ifdef DEBUG_CODE driver_remove_file( &hfc_driver.driver, &driver_attr_debug_level); err_create_file_debug_level: #endif err_pci_register_driver: ks_feature_unregister(hfc_octet_reverser_class); err_register_octet_reverser: ks_feature_unregister(hfc_hdlc_deframer_class); err_register_hdlc_deframer: ks_feature_unregister(hfc_hdlc_framer_class); err_register_hdlc_framer: return err; }
void dgnc_remove_driver_sysfiles(struct pci_driver *dgnc_driver) { struct device_driver *driverfs = &dgnc_driver->driver; driver_remove_file(driverfs, &driver_attr_version); driver_remove_file(driverfs, &driver_attr_boards); driver_remove_file(driverfs, &driver_attr_maxboards); driver_remove_file(driverfs, &driver_attr_debug); driver_remove_file(driverfs, &driver_attr_rawreadok); driver_remove_file(driverfs, &driver_attr_pollrate); driver_remove_file(driverfs, &driver_attr_pollcounter); driver_remove_file(driverfs, &driver_attr_state); }
gceSTATUS _PutPower( IN gckPLATFORM Platform ) { struct imx_priv *priv = Platform->priv; /*Disable clock*/ #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0) if (priv->clk_3d_axi) { clk_put(priv->clk_3d_axi); priv->clk_3d_axi = NULL; } #endif if (priv->clk_3d_core) { clk_put(priv->clk_3d_core); priv->clk_3d_core = NULL; } if (priv->clk_3d_shader) { clk_put(priv->clk_3d_shader); priv->clk_3d_shader = NULL; } if (priv->clk_2d_core) { clk_put(priv->clk_2d_core); priv->clk_2d_core = NULL; } if (priv->clk_2d_axi) { clk_put(priv->clk_2d_axi); priv->clk_2d_axi = NULL; } if (priv->clk_vg_axi) { clk_put(priv->clk_vg_axi); priv->clk_vg_axi = NULL; } #ifdef CONFIG_PM if(priv->pmdev) pm_runtime_disable(priv->pmdev); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0) if (priv->gpu_regulator) { regulator_put(priv->gpu_regulator); priv->gpu_regulator = NULL; } #endif #if gcdENABLE_FSCALE_VAL_ADJUST UNREG_THERMAL_NOTIFIER(&thermal_hot_pm_notifier); driver_remove_file(pdevice->dev.driver, &driver_attr_gpu3DMinClock); #endif return gcvSTATUS_OK; }
/* * Thanks to drivers making their tables __devinit, we can't allow manual * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. */ static int __must_check add_bind_files(struct device_driver *drv) { int ret; ret = driver_create_file(drv, &driver_attr_unbind); if (ret == 0) { ret = driver_create_file(drv, &driver_attr_bind); if (ret) driver_remove_file(drv, &driver_attr_unbind); } return ret; }
static int imx_3stack_alc5623_remove(struct platform_device *pdev) { struct mxc_audio_platform_data *plat = pdev->dev.platform_data; struct imx_3stack_priv *priv = &card_priv; if (plat->finit) plat->finit(); driver_remove_file(pdev->dev.driver, &driver_attr_headphone); return 0; }
/*----------------------------------------------------------------------------*/ static int kpd_delete_attr(struct device_driver *driver) { int idx, err = 0; int num = (int)(sizeof(kpd_attr_list) / sizeof(kpd_attr_list[0])); if (!driver) return -EINVAL; for (idx = 0; idx < num; idx++) driver_remove_file(driver, kpd_attr_list[idx]); return err; }
/* * test_create_file * make test call to create sysfs file for the * driver and if that call is successful then * make a call to remove the file */ static int test_create_file() { struct device_driver *drv = &test_driver; if (driver_create_file(drv, &driver_attr_new_id)) { printk("tbase: failed create sysfs file\n"); return 1; } else { printk("tbase: created sysfs file\n"); driver_remove_file(drv, &driver_attr_new_id); return 0; } }
static void altera_cvp_remove(struct pci_dev *pdev) { struct fpga_manager *mgr = pci_get_drvdata(pdev); struct altera_cvp_conf *conf = mgr->priv; u16 cmd; driver_remove_file(&altera_cvp_driver.driver, &driver_attr_chkcfg); fpga_mgr_unregister(&pdev->dev); pci_iounmap(pdev, conf->map); pci_release_region(pdev, CVP_BAR); pci_read_config_word(pdev, PCI_COMMAND, &cmd); cmd &= ~PCI_COMMAND_MEMORY; pci_write_config_word(pdev, PCI_COMMAND, cmd); }
static int lcdc_auo_panel_off(struct platform_device *pdev) { pr_debug("%s ++ entering\n", __func__); driver_remove_file(pdev->dev.driver, &driver_attr_lcm_id); panel_poweron(0); #ifdef CONFIG_MACH_Q8K_A1_EVT gpio_set_value(GPIO_BLPWM,0); //backlight power off #endif gpio_tlmm_config(GPIO_CFG(GPIO_PCLK, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE); gpio_tlmm_config(GPIO_CFG(GPIO_VSYNC, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE); gpio_tlmm_config(GPIO_CFG(GPIO_HSYNC, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE); gpio_tlmm_config(GPIO_CFG(GPIO_VDEN, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE); pr_debug("%s -- leaving\n", __func__); return 0; }
/*----------------------------------------------------------------------------*/ static int shf_delete_attr(struct device_driver *driver) { int idx ,err = 0; int num = (int)(sizeof(shf_attr_list)/sizeof(shf_attr_list[0])); if(driver == NULL) { return -EINVAL; } for(idx = 0; idx < num; idx++) { driver_remove_file(driver, shf_attr_list[idx]); } return err; }
/** * bus_remove_driver - delete driver from bus's knowledge. * @drv: driver. * * Detach the driver from the devices it controls, and remove * it from its bus's list of drivers. Finally, we drop the reference * to the bus we took in bus_add_driver(). */ void bus_remove_driver(struct device_driver *drv) { if (!drv->bus) return; remove_bind_files(drv); driver_remove_attrs(drv->bus, drv); driver_remove_file(drv, &driver_attr_uevent); klist_remove(&drv->p->knode_bus); pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name); driver_detach(drv); module_remove_driver(drv); kobject_put(&drv->p->kobj); bus_put(drv->bus); }
static void __exit hfc_module_exit(void) { printk(KERN_DEBUG "module_exit()\n"); #ifdef DEBUG_CODE driver_remove_file( &hfc_driver.driver, &driver_attr_debug_level); #endif pci_unregister_driver(&hfc_driver); ks_feature_unregister(hfc_octet_reverser_class); ks_feature_unregister(hfc_hdlc_deframer_class); ks_feature_unregister(hfc_hdlc_framer_class); hfc_msg(KERN_INFO, hfc_DRIVER_DESCR " unloaded\n"); }
static int yas537_delete_attr(struct device_driver *driver) { int ret = 0; int i = 0; int num = sizeof(yas537_attr_list)/sizeof(yas537_attr_list[0]); if(NULL == driver) { return -EINVAL; } for(i = 0; i < num; i++) { driver_remove_file(driver, yas537_attr_list[i]); } return ret; }
static int __init fpga_uinput_init(void) { int ret; struct resource *res; ret = driver_register(&fpga_uinput_driver); if (ret < 0) goto fail_driver_register; ret = driver_create_file(&fpga_uinput_driver, &driver_attr_fpga_uinput); if (ret < 0) goto fail_create_file; res = request_mem_region(UINPUT_BASE, UINPUT_SIZE, "fpga_uinput"); if (res == NULL) { ret = -EBUSY; goto fail_request_mem; } fpga_uinput_mem = ioremap(UINPUT_BASE, UINPUT_SIZE); if (fpga_uinput_mem == NULL) { ret = -EFAULT; goto fail_ioremap; } ret = request_irq(UINPUT_INT_NUM, fpga_uinput_interrupt, 0, "fpga_uinput", NULL); if (ret < 0) goto fail_request_irq; return 0; fail_request_irq: iounmap(fpga_uinput_mem); fail_ioremap: release_mem_region(UINPUT_BASE, UINPUT_SIZE); fail_request_mem: driver_remove_file(&fpga_uinput_driver, &driver_attr_fpga_uinput); fail_create_file: driver_unregister(&fpga_uinput_driver); fail_driver_register: return ret; }
static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv) { int error = 0; int i; if (bus->drv_attrs) { for (i = 0; attr_name(bus->drv_attrs[i]); i++) { error = driver_create_file(drv, &bus->drv_attrs[i]); if (error) goto err; } } done: return error; err: while (--i >= 0) driver_remove_file(drv, &bus->drv_attrs[i]); goto done; }
static void __exit bus_exit(void) { int i; for (i = 0; my_bus_attrs[i]; i++) bus_remove_file(&my_bus, my_bus_attrs[i]); for (i = 0; my_drv_attrs[i]; i++) driver_remove_file(&my_drv.drv, my_drv_attrs[i]); for (i = 0; my_dev_attrs[i]; i++) device_remove_file(&my_dev.dev, my_dev_attrs[i]); my_driver_unregister(&my_drv); my_device_unregister(&my_dev); bus_unregister(&my_bus); }
static int __devexit imx_3stack_audio_remove(struct platform_device *pdev) { struct snd_soc_machine *machine = platform_get_drvdata(pdev); struct snd_soc_codec *codec; struct snd_soc_pcm_link *pcm_link; gpio_free_irq(WM8903_IRQ_GPIO_PORT, WM8903_IRQ_GPIO_NUM, GPIO_LOW_PRIO); pcm_link = list_first_entry(&machine->active_list, struct snd_soc_pcm_link, active_list); codec = pcm_link->codec; codec->ops->io_remove(codec, machine); snd_soc_machine_free(machine); driver_remove_file(pdev->dev.driver, &driver_attr_headphone); kfree(machine); return 0; }
static void remove_bind_files(struct device_driver *drv) { driver_remove_file(drv, &driver_attr_bind); driver_remove_file(drv, &driver_attr_unbind); }
static int __devinit imx_3stack_sgtl5000_audio_probe(struct platform_device *pdev) { struct snd_soc_machine *machine; struct mxc_sgtl5000_platform_data *plat = pdev->dev.platform_data; struct snd_soc_pcm_link *audio; int ret; machine = kzalloc(sizeof(struct snd_soc_machine), GFP_KERNEL); if (machine == NULL) return -ENOMEM; platform_set_drvdata(pdev, machine); machine->owner = THIS_MODULE; machine->pdev = pdev; machine->name = "i.MX_3STACK"; machine->longname = "SGTL5000"; machine->ops = &machine_ops; /* register card */ ret = snd_soc_new_card(machine, 1, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { pr_err("%s: failed to create pcms\n", __func__); goto err; } /* SGTL5000 interface */ ret = -ENODEV; if (plat->src_port == 2) audio = snd_soc_pcm_link_new(machine, "imx_3stack-audio", &imx_3stack_pcm_ops, imx_pcm, sgtl5000_codec, sgtl5000_dai, imx_ssi_3); else audio = snd_soc_pcm_link_new(machine, "imx_3stack-audio", &imx_3stack_pcm_ops, imx_pcm, sgtl5000_codec, sgtl5000_dai, imx_ssi_1); if (audio == NULL) { pr_err("failed to create PCM link\n"); goto link_err; } ret = snd_soc_pcm_link_attach(audio); if (ret < 0) { pr_err("%s: failed to attach audio pcm\n", __func__); goto link_err; } ret = driver_create_file(pdev->dev.driver, &driver_attr_headphone); if (ret < 0) { pr_err("%s:failed to create driver_attr_headphone\n", __func__); goto sysfs_err; } return ret; sysfs_err: driver_remove_file(pdev->dev.driver, &driver_attr_headphone); link_err: snd_soc_machine_free(machine); err: kfree(machine); return ret; }
static void __exit scdriver_exit(void) { driver_remove_file(&scdriver, &driver_attr_version); driver_unregister(&scdriver); }
static void em8300_sysfs_preunregister_driver(void) { driver_remove_file(&em8300_driver.driver, &driver_attr_version); }
static int platform_probe(struct platform_device *pdev) { int ret_val; struct resource *r; int irq; struct clk *clk; unsigned long clk_rate; struct resource *demo_driver_mem_region; uint32_t io_result; uint32_t period_100ms; pr_info("platform_probe enter\n"); ret_val = -EBUSY; /* acquire the probe lock */ if (down_interruptible(&g_dev_probe_sem)) return -ERESTARTSYS; if (g_platform_probe_flag != 0) goto bad_exit_return; ret_val = -EINVAL; /* get our first memory resource */ r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (r == NULL) { pr_err("IORESOURCE_MEM, 0 does not exist\n"); goto bad_exit_return; } g_demo_driver_base_addr = r->start; g_demo_driver_size = resource_size(r); /* get our interrupt resource */ irq = platform_get_irq(pdev, 0); if (irq < 0) { pr_err("irq not available\n"); goto bad_exit_return; } g_demo_driver_irq = irq; /* get our clock resource */ clk = clk_get(&pdev->dev, NULL); if (IS_ERR(clk)) { pr_err("clk not available\n"); goto bad_exit_return; } else { clk_rate = clk_get_rate(clk); } g_demo_driver_clk_rate = clk_rate; ret_val = -EBUSY; /* reserve our memory region */ demo_driver_mem_region = request_mem_region(g_demo_driver_base_addr, g_demo_driver_size, "demo_driver_hw_region"); if (demo_driver_mem_region == NULL) { pr_err("request_mem_region failed: g_demo_driver_base_addr\n"); goto bad_exit_return; } /* ioremap our memory region */ g_ioremap_addr = ioremap(g_demo_driver_base_addr, g_demo_driver_size); if (g_ioremap_addr == NULL) { pr_err("ioremap failed: g_demo_driver_base_addr\n"); goto bad_exit_release_mem_region; } g_timer_base = g_ioremap_addr + TIMER_OFST; /* initialize our peripheral timer hardware */ io_result = ioread32(IOADDR_ALTERA_AVALON_TIMER_STATUS(g_timer_base)); io_result &= ALTERA_AVALON_TIMER_STATUS_TO_MSK | ALTERA_AVALON_TIMER_STATUS_RUN_MSK; if (io_result != 0) { pr_err("peripheral timer hardware, incorrect initial state"); goto bad_exit_iounmap; } period_100ms = (g_demo_driver_clk_rate / 10) - 1; iowrite32(period_100ms, IOADDR_ALTERA_AVALON_TIMER_PERIODL(g_timer_base)); iowrite32(period_100ms >> 16, IOADDR_ALTERA_AVALON_TIMER_PERIODH(g_timer_base)); /* register our interrupt handler */ spin_lock_init(&g_irq_lock); g_max_irq_delay = 0; g_min_irq_delay = 0xFFFFFFFF; ret_val = request_irq(g_demo_driver_irq, demo_driver_interrupt_handler, 0, the_platform_driver.driver.name, &the_platform_driver); if (ret_val) { pr_err("request_irq failed"); goto bad_exit_iounmap; } ret_val = -EBUSY; /* start our timer and enable our timer hardware interrupts */ iowrite32(ALTERA_AVALON_TIMER_CONTROL_ITO_MSK | ALTERA_AVALON_TIMER_CONTROL_CONT_MSK | ALTERA_AVALON_TIMER_CONTROL_START_MSK, IOADDR_ALTERA_AVALON_TIMER_CONTROL(g_timer_base)); io_result = ioread32(IOADDR_ALTERA_AVALON_TIMER_STATUS(g_timer_base)); io_result &= ALTERA_AVALON_TIMER_STATUS_RUN_MSK; if (io_result == 0) { /* stop our timer and disable our timer hardware interrupts */ iowrite32(ALTERA_AVALON_TIMER_CONTROL_STOP_MSK, IOADDR_ALTERA_AVALON_TIMER_CONTROL(g_timer_base)); pr_err("peripheral timer hardware, failed to start"); goto bad_exit_freeirq; } /* create the sysfs entries */ ret_val = driver_create_file(&the_platform_driver.driver, &driver_attr_irq_delays); if (ret_val != 0) { pr_err("failed to create irq_delays sysfs entry"); goto bad_exit_stop_timer; } ret_val = driver_create_file(&the_platform_driver.driver, &driver_attr_interval); if (ret_val != 0) { pr_err("failed to create interval sysfs entry"); goto bad_exit_remove_irq_delays; } g_platform_probe_flag = 1; up(&g_dev_probe_sem); pr_info("platform_probe exit\n"); return 0; bad_exit_remove_irq_delays: driver_remove_file(&the_platform_driver.driver, &driver_attr_irq_delays); bad_exit_stop_timer: iowrite32(ALTERA_AVALON_TIMER_CONTROL_STOP_MSK, IOADDR_ALTERA_AVALON_TIMER_CONTROL(g_timer_base)); /* ensure there is no pending IRQ */ do { io_result = ioread32(IOADDR_ALTERA_AVALON_TIMER_STATUS(g_timer_base)); io_result &= ALTERA_AVALON_TIMER_STATUS_TO_MSK; } while (io_result != 0); bad_exit_freeirq: free_irq(g_demo_driver_irq, &the_platform_driver); bad_exit_iounmap: iounmap(g_ioremap_addr); bad_exit_release_mem_region: release_mem_region(g_demo_driver_base_addr, g_demo_driver_size); bad_exit_return: up(&g_dev_probe_sem); pr_info("platform_probe bad_exit\n"); return ret_val; }