xref: /linux/drivers/cdx/cdx.c (revision 336b4dae6dfecc9aa53a3a68c71b9c1c1d466388)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * CDX bus driver.
4  *
5  * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
6  */
7 
8 /*
9  * Architecture Overview
10  * =====================
11  * CDX is a Hardware Architecture designed for AMD FPGA devices. It
12  * consists of sophisticated mechanism for interaction between FPGA,
13  * Firmware and the APUs (Application CPUs).
14  *
15  * Firmware resides on RPU (Realtime CPUs) which interacts with
16  * the FPGA program manager and the APUs. The RPU provides memory-mapped
17  * interface (RPU if) which is used to communicate with APUs.
18  *
19  * The diagram below shows an overview of the CDX architecture:
20  *
21  *          +--------------------------------------+
22  *          |    Application CPUs (APU)            |
23  *          |                                      |
24  *          |                    CDX device drivers|
25  *          |     Linux OS                |        |
26  *          |                        CDX bus       |
27  *          |                             |        |
28  *          |                     CDX controller   |
29  *          |                             |        |
30  *          +-----------------------------|--------+
31  *                                        | (discover, config,
32  *                                        |  reset, rescan)
33  *                                        |
34  *          +------------------------| RPU if |----+
35  *          |                             |        |
36  *          |                             V        |
37  *          |          Realtime CPUs (RPU)         |
38  *          |                                      |
39  *          +--------------------------------------+
40  *                                |
41  *          +---------------------|----------------+
42  *          |  FPGA               |                |
43  *          |      +-----------------------+       |
44  *          |      |           |           |       |
45  *          | +-------+    +-------+   +-------+   |
46  *          | | dev 1 |    | dev 2 |   | dev 3 |   |
47  *          | +-------+    +-------+   +-------+   |
48  *          +--------------------------------------+
49  *
50  * The RPU firmware extracts the device information from the loaded FPGA
51  * image and implements a mechanism that allows the APU drivers to
52  * enumerate such devices (device personality and resource details) via
53  * a dedicated communication channel. RPU mediates operations such as
54  * discover, reset and rescan of the FPGA devices for the APU. This is
55  * done using memory mapped interface provided by the RPU to APU.
56  */
57 
58 #include <linux/init.h>
59 #include <linux/irqdomain.h>
60 #include <linux/kernel.h>
61 #include <linux/of.h>
62 #include <linux/of_device.h>
63 #include <linux/of_platform.h>
64 #include <linux/platform_device.h>
65 #include <linux/slab.h>
66 #include <linux/mm.h>
67 #include <linux/idr.h>
68 #include <linux/cdx/cdx_bus.h>
69 #include <linux/iommu.h>
70 #include <linux/dma-map-ops.h>
71 #include <linux/debugfs.h>
72 #include "cdx.h"
73 
74 /* Default DMA mask for devices on a CDX bus */
75 #define CDX_DEFAULT_DMA_MASK	(~0ULL)
76 #define MAX_CDX_CONTROLLERS 16
77 
78 /* IDA for CDX controllers registered with the CDX bus */
79 static DEFINE_IDA(cdx_controller_ida);
80 /* Lock to protect controller ops */
81 static DEFINE_MUTEX(cdx_controller_lock);
82 /* Debugfs dir for cdx bus */
83 static struct dentry *cdx_debugfs_dir;
84 
85 static char *compat_node_name = "xlnx,versal-net-cdx";
86 
87 static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num);
88 
89 /**
90  * cdx_dev_reset - Reset a CDX device
91  * @dev: CDX device
92  *
93  * Return: -errno on failure, 0 on success.
94  */
cdx_dev_reset(struct device * dev)95 int cdx_dev_reset(struct device *dev)
96 {
97 	struct cdx_device *cdx_dev = to_cdx_device(dev);
98 	struct cdx_controller *cdx = cdx_dev->cdx;
99 	struct cdx_device_config dev_config = {0};
100 	struct cdx_driver *cdx_drv;
101 	int ret;
102 
103 	cdx_drv = to_cdx_driver(dev->driver);
104 	/* Notify driver that device is being reset */
105 	if (cdx_drv && cdx_drv->reset_prepare)
106 		cdx_drv->reset_prepare(cdx_dev);
107 
108 	dev_config.type = CDX_DEV_RESET_CONF;
109 	ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
110 				      cdx_dev->dev_num, &dev_config);
111 	if (ret)
112 		dev_err(dev, "cdx device reset failed\n");
113 
114 	/* Notify driver that device reset is complete */
115 	if (cdx_drv && cdx_drv->reset_done)
116 		cdx_drv->reset_done(cdx_dev);
117 
118 	return ret;
119 }
120 EXPORT_SYMBOL_GPL(cdx_dev_reset);
121 
122 /**
123  * reset_cdx_device - Reset a CDX device
124  * @dev: CDX device
125  * @data: This is always passed as NULL, and is not used in this API,
126  *    but is required here as the device_for_each_child() API expects
127  *    the passed function to have this as an argument.
128  *
129  * Return: -errno on failure, 0 on success.
130  */
reset_cdx_device(struct device * dev,void * data)131 static int reset_cdx_device(struct device *dev, void *data)
132 {
133 	return cdx_dev_reset(dev);
134 }
135 
136 /**
137  * cdx_unregister_device - Unregister a CDX device
138  * @dev: CDX device
139  * @data: This is always passed as NULL, and is not used in this API,
140  *	  but is required here as the bus_for_each_dev() API expects
141  *	  the passed function (cdx_unregister_device) to have this
142  *	  as an argument.
143  *
144  * Return: 0 on success.
145  */
cdx_unregister_device(struct device * dev,void * data)146 static int cdx_unregister_device(struct device *dev,
147 				 void *data)
148 {
149 	struct cdx_device *cdx_dev = to_cdx_device(dev);
150 	struct cdx_controller *cdx = cdx_dev->cdx;
151 
152 	if (cdx_dev->is_bus) {
153 		device_for_each_child(dev, NULL, cdx_unregister_device);
154 		if (cdx_dev->enabled && cdx->ops->bus_disable)
155 			cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
156 	} else {
157 		cdx_destroy_res_attr(cdx_dev, MAX_CDX_DEV_RESOURCES);
158 		debugfs_remove_recursive(cdx_dev->debugfs_dir);
159 		kfree(cdx_dev->driver_override);
160 		cdx_dev->driver_override = NULL;
161 	}
162 
163 	/*
164 	 * Do not free cdx_dev here as it would be freed in
165 	 * cdx_device_release() called from within put_device().
166 	 */
167 	device_del(&cdx_dev->dev);
168 	put_device(&cdx_dev->dev);
169 
170 	return 0;
171 }
172 
cdx_unregister_devices(struct bus_type * bus)173 static void cdx_unregister_devices(struct bus_type *bus)
174 {
175 	/* Reset all the devices attached to cdx bus */
176 	bus_for_each_dev(bus, NULL, NULL, cdx_unregister_device);
177 }
178 
179 /**
180  * cdx_match_one_device - Tell if a CDX device structure has a matching
181  *			  CDX device id structure
182  * @id: single CDX device id structure to match
183  * @dev: the CDX device structure to match against
184  *
185  * Return: matching cdx_device_id structure or NULL if there is no match.
186  */
187 static inline const struct cdx_device_id *
cdx_match_one_device(const struct cdx_device_id * id,const struct cdx_device * dev)188 cdx_match_one_device(const struct cdx_device_id *id,
189 		     const struct cdx_device *dev)
190 {
191 	/* Use vendor ID and device ID for matching */
192 	if ((id->vendor == CDX_ANY_ID || id->vendor == dev->vendor) &&
193 	    (id->device == CDX_ANY_ID || id->device == dev->device) &&
194 	    (id->subvendor == CDX_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
195 	    (id->subdevice == CDX_ANY_ID || id->subdevice == dev->subsystem_device) &&
196 	    !((id->class ^ dev->class) & id->class_mask))
197 		return id;
198 	return NULL;
199 }
200 
201 /**
202  * cdx_match_id - See if a CDX device matches a given cdx_id table
203  * @ids: array of CDX device ID structures to search in
204  * @dev: the CDX device structure to match against.
205  *
206  * Used by a driver to check whether a CDX device is in its list of
207  * supported devices. Returns the matching cdx_device_id structure or
208  * NULL if there is no match.
209  *
210  * Return: matching cdx_device_id structure or NULL if there is no match.
211  */
212 static inline const struct cdx_device_id *
cdx_match_id(const struct cdx_device_id * ids,struct cdx_device * dev)213 cdx_match_id(const struct cdx_device_id *ids, struct cdx_device *dev)
214 {
215 	if (ids) {
216 		while (ids->vendor || ids->device) {
217 			if (cdx_match_one_device(ids, dev))
218 				return ids;
219 			ids++;
220 		}
221 	}
222 	return NULL;
223 }
224 
cdx_set_master(struct cdx_device * cdx_dev)225 int cdx_set_master(struct cdx_device *cdx_dev)
226 {
227 	struct cdx_controller *cdx = cdx_dev->cdx;
228 	struct cdx_device_config dev_config;
229 	int ret = -EOPNOTSUPP;
230 
231 	dev_config.type = CDX_DEV_BUS_MASTER_CONF;
232 	dev_config.bus_master_enable = true;
233 	if (cdx->ops->dev_configure)
234 		ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
235 					      cdx_dev->dev_num, &dev_config);
236 
237 	return ret;
238 }
239 EXPORT_SYMBOL_GPL(cdx_set_master);
240 
cdx_clear_master(struct cdx_device * cdx_dev)241 int cdx_clear_master(struct cdx_device *cdx_dev)
242 {
243 	struct cdx_controller *cdx = cdx_dev->cdx;
244 	struct cdx_device_config dev_config;
245 	int ret = -EOPNOTSUPP;
246 
247 	dev_config.type = CDX_DEV_BUS_MASTER_CONF;
248 	dev_config.bus_master_enable = false;
249 	if (cdx->ops->dev_configure)
250 		ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
251 					      cdx_dev->dev_num, &dev_config);
252 
253 	return ret;
254 }
255 EXPORT_SYMBOL_GPL(cdx_clear_master);
256 
257 /**
258  * cdx_bus_match - device to driver matching callback
259  * @dev: the cdx device to match against
260  * @drv: the device driver to search for matching cdx device
261  * structures
262  *
263  * Return: true on success, false otherwise.
264  */
cdx_bus_match(struct device * dev,const struct device_driver * drv)265 static int cdx_bus_match(struct device *dev, const struct device_driver *drv)
266 {
267 	struct cdx_device *cdx_dev = to_cdx_device(dev);
268 	const struct cdx_driver *cdx_drv = to_cdx_driver(drv);
269 	const struct cdx_device_id *found_id = NULL;
270 	const struct cdx_device_id *ids;
271 
272 	if (cdx_dev->is_bus)
273 		return false;
274 
275 	ids = cdx_drv->match_id_table;
276 
277 	/* When driver_override is set, only bind to the matching driver */
278 	if (cdx_dev->driver_override && strcmp(cdx_dev->driver_override, drv->name))
279 		return false;
280 
281 	found_id = cdx_match_id(ids, cdx_dev);
282 	if (!found_id)
283 		return false;
284 
285 	do {
286 		/*
287 		 * In case override_only was set, enforce driver_override
288 		 * matching.
289 		 */
290 		if (!found_id->override_only)
291 			return true;
292 		if (cdx_dev->driver_override)
293 			return true;
294 
295 		ids = found_id + 1;
296 		found_id = cdx_match_id(ids, cdx_dev);
297 	} while (found_id);
298 
299 	return false;
300 }
301 
cdx_probe(struct device * dev)302 static int cdx_probe(struct device *dev)
303 {
304 	struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
305 	struct cdx_device *cdx_dev = to_cdx_device(dev);
306 	struct cdx_controller *cdx = cdx_dev->cdx;
307 	int error;
308 
309 	/*
310 	 * Setup MSI device data so that generic MSI alloc/free can
311 	 * be used by the device driver.
312 	 */
313 	if (cdx->msi_domain) {
314 		error = msi_setup_device_data(&cdx_dev->dev);
315 		if (error)
316 			return error;
317 	}
318 
319 	error = cdx_drv->probe(cdx_dev);
320 	if (error) {
321 		dev_err_probe(dev, error, "%s failed\n", __func__);
322 		return error;
323 	}
324 
325 	return 0;
326 }
327 
cdx_remove(struct device * dev)328 static void cdx_remove(struct device *dev)
329 {
330 	struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
331 	struct cdx_device *cdx_dev = to_cdx_device(dev);
332 
333 	if (cdx_drv && cdx_drv->remove)
334 		cdx_drv->remove(cdx_dev);
335 }
336 
cdx_shutdown(struct device * dev)337 static void cdx_shutdown(struct device *dev)
338 {
339 	struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
340 	struct cdx_device *cdx_dev = to_cdx_device(dev);
341 	struct cdx_controller *cdx = cdx_dev->cdx;
342 
343 	if (cdx_dev->is_bus && cdx_dev->enabled && cdx->ops->bus_disable)
344 		cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
345 	if (cdx_drv && cdx_drv->shutdown)
346 		cdx_drv->shutdown(cdx_dev);
347 }
348 
cdx_dma_configure(struct device * dev)349 static int cdx_dma_configure(struct device *dev)
350 {
351 	struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
352 	struct cdx_device *cdx_dev = to_cdx_device(dev);
353 	struct cdx_controller *cdx = cdx_dev->cdx;
354 	u32 input_id = cdx_dev->req_id;
355 	int ret;
356 
357 	ret = of_dma_configure_id(dev, cdx->dev->of_node, 0, &input_id);
358 	if (ret && ret != -EPROBE_DEFER) {
359 		dev_err(dev, "of_dma_configure_id() failed\n");
360 		return ret;
361 	}
362 
363 	/* @cdx_drv may not be valid when we're called from the IOMMU layer */
364 	if (!ret && dev->driver && !cdx_drv->driver_managed_dma) {
365 		ret = iommu_device_use_default_domain(dev);
366 		if (ret)
367 			arch_teardown_dma_ops(dev);
368 	}
369 
370 	return 0;
371 }
372 
cdx_dma_cleanup(struct device * dev)373 static void cdx_dma_cleanup(struct device *dev)
374 {
375 	struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
376 
377 	if (!cdx_drv->driver_managed_dma)
378 		iommu_device_unuse_default_domain(dev);
379 }
380 
381 /* show configuration fields */
382 #define cdx_config_attr(field, format_string)	\
383 static ssize_t	\
384 field##_show(struct device *dev, struct device_attribute *attr, char *buf)	\
385 {	\
386 	struct cdx_device *cdx_dev = to_cdx_device(dev);	\
387 	return sysfs_emit(buf, format_string, cdx_dev->field);	\
388 }	\
389 static DEVICE_ATTR_RO(field)
390 
391 cdx_config_attr(vendor, "0x%04x\n");
392 cdx_config_attr(device, "0x%04x\n");
393 cdx_config_attr(subsystem_vendor, "0x%04x\n");
394 cdx_config_attr(subsystem_device, "0x%04x\n");
395 cdx_config_attr(revision, "0x%02x\n");
396 cdx_config_attr(class, "0x%06x\n");
397 
remove_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)398 static ssize_t remove_store(struct device *dev,
399 			    struct device_attribute *attr,
400 			    const char *buf, size_t count)
401 {
402 	bool val;
403 
404 	if (kstrtobool(buf, &val) < 0)
405 		return -EINVAL;
406 
407 	if (!val)
408 		return -EINVAL;
409 
410 	if (device_remove_file_self(dev, attr)) {
411 		int ret;
412 
413 		ret = cdx_unregister_device(dev, NULL);
414 		if (ret)
415 			return ret;
416 	}
417 
418 	return count;
419 }
420 static DEVICE_ATTR_WO(remove);
421 
reset_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)422 static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
423 			   const char *buf, size_t count)
424 {
425 	struct cdx_device *cdx_dev = to_cdx_device(dev);
426 	bool val;
427 	int ret;
428 
429 	if (kstrtobool(buf, &val) < 0)
430 		return -EINVAL;
431 
432 	if (!val)
433 		return -EINVAL;
434 
435 	if (cdx_dev->is_bus)
436 		/* Reset all the devices attached to cdx bus */
437 		ret = device_for_each_child(dev, NULL, reset_cdx_device);
438 	else
439 		ret = cdx_dev_reset(dev);
440 
441 	return ret < 0 ? ret : count;
442 }
443 static DEVICE_ATTR_WO(reset);
444 
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)445 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
446 			     char *buf)
447 {
448 	struct cdx_device *cdx_dev = to_cdx_device(dev);
449 
450 	return sprintf(buf, "cdx:v%04Xd%04Xsv%04Xsd%04Xc%06X\n", cdx_dev->vendor,
451 			cdx_dev->device, cdx_dev->subsystem_vendor, cdx_dev->subsystem_device,
452 			cdx_dev->class);
453 }
454 static DEVICE_ATTR_RO(modalias);
455 
driver_override_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)456 static ssize_t driver_override_store(struct device *dev,
457 				     struct device_attribute *attr,
458 				     const char *buf, size_t count)
459 {
460 	struct cdx_device *cdx_dev = to_cdx_device(dev);
461 	int ret;
462 
463 	if (WARN_ON(dev->bus != &cdx_bus_type))
464 		return -EINVAL;
465 
466 	ret = driver_set_override(dev, &cdx_dev->driver_override, buf, count);
467 	if (ret)
468 		return ret;
469 
470 	return count;
471 }
472 
driver_override_show(struct device * dev,struct device_attribute * attr,char * buf)473 static ssize_t driver_override_show(struct device *dev,
474 				    struct device_attribute *attr, char *buf)
475 {
476 	struct cdx_device *cdx_dev = to_cdx_device(dev);
477 	ssize_t len;
478 
479 	device_lock(dev);
480 	len = sysfs_emit(buf, "%s\n", cdx_dev->driver_override);
481 	device_unlock(dev);
482 	return len;
483 }
484 static DEVICE_ATTR_RW(driver_override);
485 
enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)486 static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
487 			    const char *buf, size_t count)
488 {
489 	struct cdx_device *cdx_dev = to_cdx_device(dev);
490 	struct cdx_controller *cdx = cdx_dev->cdx;
491 	bool enable;
492 	int ret;
493 
494 	if (kstrtobool(buf, &enable) < 0)
495 		return -EINVAL;
496 
497 	if (enable == cdx_dev->enabled)
498 		return count;
499 
500 	if (enable && cdx->ops->bus_enable)
501 		ret = cdx->ops->bus_enable(cdx, cdx_dev->bus_num);
502 	else if (!enable && cdx->ops->bus_disable)
503 		ret = cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
504 	else
505 		ret = -EOPNOTSUPP;
506 
507 	if (!ret)
508 		cdx_dev->enabled = enable;
509 
510 	return ret < 0 ? ret : count;
511 }
512 
enable_show(struct device * dev,struct device_attribute * attr,char * buf)513 static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)
514 {
515 	struct cdx_device *cdx_dev = to_cdx_device(dev);
516 
517 	return sysfs_emit(buf, "%u\n", cdx_dev->enabled);
518 }
519 static DEVICE_ATTR_RW(enable);
520 
cdx_dev_attrs_are_visible(struct kobject * kobj,struct attribute * a,int n)521 static umode_t cdx_dev_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
522 {
523 	struct device *dev = kobj_to_dev(kobj);
524 	struct cdx_device *cdx_dev;
525 
526 	cdx_dev = to_cdx_device(dev);
527 	if (!cdx_dev->is_bus)
528 		return a->mode;
529 
530 	return 0;
531 }
532 
cdx_bus_attrs_are_visible(struct kobject * kobj,struct attribute * a,int n)533 static umode_t cdx_bus_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
534 {
535 	struct device *dev = kobj_to_dev(kobj);
536 	struct cdx_device *cdx_dev;
537 
538 	cdx_dev = to_cdx_device(dev);
539 	if (cdx_dev->is_bus)
540 		return a->mode;
541 
542 	return 0;
543 }
544 
545 static struct attribute *cdx_dev_attrs[] = {
546 	&dev_attr_remove.attr,
547 	&dev_attr_reset.attr,
548 	&dev_attr_vendor.attr,
549 	&dev_attr_device.attr,
550 	&dev_attr_subsystem_vendor.attr,
551 	&dev_attr_subsystem_device.attr,
552 	&dev_attr_class.attr,
553 	&dev_attr_revision.attr,
554 	&dev_attr_modalias.attr,
555 	&dev_attr_driver_override.attr,
556 	NULL,
557 };
558 
559 static const struct attribute_group cdx_dev_group = {
560 	.attrs = cdx_dev_attrs,
561 	.is_visible = cdx_dev_attrs_are_visible,
562 };
563 
564 static struct attribute *cdx_bus_dev_attrs[] = {
565 	&dev_attr_enable.attr,
566 	&dev_attr_reset.attr,
567 	NULL,
568 };
569 
570 static const struct attribute_group cdx_bus_dev_group = {
571 	.attrs = cdx_bus_dev_attrs,
572 	.is_visible = cdx_bus_attrs_are_visible,
573 };
574 
575 static const struct attribute_group *cdx_dev_groups[] = {
576 	&cdx_dev_group,
577 	&cdx_bus_dev_group,
578 	NULL,
579 };
580 
cdx_debug_resource_show(struct seq_file * s,void * data)581 static int cdx_debug_resource_show(struct seq_file *s, void *data)
582 {
583 	struct cdx_device *cdx_dev = s->private;
584 	int i;
585 
586 	for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
587 		struct resource *res =  &cdx_dev->res[i];
588 
589 		seq_printf(s, "%pr\n", res);
590 	}
591 
592 	return 0;
593 }
594 DEFINE_SHOW_ATTRIBUTE(cdx_debug_resource);
595 
cdx_device_debugfs_init(struct cdx_device * cdx_dev)596 static void cdx_device_debugfs_init(struct cdx_device *cdx_dev)
597 {
598 	cdx_dev->debugfs_dir = debugfs_create_dir(dev_name(&cdx_dev->dev), cdx_debugfs_dir);
599 	if (IS_ERR(cdx_dev->debugfs_dir))
600 		return;
601 
602 	debugfs_create_file("resource", 0444, cdx_dev->debugfs_dir, cdx_dev,
603 			    &cdx_debug_resource_fops);
604 }
605 
rescan_store(const struct bus_type * bus,const char * buf,size_t count)606 static ssize_t rescan_store(const struct bus_type *bus,
607 			    const char *buf, size_t count)
608 {
609 	struct cdx_controller *cdx;
610 	struct platform_device *pd;
611 	struct device_node *np;
612 	bool val;
613 
614 	if (kstrtobool(buf, &val) < 0)
615 		return -EINVAL;
616 
617 	if (!val)
618 		return -EINVAL;
619 
620 	mutex_lock(&cdx_controller_lock);
621 
622 	/* Unregister all the devices on the bus */
623 	cdx_unregister_devices(&cdx_bus_type);
624 
625 	/* Rescan all the devices */
626 	for_each_compatible_node(np, NULL, compat_node_name) {
627 		pd = of_find_device_by_node(np);
628 		if (!pd) {
629 			of_node_put(np);
630 			count = -EINVAL;
631 			goto unlock;
632 		}
633 
634 		cdx = platform_get_drvdata(pd);
635 		if (cdx && cdx->controller_registered && cdx->ops->scan)
636 			cdx->ops->scan(cdx);
637 
638 		put_device(&pd->dev);
639 	}
640 
641 unlock:
642 	mutex_unlock(&cdx_controller_lock);
643 
644 	return count;
645 }
646 static BUS_ATTR_WO(rescan);
647 
648 static struct attribute *cdx_bus_attrs[] = {
649 	&bus_attr_rescan.attr,
650 	NULL,
651 };
652 ATTRIBUTE_GROUPS(cdx_bus);
653 
654 struct bus_type cdx_bus_type = {
655 	.name		= "cdx",
656 	.match		= cdx_bus_match,
657 	.probe		= cdx_probe,
658 	.remove		= cdx_remove,
659 	.shutdown	= cdx_shutdown,
660 	.dma_configure	= cdx_dma_configure,
661 	.dma_cleanup	= cdx_dma_cleanup,
662 	.bus_groups	= cdx_bus_groups,
663 	.dev_groups	= cdx_dev_groups,
664 };
665 EXPORT_SYMBOL_GPL(cdx_bus_type);
666 
__cdx_driver_register(struct cdx_driver * cdx_driver,struct module * owner)667 int __cdx_driver_register(struct cdx_driver *cdx_driver,
668 			  struct module *owner)
669 {
670 	int error;
671 
672 	cdx_driver->driver.owner = owner;
673 	cdx_driver->driver.bus = &cdx_bus_type;
674 
675 	error = driver_register(&cdx_driver->driver);
676 	if (error) {
677 		pr_err("driver_register() failed for %s: %d\n",
678 		       cdx_driver->driver.name, error);
679 		return error;
680 	}
681 
682 	return 0;
683 }
684 EXPORT_SYMBOL_GPL(__cdx_driver_register);
685 
cdx_driver_unregister(struct cdx_driver * cdx_driver)686 void cdx_driver_unregister(struct cdx_driver *cdx_driver)
687 {
688 	driver_unregister(&cdx_driver->driver);
689 }
690 EXPORT_SYMBOL_GPL(cdx_driver_unregister);
691 
cdx_device_release(struct device * dev)692 static void cdx_device_release(struct device *dev)
693 {
694 	struct cdx_device *cdx_dev = to_cdx_device(dev);
695 
696 	kfree(cdx_dev);
697 }
698 
699 static const struct vm_operations_struct cdx_phys_vm_ops = {
700 #ifdef CONFIG_HAVE_IOREMAP_PROT
701 	.access = generic_access_phys,
702 #endif
703 };
704 
705 /**
706  * cdx_mmap_resource - map a CDX resource into user memory space
707  * @fp: File pointer. Not used in this function, but required where
708  *      this API is registered as a callback.
709  * @kobj: kobject for mapping
710  * @attr: struct bin_attribute for the file being mapped
711  * @vma: struct vm_area_struct passed into the mmap
712  *
713  * Use the regular CDX mapping routines to map a CDX resource into userspace.
714  *
715  * Return: true on success, false otherwise.
716  */
cdx_mmap_resource(struct file * fp,struct kobject * kobj,const struct bin_attribute * attr,struct vm_area_struct * vma)717 static int cdx_mmap_resource(struct file *fp, struct kobject *kobj,
718 			     const struct bin_attribute *attr,
719 			     struct vm_area_struct *vma)
720 {
721 	struct cdx_device *cdx_dev = to_cdx_device(kobj_to_dev(kobj));
722 	int num = (unsigned long)attr->private;
723 	struct resource *res;
724 	unsigned long size;
725 
726 	res = &cdx_dev->res[num];
727 	if (iomem_is_exclusive(res->start))
728 		return -EINVAL;
729 
730 	/* Make sure the caller is mapping a valid resource for this device */
731 	size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1;
732 	if (vma->vm_pgoff + vma_pages(vma) > size)
733 		return -EINVAL;
734 
735 	/*
736 	 * Map memory region and vm->vm_pgoff is expected to be an
737 	 * offset within that region.
738 	 */
739 	vma->vm_page_prot = pgprot_device(vma->vm_page_prot);
740 	vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT);
741 	vma->vm_ops = &cdx_phys_vm_ops;
742 	return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
743 				  vma->vm_end - vma->vm_start,
744 				  vma->vm_page_prot);
745 }
746 
cdx_destroy_res_attr(struct cdx_device * cdx_dev,int num)747 static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num)
748 {
749 	int i;
750 
751 	/* removing the bin attributes */
752 	for (i = 0; i < num; i++) {
753 		struct bin_attribute *res_attr;
754 
755 		res_attr = cdx_dev->res_attr[i];
756 		if (res_attr) {
757 			sysfs_remove_bin_file(&cdx_dev->dev.kobj, res_attr);
758 			kfree(res_attr);
759 		}
760 	}
761 }
762 
763 #define CDX_RES_ATTR_NAME_LEN	10
cdx_create_res_attr(struct cdx_device * cdx_dev,int num)764 static int cdx_create_res_attr(struct cdx_device *cdx_dev, int num)
765 {
766 	struct bin_attribute *res_attr;
767 	char *res_attr_name;
768 	int ret;
769 
770 	res_attr = kzalloc(sizeof(*res_attr) + CDX_RES_ATTR_NAME_LEN, GFP_ATOMIC);
771 	if (!res_attr)
772 		return -ENOMEM;
773 
774 	res_attr_name = (char *)(res_attr + 1);
775 
776 	sysfs_bin_attr_init(res_attr);
777 
778 	cdx_dev->res_attr[num] = res_attr;
779 	sprintf(res_attr_name, "resource%d", num);
780 
781 	res_attr->mmap = cdx_mmap_resource;
782 	res_attr->attr.name = res_attr_name;
783 	res_attr->attr.mode = 0600;
784 	res_attr->size = cdx_resource_len(cdx_dev, num);
785 	res_attr->private = (void *)(unsigned long)num;
786 	ret = sysfs_create_bin_file(&cdx_dev->dev.kobj, res_attr);
787 	if (ret)
788 		kfree(res_attr);
789 
790 	return ret;
791 }
792 
cdx_device_add(struct cdx_dev_params * dev_params)793 int cdx_device_add(struct cdx_dev_params *dev_params)
794 {
795 	struct cdx_controller *cdx = dev_params->cdx;
796 	struct cdx_device *cdx_dev;
797 	int ret, i;
798 
799 	cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL);
800 	if (!cdx_dev)
801 		return -ENOMEM;
802 
803 	/* Populate resource */
804 	memcpy(cdx_dev->res, dev_params->res, sizeof(struct resource) *
805 		dev_params->res_count);
806 	cdx_dev->res_count = dev_params->res_count;
807 
808 	/* Populate CDX dev params */
809 	cdx_dev->req_id = dev_params->req_id;
810 	cdx_dev->msi_dev_id = dev_params->msi_dev_id;
811 	cdx_dev->vendor = dev_params->vendor;
812 	cdx_dev->device = dev_params->device;
813 	cdx_dev->subsystem_vendor = dev_params->subsys_vendor;
814 	cdx_dev->subsystem_device = dev_params->subsys_device;
815 	cdx_dev->class = dev_params->class;
816 	cdx_dev->revision = dev_params->revision;
817 	cdx_dev->bus_num = dev_params->bus_num;
818 	cdx_dev->dev_num = dev_params->dev_num;
819 	cdx_dev->cdx = dev_params->cdx;
820 	cdx_dev->dma_mask = CDX_DEFAULT_DMA_MASK;
821 
822 	/* Initialize generic device */
823 	device_initialize(&cdx_dev->dev);
824 	cdx_dev->dev.parent = dev_params->parent;
825 	cdx_dev->dev.bus = &cdx_bus_type;
826 	cdx_dev->dev.dma_mask = &cdx_dev->dma_mask;
827 	cdx_dev->dev.release = cdx_device_release;
828 	cdx_dev->msi_write_pending = false;
829 	mutex_init(&cdx_dev->irqchip_lock);
830 
831 	/* Set Name */
832 	dev_set_name(&cdx_dev->dev, "cdx-%02x:%02x",
833 		     ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (cdx_dev->bus_num & CDX_BUS_NUM_MASK)),
834 		     cdx_dev->dev_num);
835 
836 	if (cdx->msi_domain) {
837 		cdx_dev->num_msi = dev_params->num_msi;
838 		dev_set_msi_domain(&cdx_dev->dev, cdx->msi_domain);
839 	}
840 
841 	ret = device_add(&cdx_dev->dev);
842 	if (ret) {
843 		dev_err(&cdx_dev->dev,
844 			"cdx device add failed: %d", ret);
845 		goto fail;
846 	}
847 
848 	/* Create resource<N> attributes */
849 	for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
850 		if (cdx_resource_flags(cdx_dev, i) & IORESOURCE_MEM) {
851 			/* skip empty resources */
852 			if (!cdx_resource_len(cdx_dev, i))
853 				continue;
854 
855 			ret = cdx_create_res_attr(cdx_dev, i);
856 			if (ret != 0) {
857 				dev_err(&cdx_dev->dev,
858 					"cdx device resource<%d> file creation failed: %d", i, ret);
859 				goto resource_create_fail;
860 			}
861 		}
862 	}
863 
864 	cdx_device_debugfs_init(cdx_dev);
865 
866 	return 0;
867 resource_create_fail:
868 	cdx_destroy_res_attr(cdx_dev, i);
869 	device_del(&cdx_dev->dev);
870 fail:
871 	/*
872 	 * Do not free cdx_dev here as it would be freed in
873 	 * cdx_device_release() called from put_device().
874 	 */
875 	put_device(&cdx_dev->dev);
876 
877 	return ret;
878 }
879 EXPORT_SYMBOL_NS_GPL(cdx_device_add, "CDX_BUS_CONTROLLER");
880 
cdx_bus_add(struct cdx_controller * cdx,u8 bus_num)881 struct device *cdx_bus_add(struct cdx_controller *cdx, u8 bus_num)
882 {
883 	struct cdx_device *cdx_dev;
884 	int ret;
885 
886 	cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL);
887 	if (!cdx_dev)
888 		return NULL;
889 
890 	device_initialize(&cdx_dev->dev);
891 	cdx_dev->cdx = cdx;
892 
893 	cdx_dev->dev.parent = cdx->dev;
894 	cdx_dev->dev.bus = &cdx_bus_type;
895 	cdx_dev->dev.release = cdx_device_release;
896 	cdx_dev->is_bus = true;
897 	cdx_dev->bus_num = bus_num;
898 
899 	dev_set_name(&cdx_dev->dev, "cdx-%02x",
900 		     ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (bus_num & CDX_BUS_NUM_MASK)));
901 
902 	ret = device_add(&cdx_dev->dev);
903 	if (ret) {
904 		dev_err(&cdx_dev->dev, "cdx bus device add failed: %d\n", ret);
905 		goto device_add_fail;
906 	}
907 
908 	if (cdx->ops->bus_enable) {
909 		ret = cdx->ops->bus_enable(cdx, bus_num);
910 		if (ret && ret != -EALREADY) {
911 			dev_err(cdx->dev, "cdx bus enable failed: %d\n", ret);
912 			goto bus_enable_fail;
913 		}
914 	}
915 
916 	cdx_dev->enabled = true;
917 	return &cdx_dev->dev;
918 
919 bus_enable_fail:
920 	device_del(&cdx_dev->dev);
921 device_add_fail:
922 	put_device(&cdx_dev->dev);
923 
924 	return NULL;
925 }
926 EXPORT_SYMBOL_NS_GPL(cdx_bus_add, "CDX_BUS_CONTROLLER");
927 
cdx_register_controller(struct cdx_controller * cdx)928 int cdx_register_controller(struct cdx_controller *cdx)
929 {
930 	int ret;
931 
932 	ret = ida_alloc_range(&cdx_controller_ida, 0,  MAX_CDX_CONTROLLERS - 1, GFP_KERNEL);
933 	if (ret < 0) {
934 		dev_err(cdx->dev,
935 			"No free index available. Maximum controllers already registered\n");
936 		cdx->id = (u8)MAX_CDX_CONTROLLERS;
937 		return ret;
938 	}
939 
940 	mutex_lock(&cdx_controller_lock);
941 	cdx->id = ret;
942 
943 	/* Scan all the devices */
944 	if (cdx->ops->scan)
945 		cdx->ops->scan(cdx);
946 	cdx->controller_registered = true;
947 	mutex_unlock(&cdx_controller_lock);
948 
949 	return 0;
950 }
951 EXPORT_SYMBOL_NS_GPL(cdx_register_controller, "CDX_BUS_CONTROLLER");
952 
cdx_unregister_controller(struct cdx_controller * cdx)953 void cdx_unregister_controller(struct cdx_controller *cdx)
954 {
955 	if (cdx->id >= MAX_CDX_CONTROLLERS)
956 		return;
957 
958 	mutex_lock(&cdx_controller_lock);
959 
960 	cdx->controller_registered = false;
961 	device_for_each_child(cdx->dev, NULL, cdx_unregister_device);
962 	ida_free(&cdx_controller_ida, cdx->id);
963 
964 	mutex_unlock(&cdx_controller_lock);
965 }
966 EXPORT_SYMBOL_NS_GPL(cdx_unregister_controller, "CDX_BUS_CONTROLLER");
967 
cdx_bus_init(void)968 static int __init cdx_bus_init(void)
969 {
970 	int ret;
971 
972 	ret = bus_register(&cdx_bus_type);
973 	if (!ret)
974 		cdx_debugfs_dir = debugfs_create_dir(cdx_bus_type.name, NULL);
975 
976 	return ret;
977 }
978 postcore_initcall(cdx_bus_init);
979