// SPDX-License-Identifier: MIT /* * Copyright (C) 2020 - 2021 Red Hat, Inc. * * Authors: * Hans de Goede */ #include #include #include #include #include #include #include #include #include #include "drm_internal.h" /** * DOC: overview * * This class allows non KMS drivers, from e.g. drivers/platform/x86 to * register a privacy-screen device, which the KMS drivers can then use * to implement the standard privacy-screen properties, see * :ref:`Standard Connector Properties`. * * KMS drivers using a privacy-screen class device are advised to use the * drm_connector_attach_privacy_screen_provider() and * drm_connector_update_privacy_screen() helpers for dealing with this. */ #define to_drm_privacy_screen(dev) \ container_of(dev, struct drm_privacy_screen, dev) static DEFINE_MUTEX(drm_privacy_screen_lookup_lock); static LIST_HEAD(drm_privacy_screen_lookup_list); static DEFINE_MUTEX(drm_privacy_screen_devs_lock); static LIST_HEAD(drm_privacy_screen_devs); /*** drm_privacy_screen_machine.h functions ***/ /** * drm_privacy_screen_lookup_add - add an entry to the static privacy-screen * lookup list * @lookup: lookup list entry to add * * Add an entry to the static privacy-screen lookup list. Note the * &struct list_head which is part of the &struct drm_privacy_screen_lookup * gets added to a list owned by the privacy-screen core. So the passed in * &struct drm_privacy_screen_lookup must not be free-ed until it is removed * from the lookup list by calling drm_privacy_screen_lookup_remove(). */ void drm_privacy_screen_lookup_add(struct drm_privacy_screen_lookup *lookup) { mutex_lock(&drm_privacy_screen_lookup_lock); list_add(&lookup->list, &drm_privacy_screen_lookup_list); mutex_unlock(&drm_privacy_screen_lookup_lock); } EXPORT_SYMBOL(drm_privacy_screen_lookup_add); /** * drm_privacy_screen_lookup_remove - remove an entry to the static * privacy-screen lookup list * @lookup: lookup list entry to remove * * Remove an entry previously added with drm_privacy_screen_lookup_add() * from the static privacy-screen lookup list. */ void drm_privacy_screen_lookup_remove(struct drm_privacy_screen_lookup *lookup) { mutex_lock(&drm_privacy_screen_lookup_lock); list_del(&lookup->list); mutex_unlock(&drm_privacy_screen_lookup_lock); } EXPORT_SYMBOL(drm_privacy_screen_lookup_remove); /*** drm_privacy_screen_consumer.h functions ***/ static struct drm_privacy_screen *drm_privacy_screen_get_by_name( const char *name) { struct drm_privacy_screen *priv; struct device *dev = NULL; mutex_lock(&drm_privacy_screen_devs_lock); list_for_each_entry(priv, &drm_privacy_screen_devs, list) { if (strcmp(dev_name(&priv->dev), name) == 0) { dev = get_device(&priv->dev); break; } } mutex_unlock(&drm_privacy_screen_devs_lock); return dev ? to_drm_privacy_screen(dev) : NULL; } /** * drm_privacy_screen_get - get a privacy-screen provider * @dev: consumer-device for which to get a privacy-screen provider * @con_id: (video)connector name for which to get a privacy-screen provider * * Get a privacy-screen provider for a privacy-screen attached to the * display described by the @dev and @con_id parameters. * * Return: * * A pointer to a &struct drm_privacy_screen on success. * * ERR_PTR(-ENODEV) if no matching privacy-screen is found * * ERR_PTR(-EPROBE_DEFER) if there is a matching privacy-screen, * but it has not been registered yet. */ struct drm_privacy_screen *drm_privacy_screen_get(struct device *dev, const char *con_id) { const char *dev_id = dev ? dev_name(dev) : NULL; struct drm_privacy_screen_lookup *l; struct drm_privacy_screen *priv; const char *provider = NULL; int match, best = -1; /* * For now we only support using a static lookup table, which is * populated by the drm_privacy_screen_arch_init() call. This should * be extended with device-tree / fw_node lookup when support is added * for device-tree using hardware with a privacy-screen. * * The lookup algorithm was shamelessly taken from the clock * framework: * * We do slightly fuzzy matching here: * An entry with a NULL ID is assumed to be a wildcard. * If an entry has a device ID, it must match * If an entry has a connection ID, it must match * Then we take the most specific entry - with the following order * of precedence: dev+con > dev only > con only. */ mutex_lock(&drm_privacy_screen_lookup_lock); list_for_each_entry(l, &drm_privacy_screen_lookup_list, list) { match = 0; if (l->dev_id) { if (!dev_id || strcmp(l->dev_id, dev_id)) continue; match += 2; } if (l->con_id) { if (!con_id || strcmp(l->con_id, con_id)) continue; match += 1; } if (match > best) { provider = l->provider; best = match; } } mutex_unlock(&drm_privacy_screen_lookup_lock); if (!provider) return ERR_PTR(-ENODEV); priv = drm_privacy_screen_get_by_name(provider); if (!priv) return ERR_PTR(-EPROBE_DEFER); return priv; } EXPORT_SYMBOL(drm_privacy_screen_get); /** * drm_privacy_screen_put - release a privacy-screen reference * @priv: privacy screen reference to release * * Release a privacy-screen provider reference gotten through * drm_privacy_screen_get(). May be called with a NULL or ERR_PTR, * in which case it is a no-op. */ void drm_privacy_screen_put(struct drm_privacy_screen *priv) { if (IS_ERR_OR_NULL(priv)) return; put_device(&priv->dev); } EXPORT_SYMBOL(drm_privacy_screen_put); /** * drm_privacy_screen_set_sw_state - set a privacy-screen's sw-state * @priv: privacy screen to set the sw-state for * @sw_state: new sw-state value to set * * Set the sw-state of a privacy screen. If the privacy-screen is not * in a locked hw-state, then the actual and hw-state of the privacy-screen * will be immediately updated to the new value. If the privacy-screen is * in a locked hw-state, then the new sw-state will be remembered as the * requested state to put the privacy-screen in when it becomes unlocked. * * Return: 0 on success, negative error code on failure. */ int drm_privacy_screen_set_sw_state(struct drm_privacy_screen *priv, enum drm_privacy_screen_status sw_state) { int ret = 0; mutex_lock(&priv->lock); if (!priv->ops) { ret = -ENODEV; goto out; } /* * As per the DRM connector properties documentation, setting the * sw_state while the hw_state is locked is allowed. In this case * it is a no-op other then storing the new sw_state so that it * can be honored when the state gets unlocked. * Also skip the set if the hw already is in the desired state. */ if (priv->hw_state >= PRIVACY_SCREEN_DISABLED_LOCKED || priv->hw_state == sw_state) { priv->sw_state = sw_state; goto out; } ret = priv->ops->set_sw_state(priv, sw_state); out: mutex_unlock(&priv->lock); return ret; } EXPORT_SYMBOL(drm_privacy_screen_set_sw_state); /** * drm_privacy_screen_get_state - get privacy-screen's current state * @priv: privacy screen to get the state for * @sw_state_ret: address where to store the privacy-screens current sw-state * @hw_state_ret: address where to store the privacy-screens current hw-state * * Get the current state of a privacy-screen, both the sw-state and the * hw-state. */ void drm_privacy_screen_get_state(struct drm_privacy_screen *priv, enum drm_privacy_screen_status *sw_state_ret, enum drm_privacy_screen_status *hw_state_ret) { mutex_lock(&priv->lock); *sw_state_ret = priv->sw_state; *hw_state_ret = priv->hw_state; mutex_unlock(&priv->lock); } EXPORT_SYMBOL(drm_privacy_screen_get_state); /** * drm_privacy_screen_register_notifier - register a notifier * @priv: Privacy screen to register the notifier with * @nb: Notifier-block for the notifier to register * * Register a notifier with the privacy-screen to be notified of changes made * to the privacy-screen state from outside of the privacy-screen class. * E.g. the state may be changed by the hardware itself in response to a * hotkey press. * * The notifier is called with no locks held. The new hw_state and sw_state * can be retrieved using the drm_privacy_screen_get_state() function. * A pointer to the drm_privacy_screen's struct is passed as the ``void *data`` * argument of the notifier_block's notifier_call. * * The notifier will NOT be called when changes are made through * drm_privacy_screen_set_sw_state(). It is only called for external changes. * * Return: 0 on success, negative error code on failure. */ int drm_privacy_screen_register_notifier(struct drm_privacy_screen *priv, struct notifier_block *nb) { return blocking_notifier_chain_register(&priv->notifier_head, nb); } EXPORT_SYMBOL(drm_privacy_screen_register_notifier); /** * drm_privacy_screen_unregister_notifier - unregister a notifier * @priv: Privacy screen to register the notifier with * @nb: Notifier-block for the notifier to register * * Unregister a notifier registered with drm_privacy_screen_register_notifier(). * * Return: 0 on success, negative error code on failure. */ int drm_privacy_screen_unregister_notifier(struct drm_privacy_screen *priv, struct notifier_block *nb) { return blocking_notifier_chain_unregister(&priv->notifier_head, nb); } EXPORT_SYMBOL(drm_privacy_screen_unregister_notifier); /*** drm_privacy_screen_driver.h functions ***/ static ssize_t sw_state_show(struct device *dev, struct device_attribute *attr, char *buf) { struct drm_privacy_screen *priv = to_drm_privacy_screen(dev); const char * const sw_state_names[] = { "Disabled", "Enabled", }; ssize_t ret; mutex_lock(&priv->lock); if (!priv->ops) ret = -ENODEV; else if (WARN_ON(priv->sw_state >= ARRAY_SIZE(sw_state_names))) ret = -ENXIO; else ret = sprintf(buf, "%s\n", sw_state_names[priv->sw_state]); mutex_unlock(&priv->lock); return ret; } /* * RO: Do not allow setting the sw_state through sysfs, this MUST be done * through the drm_properties on the drm_connector. */ static DEVICE_ATTR_RO(sw_state); static ssize_t hw_state_show(struct device *dev, struct device_attribute *attr, char *buf) { struct drm_privacy_screen *priv = to_drm_privacy_screen(dev); const char * const hw_state_names[] = { "Disabled", "Enabled", "Disabled, locked", "Enabled, locked", }; ssize_t ret; mutex_lock(&priv->lock); if (!priv->ops) ret = -ENODEV; else if (WARN_ON(priv->hw_state >= ARRAY_SIZE(hw_state_names))) ret = -ENXIO; else ret = sprintf(buf, "%s\n", hw_state_names[priv->hw_state]); mutex_unlock(&priv->lock); return ret; } static DEVICE_ATTR_RO(hw_state); static struct attribute *drm_privacy_screen_attrs[] = { &dev_attr_sw_state.attr, &dev_attr_hw_state.attr, NULL }; ATTRIBUTE_GROUPS(drm_privacy_screen); static struct device_type drm_privacy_screen_type = { .name = "privacy_screen", .groups = drm_privacy_screen_groups, }; static void drm_privacy_screen_device_release(struct device *dev) { struct drm_privacy_screen *priv = to_drm_privacy_screen(dev); kfree(priv); } /** * drm_privacy_screen_register - register a privacy-screen * @parent: parent-device for the privacy-screen * @ops: &struct drm_privacy_screen_ops pointer with ops for the privacy-screen * @data: Private data owned by the privacy screen provider * * Create and register a privacy-screen. * * Return: * * A pointer to the created privacy-screen on success. * * An ERR_PTR(errno) on failure. */ struct drm_privacy_screen *drm_privacy_screen_register( struct device *parent, const struct drm_privacy_screen_ops *ops, void *data) { struct drm_privacy_screen *priv; int ret; priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) return ERR_PTR(-ENOMEM); mutex_init(&priv->lock); BLOCKING_INIT_NOTIFIER_HEAD(&priv->notifier_head); priv->dev.class = drm_class; priv->dev.type = &drm_privacy_screen_type; priv->dev.parent = parent; priv->dev.release = drm_privacy_screen_device_release; dev_set_name(&priv->dev, "privacy_screen-%s", dev_name(parent)); priv->drvdata = data; priv->ops = ops; priv->ops->get_hw_state(priv); ret = device_register(&priv->dev); if (ret) { put_device(&priv->dev); return ERR_PTR(ret); } mutex_lock(&drm_privacy_screen_devs_lock); list_add(&priv->list, &drm_privacy_screen_devs); mutex_unlock(&drm_privacy_screen_devs_lock); return priv; } EXPORT_SYMBOL(drm_privacy_screen_register); /** * drm_privacy_screen_unregister - unregister privacy-screen * @priv: privacy-screen to unregister * * Unregister a privacy-screen registered with drm_privacy_screen_register(). * May be called with a NULL or ERR_PTR, in which case it is a no-op. */ void drm_privacy_screen_unregister(struct drm_privacy_screen *priv) { if (IS_ERR_OR_NULL(priv)) return; mutex_lock(&drm_privacy_screen_devs_lock); list_del(&priv->list); mutex_unlock(&drm_privacy_screen_devs_lock); mutex_lock(&priv->lock); priv->drvdata = NULL; priv->ops = NULL; mutex_unlock(&priv->lock); device_unregister(&priv->dev); } EXPORT_SYMBOL(drm_privacy_screen_unregister); /** * drm_privacy_screen_call_notifier_chain - notify consumers of state change * @priv: Privacy screen to register the notifier with * * A privacy-screen provider driver can call this functions upon external * changes to the privacy-screen state. E.g. the state may be changed by the * hardware itself in response to a hotkey press. * This function must be called without holding the privacy-screen lock. * the driver must update sw_state and hw_state to reflect the new state before * calling this function. * The expected behavior from the driver upon receiving an external state * change event is: 1. Take the lock; 2. Update sw_state and hw_state; * 3. Release the lock. 4. Call drm_privacy_screen_call_notifier_chain(). */ void drm_privacy_screen_call_notifier_chain(struct drm_privacy_screen *priv) { blocking_notifier_call_chain(&priv->notifier_head, 0, priv); } EXPORT_SYMBOL(drm_privacy_screen_call_notifier_chain); /option> main, development code repositoryroot
summaryrefslogtreecommitdiff
path: root/moz
AgeCommit message (Expand)AuthorFilesLines