int show_mem_notifier_unregister(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&show_mem_notifier, nb); }
void unregister_memory_isolate_notifier(struct notifier_block *nb) { atomic_notifier_chain_unregister(&memory_isolate_chain, nb); }
int unregister_die_notifier(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&die_chain, nb); }
int unregister_keyboard_notifier(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb); }
/** * unregister_restart_handler - Unregister previously registered * restart handler * @nb: Hook to be unregistered * * Unregisters a previously registered restart handler function. * * Returns zero on success, or %-ENOENT on failure. */ int unregister_restart_handler(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&restart_handler_list, nb); }
int set_otg_notify(struct otg_notify *n) { int ret = 0; pr_info("%s\n",__func__); if (!u_notify) { ret = create_usb_notify(); if (ret) { pr_err("unable create_usb_notify\n"); goto err; } } if (u_notify->o_notify && n) { pr_err("error : already set o_notify\n"); goto err; } pr_info("registered otg_notify +\n"); if (!n) { pr_err("otg notify structure is null\n"); ret = -EFAULT; goto err1; } u_notify->o_notify = n; ATOMIC_INIT_NOTIFIER_HEAD(&u_notify->o_notify->otg_notifier); u_notify->otg_nb.notifier_call = otg_notifier_callback; ret = atomic_notifier_chain_register(&u_notify->o_notify->otg_notifier, &u_notify->otg_nb); if (ret < 0) { pr_err("atomic_notifier_chain_register failed\n"); goto err1; } BLOCKING_INIT_NOTIFIER_HEAD(&u_notify->o_notify->extra_notifier); u_notify->extra_nb.notifier_call = extra_notifier_callback; ret = blocking_notifier_chain_register (&u_notify->o_notify->extra_notifier, &u_notify->extra_nb); if (ret < 0) { pr_err("blocking_notifier_chain_register failed\n"); goto err2; } if (!n->unsupport_host) { u_notify->ndev.name = "usb_otg"; u_notify->ndev.set_booster = n->vbus_drive; ret = host_notify_dev_register(&u_notify->ndev); if (ret < 0) { pr_err("host_notify_dev_register is failed\n"); goto err3; } if (!n->vbus_drive) { pr_err("vbus_drive is null\n"); goto err4; } } if (gpio_is_valid(n->vbus_detect_gpio) || gpio_is_valid(n->redriver_en_gpio)) { ret = register_gpios(n); if (ret < 0) { pr_err("register_gpios is failed\n"); goto err4; } } if (n->is_wakelock) wake_lock_init(&u_notify->wlock, WAKE_LOCK_SUSPEND, "usb_notify"); if (n->booting_delay_sec) { INIT_DELAYED_WORK(&u_notify->b_delay.booting_work, reserve_state_check); schedule_delayed_work(&u_notify->b_delay.booting_work, n->booting_delay_sec*HZ); } register_usbdev_notify(); pr_info("registered otg_notify -\n"); return 0; err4: if (!n->unsupport_host) host_notify_dev_unregister(&u_notify->ndev); err3: blocking_notifier_chain_unregister(&u_notify->o_notify->extra_notifier, &u_notify->extra_nb); err2: atomic_notifier_chain_unregister(&u_notify->o_notify->otg_notifier, &u_notify->otg_nb); err1: u_notify->o_notify = NULL; err: return ret; }
static void __exit ec2dump_exit(void) { atomic_notifier_chain_unregister(&panic_notifier_list, &ec2dump_panic_notifier); printk("exited ec2dump...\n"); }
int unregister_netevent_notifier(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&netevent_notif_chain, nb); }
/** * nvec_unregister_notifier - Unregister a notifier with nvec * @nvec: A &struct nvec_chip * @nb: The notifier block to unregister * * Unregisters a notifier with @nvec. The notifier will be removed from the * atomic notifier chain. */ int nvec_unregister_notifier(struct nvec_chip *nvec, struct notifier_block *nb) { return atomic_notifier_chain_unregister(&nvec->notifier_list, nb); }
void vrf_notifier_unregister(struct notifier_block *n) { atomic_notifier_chain_unregister(&vrf_notifier, n); }
int topology_unregister_notifier(struct notifier_block *nb) { return atomic_notifier_chain_unregister( &topology_update_notifier_list, nb); }
static int hvfb_probe(struct hv_device *hdev, const struct hv_vmbus_device_id *dev_id) { struct fb_info *info; struct hvfb_par *par; int ret; info = framebuffer_alloc(sizeof(struct hvfb_par), &hdev->device); if (!info) { pr_err("No memory for framebuffer info\n"); return -ENOMEM; } par = info->par; par->info = info; par->fb_ready = false; init_completion(&par->wait); INIT_DELAYED_WORK(&par->dwork, hvfb_update_work); /* Connect to VSP */ hv_set_drvdata(hdev, info); ret = synthvid_connect_vsp(hdev); if (ret) { pr_err("Unable to connect to VSP\n"); goto error1; } ret = hvfb_getmem(info); if (ret) { pr_err("No memory for framebuffer\n"); goto error2; } hvfb_get_option(info); pr_info("Screen resolution: %dx%d, Color depth: %d\n", screen_width, screen_height, screen_depth); /* Set up fb_info */ info->flags = FBINFO_DEFAULT; info->var.xres_virtual = info->var.xres = screen_width; info->var.yres_virtual = info->var.yres = screen_height; info->var.bits_per_pixel = screen_depth; if (info->var.bits_per_pixel == 16) { info->var.red = (struct fb_bitfield){11, 5, 0}; info->var.green = (struct fb_bitfield){5, 6, 0}; info->var.blue = (struct fb_bitfield){0, 5, 0}; info->var.transp = (struct fb_bitfield){0, 0, 0}; } else { info->var.red = (struct fb_bitfield){16, 8, 0}; info->var.green = (struct fb_bitfield){8, 8, 0}; info->var.blue = (struct fb_bitfield){0, 8, 0}; info->var.transp = (struct fb_bitfield){24, 8, 0}; } info->var.activate = FB_ACTIVATE_NOW; info->var.height = -1; info->var.width = -1; info->var.vmode = FB_VMODE_NONINTERLACED; strcpy(info->fix.id, KBUILD_MODNAME); info->fix.type = FB_TYPE_PACKED_PIXELS; info->fix.visual = FB_VISUAL_TRUECOLOR; info->fix.line_length = screen_width * screen_depth / 8; info->fix.accel = FB_ACCEL_NONE; info->fbops = &hvfb_ops; info->pseudo_palette = par->pseudo_palette; /* Send config to host */ ret = synthvid_send_config(hdev); if (ret) goto error; ret = register_framebuffer(info); if (ret) { pr_err("Unable to register framebuffer\n"); goto error; } par->fb_ready = true; par->synchronous_fb = false; par->hvfb_panic_nb.notifier_call = hvfb_on_panic; atomic_notifier_chain_register(&panic_notifier_list, &par->hvfb_panic_nb); return 0; error: hvfb_putmem(info); error2: vmbus_close(hdev->channel); error1: cancel_delayed_work_sync(&par->dwork); hv_set_drvdata(hdev, NULL); framebuffer_release(info); return ret; } static int hvfb_remove(struct hv_device *hdev) { struct fb_info *info = hv_get_drvdata(hdev); struct hvfb_par *par = info->par; atomic_notifier_chain_unregister(&panic_notifier_list, &par->hvfb_panic_nb); par->update = false; par->fb_ready = false; unregister_framebuffer(info); cancel_delayed_work_sync(&par->dwork); vmbus_close(hdev->channel); hv_set_drvdata(hdev, NULL); hvfb_putmem(info); framebuffer_release(info); return 0; } static const struct pci_device_id pci_stub_id_table[] = { { .vendor = PCI_VENDOR_ID_MICROSOFT, .device = PCI_DEVICE_ID_HYPERV_VIDEO, }, { /* end of list */ } }; static const struct hv_vmbus_device_id id_table[] = { /* Synthetic Video Device GUID */ {HV_SYNTHVID_GUID}, {} }; MODULE_DEVICE_TABLE(pci, pci_stub_id_table); MODULE_DEVICE_TABLE(vmbus, id_table); static struct hv_driver hvfb_drv = { .name = KBUILD_MODNAME, .id_table = id_table, .probe = hvfb_probe, .remove = hvfb_remove, }; static int hvfb_pci_stub_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { return 0; } static void hvfb_pci_stub_remove(struct pci_dev *pdev) { } static struct pci_driver hvfb_pci_stub_driver = { .name = KBUILD_MODNAME, .id_table = pci_stub_id_table, .probe = hvfb_pci_stub_probe, .remove = hvfb_pci_stub_remove, }; static int __init hvfb_drv_init(void) { int ret; ret = vmbus_driver_register(&hvfb_drv); if (ret != 0) return ret; ret = pci_register_driver(&hvfb_pci_stub_driver); if (ret != 0) { vmbus_driver_unregister(&hvfb_drv); return ret; } return 0; } static void __exit hvfb_drv_exit(void) { pci_unregister_driver(&hvfb_pci_stub_driver); vmbus_driver_unregister(&hvfb_drv); } module_init(hvfb_drv_init); module_exit(hvfb_drv_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Microsoft Hyper-V Synthetic Video Frame Buffer Driver");
void libcfs_unregister_panic_notifier(void) { atomic_notifier_chain_unregister(&panic_notifier_list, &libcfs_panic_notifier); }
int task_free_unregister(struct notifier_block *n) { return atomic_notifier_chain_unregister(&task_free_notifier, n); }
int opal_message_notifier_unregister(enum OpalMessageType msg_type, struct notifier_block *nb) { return atomic_notifier_chain_unregister( &opal_msg_notifier_head[msg_type], nb); }
void idle_notifier_unregister(struct notifier_block *n) { atomic_notifier_chain_unregister(&idle_notifier, n); }
int unregister_inet6addr_notifier(struct notifier_block *nb) { return atomic_notifier_chain_unregister(&inet6addr_chain, nb); }