drm_dp_aux_bus.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright 2021 Google Inc.
  4 *
  5 * The DP AUX bus is used for devices that are connected over a DisplayPort
  6 * AUX bus. The device on the far side of the bus is referred to as an
  7 * endpoint in this code.
  8 *
  9 * There is only one device connected to the DP AUX bus: an eDP panel.
 10 * Though historically panels (even DP panels) have been modeled as simple
 11 * platform devices, putting them under the DP AUX bus allows the panel driver
 12 * to perform transactions on that bus.
 13 */
 14
 15#include <linux/export.h>
 16#include <linux/init.h>
 17#include <linux/kernel.h>
 18#include <linux/module.h>
 19#include <linux/of_device.h>
 20#include <linux/pm_domain.h>
 21#include <linux/pm_runtime.h>
 22
 23#include <drm/display/drm_dp_aux_bus.h>
 24#include <drm/display/drm_dp_helper.h>
 25
 26struct dp_aux_ep_device_with_data {
 27	struct dp_aux_ep_device aux_ep;
 28	int (*done_probing)(struct drm_dp_aux *aux);
 29};
 30
 31/**
 32 * dp_aux_ep_match() - The match function for the dp_aux_bus.
 33 * @dev: The device to match.
 34 * @drv: The driver to try to match against.
 35 *
 36 * At the moment, we just match on device tree.
 37 *
 38 * Return: True if this driver matches this device; false otherwise.
 39 */
 40static int dp_aux_ep_match(struct device *dev, const struct device_driver *drv)
 41{
 42	return !!of_match_device(drv->of_match_table, dev);
 43}
 44
 45/**
 46 * dp_aux_ep_probe() - The probe function for the dp_aux_bus.
 47 * @dev: The device to probe.
 48 *
 49 * Calls through to the endpoint driver probe.
 50 *
 51 * Return: 0 if no error or negative error code.
 52 */
 53static int dp_aux_ep_probe(struct device *dev)
 54{
 55	struct dp_aux_ep_driver *aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
 56	struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(dev);
 57	struct dp_aux_ep_device_with_data *aux_ep_with_data =
 58		container_of(aux_ep, struct dp_aux_ep_device_with_data, aux_ep);
 59	int ret;
 60
 61	ret = dev_pm_domain_attach(dev, PD_FLAG_ATTACH_POWER_ON);
 62	if (ret)
 63		return dev_err_probe(dev, ret, "Failed to attach to PM Domain\n");
 64
 65	ret = aux_ep_drv->probe(aux_ep);
 66	if (ret)
 67		goto err_attached;
 68
 69	if (aux_ep_with_data->done_probing) {
 70		ret = aux_ep_with_data->done_probing(aux_ep->aux);
 71		if (ret) {
 72			/*
 73			 * The done_probing() callback should not return
 74			 * -EPROBE_DEFER to us. If it does, we treat it as an
 75			 * error. Passing it on as-is would cause the _panel_
 76			 * to defer.
 77			 */
 78			if (ret == -EPROBE_DEFER) {
 79				dev_err(dev,
 80					"DP AUX done_probing() can't defer\n");
 81				ret = -EINVAL;
 82			}
 83			goto err_probed;
 84		}
 85	}
 86
 87	return 0;
 88err_probed:
 89	if (aux_ep_drv->remove)
 90		aux_ep_drv->remove(aux_ep);
 91err_attached:
 92	dev_pm_domain_detach(dev, true);
 93
 94	return ret;
 95}
 96
 97/**
 98 * dp_aux_ep_remove() - The remove function for the dp_aux_bus.
 99 * @dev: The device to remove.
100 *
101 * Calls through to the endpoint driver remove.
102 */
103static void dp_aux_ep_remove(struct device *dev)
104{
105	struct dp_aux_ep_driver *aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
106	struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(dev);
107
108	if (aux_ep_drv->remove)
109		aux_ep_drv->remove(aux_ep);
110	dev_pm_domain_detach(dev, true);
111}
112
113/**
114 * dp_aux_ep_shutdown() - The shutdown function for the dp_aux_bus.
115 * @dev: The device to shutdown.
116 *
117 * Calls through to the endpoint driver shutdown.
118 */
119static void dp_aux_ep_shutdown(struct device *dev)
120{
121	struct dp_aux_ep_driver *aux_ep_drv;
122
123	if (!dev->driver)
124		return;
125
126	aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
127	if (aux_ep_drv->shutdown)
128		aux_ep_drv->shutdown(to_dp_aux_ep_dev(dev));
129}
130
131static const struct bus_type dp_aux_bus_type = {
132	.name		= "dp-aux",
133	.match		= dp_aux_ep_match,
134	.probe		= dp_aux_ep_probe,
135	.remove		= dp_aux_ep_remove,
136	.shutdown	= dp_aux_ep_shutdown,
137};
138
139static ssize_t modalias_show(struct device *dev,
140			     struct device_attribute *attr, char *buf)
141{
142	return of_device_modalias(dev, buf, PAGE_SIZE);
143}
144static DEVICE_ATTR_RO(modalias);
145
146static struct attribute *dp_aux_ep_dev_attrs[] = {
147	&dev_attr_modalias.attr,
148	NULL,
149};
150ATTRIBUTE_GROUPS(dp_aux_ep_dev);
151
152/**
153 * dp_aux_ep_dev_release() - Free memory for the dp_aux_ep device
154 * @dev: The device to free.
155 */
156static void dp_aux_ep_dev_release(struct device *dev)
157{
158	struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(dev);
159	struct dp_aux_ep_device_with_data *aux_ep_with_data =
160		container_of(aux_ep, struct dp_aux_ep_device_with_data, aux_ep);
161
162	kfree(aux_ep_with_data);
163}
164
165static int dp_aux_ep_dev_modalias(const struct device *dev, struct kobj_uevent_env *env)
166{
167	return of_device_uevent_modalias(dev, env);
168}
169
170static struct device_type dp_aux_device_type_type = {
171	.groups		= dp_aux_ep_dev_groups,
172	.uevent		= dp_aux_ep_dev_modalias,
173	.release	= dp_aux_ep_dev_release,
174};
175
176/**
177 * of_dp_aux_ep_destroy() - Destroy an DP AUX endpoint device
178 * @dev: The device to destroy.
179 * @data: Not used
180 *
181 * This is just used as a callback by of_dp_aux_depopulate_bus() and
182 * is called for _all_ of the child devices of the device providing the AUX bus.
183 * We'll only act on those that are of type "dp_aux_bus_type".
184 *
185 * This function is effectively an inverse of what's in
186 * of_dp_aux_populate_bus(). NOTE: since we only populate one child
187 * then it's expected that only one device will match all the "if" tests in
188 * this function and get to the device_unregister().
189 *
190 * Return: 0 if no error or negative error code.
191 */
192static int of_dp_aux_ep_destroy(struct device *dev, void *data)
193{
194	struct device_node *np = dev->of_node;
195
196	if (dev->bus != &dp_aux_bus_type)
197		return 0;
198
199	if (!of_node_check_flag(np, OF_POPULATED))
200		return 0;
201
202	of_node_clear_flag(np, OF_POPULATED);
203	of_node_put(np);
204
205	device_unregister(dev);
206
207	return 0;
208}
209
210/**
211 * of_dp_aux_depopulate_bus() - Undo of_dp_aux_populate_bus
212 * @aux: The AUX channel whose device we want to depopulate
213 *
214 * This will destroy the device that was created
215 * by of_dp_aux_populate_bus().
216 */
217void of_dp_aux_depopulate_bus(struct drm_dp_aux *aux)
218{
219	device_for_each_child_reverse(aux->dev, NULL, of_dp_aux_ep_destroy);
220}
221EXPORT_SYMBOL_GPL(of_dp_aux_depopulate_bus);
222
223/**
224 * of_dp_aux_populate_bus() - Populate the endpoint device on the DP AUX
225 * @aux: The AUX channel whose device we want to populate. It is required that
226 *       drm_dp_aux_init() has already been called for this AUX channel.
227 * @done_probing: Callback functions to call after EP device finishes probing.
228 *                Will not be called if there are no EP devices and this
229 *                function will return -ENODEV.
230 *
231 * This will populate the device (expected to be an eDP panel) under the
232 * "aux-bus" node of the device providing the AUX channel (AKA aux->dev).
233 *
234 * When this function finishes, it is _possible_ (but not guaranteed) that
235 * our sub-device will have finished probing. It should be noted that if our
236 * sub-device returns -EPROBE_DEFER or is probing asynchronously for some
237 * reason that we will not return any error codes ourselves but our
238 * sub-device will _not_ have actually probed successfully yet.
239 *
240 * In many cases it's important for the caller of this function to be notified
241 * when our sub device finishes probing. Our sub device is expected to be an
242 * eDP panel and the caller is expected to be an eDP controller. The eDP
243 * controller needs to be able to get a reference to the panel when it finishes
244 * probing. For this reason the caller can pass in a function pointer that
245 * will be called when our sub-device finishes probing.
246 *
247 * If this function succeeds you should later make sure you call
248 * of_dp_aux_depopulate_bus() to undo it, or just use the devm version
249 * of this function.
250 *
251 * Return: 0 if no error or negative error code; returns -ENODEV if there are
252 *         no children. The done_probing() function won't be called in that
253 *         case.
254 */
255int of_dp_aux_populate_bus(struct drm_dp_aux *aux,
256			   int (*done_probing)(struct drm_dp_aux *aux))
257{
258	struct device_node *bus = NULL, *np = NULL;
259	struct dp_aux_ep_device *aux_ep;
260	struct dp_aux_ep_device_with_data *aux_ep_with_data;
261	int ret;
262
263	/* drm_dp_aux_init() should have been called already; warn if not */
264	WARN_ON_ONCE(!aux->ddc.algo);
265
266	if (!aux->dev->of_node)
267		return -ENODEV;
268	bus = of_get_child_by_name(aux->dev->of_node, "aux-bus");
269	if (!bus)
270		return -ENODEV;
271
272	np = of_get_next_available_child(bus, NULL);
273	of_node_put(bus);
274	if (!np)
275		return -ENODEV;
276
277	if (of_node_test_and_set_flag(np, OF_POPULATED)) {
278		dev_err(aux->dev, "DP AUX EP device already populated\n");
279		ret = -EINVAL;
280		goto err_did_get_np;
281	}
282
283	aux_ep_with_data = kzalloc(sizeof(*aux_ep_with_data), GFP_KERNEL);
284	if (!aux_ep_with_data) {
285		ret = -ENOMEM;
286		goto err_did_set_populated;
287	}
288
289	aux_ep_with_data->done_probing = done_probing;
290
291	aux_ep = &aux_ep_with_data->aux_ep;
292	aux_ep->aux = aux;
293	aux_ep->dev.parent = aux->dev;
294	aux_ep->dev.bus = &dp_aux_bus_type;
295	aux_ep->dev.type = &dp_aux_device_type_type;
296	device_set_node(&aux_ep->dev, of_fwnode_handle(of_node_get(np)));
297	dev_set_name(&aux_ep->dev, "aux-%s", dev_name(aux->dev));
298
299	ret = device_register(&aux_ep->dev);
300	if (ret) {
301		dev_err(aux->dev, "Failed to create AUX EP for %pOF: %d\n", np, ret);
302
303		/*
304		 * As per docs of device_register(), call this instead
305		 * of kfree() directly for error cases.
306		 */
307		put_device(&aux_ep->dev);
308
309		goto err_did_set_populated;
310	}
311
312	return 0;
313
314err_did_set_populated:
315	of_node_clear_flag(np, OF_POPULATED);
316
317err_did_get_np:
318	of_node_put(np);
319
320	return ret;
321}
322EXPORT_SYMBOL_GPL(of_dp_aux_populate_bus);
323
324static void of_dp_aux_depopulate_bus_void(void *data)
325{
326	of_dp_aux_depopulate_bus(data);
327}
328
329/**
330 * devm_of_dp_aux_populate_bus() - devm wrapper for of_dp_aux_populate_bus()
331 * @aux: The AUX channel whose device we want to populate
332 * @done_probing: Callback functions to call after EP device finishes probing.
333 *                Will not be called if there are no EP devices and this
334 *                function will return -ENODEV.
335 *
336 * Handles freeing w/ devm on the device "aux->dev".
337 *
338 * Return: 0 if no error or negative error code; returns -ENODEV if there are
339 *         no children. The done_probing() function won't be called in that
340 *         case.
341 */
342int devm_of_dp_aux_populate_bus(struct drm_dp_aux *aux,
343				int (*done_probing)(struct drm_dp_aux *aux))
344{
345	int ret;
346
347	ret = of_dp_aux_populate_bus(aux, done_probing);
348	if (ret)
349		return ret;
350
351	return devm_add_action_or_reset(aux->dev,
352					of_dp_aux_depopulate_bus_void, aux);
353}
354EXPORT_SYMBOL_GPL(devm_of_dp_aux_populate_bus);
355
356int __dp_aux_dp_driver_register(struct dp_aux_ep_driver *drv, struct module *owner)
357{
358	drv->driver.owner = owner;
359	drv->driver.bus = &dp_aux_bus_type;
360
361	return driver_register(&drv->driver);
362}
363EXPORT_SYMBOL_GPL(__dp_aux_dp_driver_register);
364
365void dp_aux_dp_driver_unregister(struct dp_aux_ep_driver *drv)
366{
367	driver_unregister(&drv->driver);
368}
369EXPORT_SYMBOL_GPL(dp_aux_dp_driver_unregister);
370
371static int __init dp_aux_bus_init(void)
372{
373	int ret;
374
375	ret = bus_register(&dp_aux_bus_type);
376	if (ret)
377		return ret;
378
379	return 0;
380}
381
382static void __exit dp_aux_bus_exit(void)
383{
384	bus_unregister(&dp_aux_bus_type);
385}
386
387subsys_initcall(dp_aux_bus_init);
388module_exit(dp_aux_bus_exit);
389
390MODULE_AUTHOR("Douglas Anderson <dianders@chromium.org>");
391MODULE_DESCRIPTION("DRM DisplayPort AUX bus");
392MODULE_LICENSE("GPL v2");