Lines Matching refs:dev
72 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each
76 * Minors can be accessed via dev->$minor_name. This pointer is either
83 static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
88 return &dev->primary;
90 return &dev->render;
96 static void drm_minor_alloc_release(struct drm_device *dev, void *data)
101 WARN_ON(dev != minor->dev);
110 static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
116 minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL);
121 minor->dev = dev;
138 r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);
146 *drm_minor_get_slot(dev, type) = minor;
150 static int drm_minor_register(struct drm_device *dev, unsigned int type)
158 minor = *drm_minor_get_slot(dev, type);
185 static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
190 minor = *drm_minor_get_slot(dev, type);
210 * minor->dev pointer will stay valid! However, the device may get unplugged and
221 drm_dev_get(minor->dev);
226 } else if (drm_dev_is_unplugged(minor->dev)) {
227 drm_dev_put(minor->dev);
236 drm_dev_put(minor->dev);
297 * priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver,
311 * priv->pclk = devm_clk_get(dev, "PCLK");
347 * static int __maybe_unused driver_pm_suspend(struct device *dev)
349 * return drm_mode_config_helper_suspend(dev_get_drvdata(dev));
352 * static int __maybe_unused driver_pm_resume(struct device *dev)
354 * drm_mode_config_helper_resume(dev_get_drvdata(dev));
386 * @dev: DRM device
398 void drm_put_dev(struct drm_device *dev)
402 if (!dev) {
403 DRM_ERROR("cleanup called no dev\n");
407 drm_dev_unregister(dev);
408 drm_dev_put(dev);
414 * @dev: DRM device
424 bool drm_dev_enter(struct drm_device *dev, int *idx)
428 if (dev->unplugged) {
452 * @dev: DRM device
458 * called while there are still open users of @dev.
460 void drm_dev_unplug(struct drm_device *dev)
468 dev->unplugged = true;
471 drm_dev_unregister(dev);
559 static void drm_dev_init_release(struct drm_device *dev, void *res)
561 drm_legacy_ctxbitmap_cleanup(dev);
562 drm_legacy_remove_map_hash(dev);
563 drm_fs_inode_free(dev->anon_inode);
565 put_device(dev->dev);
568 dev->dev = NULL;
569 mutex_destroy(&dev->master_mutex);
570 mutex_destroy(&dev->clientlist_mutex);
571 mutex_destroy(&dev->filelist_mutex);
572 mutex_destroy(&dev->struct_mutex);
573 drm_legacy_destroy_members(dev);
576 static int drm_dev_init(struct drm_device *dev,
591 kref_init(&dev->ref);
592 dev->dev = get_device(parent);
593 dev->driver = driver;
595 INIT_LIST_HEAD(&dev->managed.resources);
596 spin_lock_init(&dev->managed.lock);
599 dev->driver_features = ~0u;
601 drm_legacy_init_members(dev);
602 INIT_LIST_HEAD(&dev->filelist);
603 INIT_LIST_HEAD(&dev->filelist_internal);
604 INIT_LIST_HEAD(&dev->clientlist);
605 INIT_LIST_HEAD(&dev->vblank_event_list);
607 spin_lock_init(&dev->event_lock);
608 mutex_init(&dev->struct_mutex);
609 mutex_init(&dev->filelist_mutex);
610 mutex_init(&dev->clientlist_mutex);
611 mutex_init(&dev->master_mutex);
613 ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL);
624 dev->anon_inode = inode;
626 if (drm_core_check_feature(dev, DRIVER_RENDER)) {
627 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
632 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
636 ret = drm_legacy_create_map_hash(dev);
640 drm_legacy_ctxbitmap_init(dev);
642 if (drm_core_check_feature(dev, DRIVER_GEM)) {
643 ret = drm_gem_init(dev);
650 ret = drm_dev_set_unique(dev, dev_name(parent));
657 drm_managed_release(dev);
668 struct drm_device *dev,
673 ret = drm_dev_init(dev, driver, parent);
677 ret = devm_add_action(parent, devm_drm_dev_init_release, dev);
679 devm_drm_dev_init_release(dev);
722 struct drm_device *dev;
725 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
726 if (!dev)
729 ret = drm_dev_init(dev, driver, parent);
731 kfree(dev);
735 drmm_add_final_kfree(dev, dev);
737 return dev;
743 struct drm_device *dev = container_of(ref, struct drm_device, ref);
745 if (dev->driver->release)
746 dev->driver->release(dev);
748 drm_managed_release(dev);
750 kfree(dev->managed.final_kfree);
755 * @dev: device to take reference of or NULL
757 * This increases the ref-count of @dev by one. You *must* already own a
765 void drm_dev_get(struct drm_device *dev)
767 if (dev)
768 kref_get(&dev->ref);
774 * @dev: device to drop reference of or NULL
776 * This decreases the ref-count of @dev by one. The device is destroyed if the
779 void drm_dev_put(struct drm_device *dev)
781 if (dev)
782 kref_put(&dev->ref, drm_dev_release);
786 static int create_compat_control_link(struct drm_device *dev)
792 if (!drm_core_check_feature(dev, DRIVER_MODESET))
795 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
821 static void remove_compat_control_link(struct drm_device *dev)
826 if (!drm_core_check_feature(dev, DRIVER_MODESET))
829 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
844 * @dev: Device to register
847 * Register the DRM device @dev with the system, advertise device to user-space
848 * and start normal device operation. @dev must be initialized via drm_dev_init()
862 int drm_dev_register(struct drm_device *dev, unsigned long flags)
864 struct drm_driver *driver = dev->driver;
868 drm_mode_config_validate(dev);
870 WARN_ON(!dev->managed.final_kfree);
872 if (drm_dev_needs_global_mutex(dev))
875 ret = drm_minor_register(dev, DRM_MINOR_RENDER);
879 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
883 ret = create_compat_control_link(dev);
887 dev->registered = true;
889 if (dev->driver->load) {
890 ret = dev->driver->load(dev, flags);
895 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
896 ret = drm_modeset_register_all(dev);
906 dev->dev ? dev_name(dev->dev) : "virtual device",
907 dev->primary->index);
912 if (dev->driver->unload)
913 dev->driver->unload(dev);
915 remove_compat_control_link(dev);
916 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
917 drm_minor_unregister(dev, DRM_MINOR_RENDER);
919 if (drm_dev_needs_global_mutex(dev))
927 * @dev: Device to unregister
934 * which can be called while there are still open users of @dev.
939 void drm_dev_unregister(struct drm_device *dev)
941 if (drm_core_check_feature(dev, DRIVER_LEGACY))
942 drm_lastclose(dev);
944 dev->registered = false;
946 drm_client_dev_unregister(dev);
948 if (drm_core_check_feature(dev, DRIVER_MODESET))
949 drm_modeset_unregister_all(dev);
951 if (dev->driver->unload)
952 dev->driver->unload(dev);
954 if (dev->agp)
955 drm_pci_agp_destroy(dev);
957 drm_legacy_rmmaps(dev);
959 remove_compat_control_link(dev);
960 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
961 drm_minor_unregister(dev, DRM_MINOR_RENDER);
967 * @dev: device of which to set the unique name
976 int drm_dev_set_unique(struct drm_device *dev, const char *name)
978 drmm_kfree(dev, dev->unique);
979 dev->unique = drmm_kstrdup(dev, name, GFP_KERNEL);
981 return dev->unique ? 0 : -ENOMEM;
998 * Furthermore, the DRM core provides dynamic char-dev lookups. For each
1000 * core. DRM core takes care of major-number management and char-dev
1017 new_fops = fops_get(minor->dev->driver->fops);