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 */
79static DEFINE_IDA(cdx_controller_ida);
80/* Lock to protect controller ops */
81static DEFINE_MUTEX(cdx_controller_lock);
82/* Debugfs dir for cdx bus */
83static struct dentry *cdx_debugfs_dir;
84
85static char *compat_node_name = "xlnx,versal-net-cdx";
86
87static 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 */
95int 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}
120EXPORT_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 */
131static 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 */
146static 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, fn: 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(dentry: cdx_dev->debugfs_dir);
159 kfree(objp: 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(dev: &cdx_dev->dev);
168 put_device(dev: &cdx_dev->dev);
169
170 return 0;
171}
172
173static 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, fn: 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 */
187static inline const struct cdx_device_id *
188cdx_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 */
212static inline const struct cdx_device_id *
213cdx_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(id: ids, dev))
218 return ids;
219 ids++;
220 }
221 }
222 return NULL;
223}
224
225int 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}
239EXPORT_SYMBOL_GPL(cdx_set_master);
240
241int 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}
255EXPORT_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 */
265static int cdx_bus_match(struct device *dev, struct device_driver *drv)
266{
267 struct cdx_device *cdx_dev = to_cdx_device(dev);
268 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, dev: 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, dev: cdx_dev);
297 } while (found_id);
298
299 return false;
300}
301
302static 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(dev: &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, err: error, fmt: "%s failed\n", __func__);
322 return error;
323 }
324
325 return 0;
326}
327
328static 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
337static 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
342 if (cdx_drv && cdx_drv->shutdown)
343 cdx_drv->shutdown(cdx_dev);
344}
345
346static int cdx_dma_configure(struct device *dev)
347{
348 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
349 struct cdx_device *cdx_dev = to_cdx_device(dev);
350 struct cdx_controller *cdx = cdx_dev->cdx;
351 u32 input_id = cdx_dev->req_id;
352 int ret;
353
354 ret = of_dma_configure_id(dev, np: cdx->dev->of_node, force_dma: 0, id: &input_id);
355 if (ret && ret != -EPROBE_DEFER) {
356 dev_err(dev, "of_dma_configure_id() failed\n");
357 return ret;
358 }
359
360 if (!ret && !cdx_drv->driver_managed_dma) {
361 ret = iommu_device_use_default_domain(dev);
362 if (ret)
363 arch_teardown_dma_ops(dev);
364 }
365
366 return 0;
367}
368
369static void cdx_dma_cleanup(struct device *dev)
370{
371 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
372
373 if (!cdx_drv->driver_managed_dma)
374 iommu_device_unuse_default_domain(dev);
375}
376
377/* show configuration fields */
378#define cdx_config_attr(field, format_string) \
379static ssize_t \
380field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
381{ \
382 struct cdx_device *cdx_dev = to_cdx_device(dev); \
383 return sysfs_emit(buf, format_string, cdx_dev->field); \
384} \
385static DEVICE_ATTR_RO(field)
386
387cdx_config_attr(vendor, "0x%04x\n");
388cdx_config_attr(device, "0x%04x\n");
389cdx_config_attr(subsystem_vendor, "0x%04x\n");
390cdx_config_attr(subsystem_device, "0x%04x\n");
391cdx_config_attr(revision, "0x%02x\n");
392cdx_config_attr(class, "0x%06x\n");
393
394static ssize_t remove_store(struct device *dev,
395 struct device_attribute *attr,
396 const char *buf, size_t count)
397{
398 bool val;
399
400 if (kstrtobool(s: buf, res: &val) < 0)
401 return -EINVAL;
402
403 if (!val)
404 return -EINVAL;
405
406 if (device_remove_file_self(dev, attr)) {
407 int ret;
408
409 ret = cdx_unregister_device(dev, NULL);
410 if (ret)
411 return ret;
412 }
413
414 return count;
415}
416static DEVICE_ATTR_WO(remove);
417
418static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
419 const char *buf, size_t count)
420{
421 struct cdx_device *cdx_dev = to_cdx_device(dev);
422 bool val;
423 int ret;
424
425 if (kstrtobool(s: buf, res: &val) < 0)
426 return -EINVAL;
427
428 if (!val)
429 return -EINVAL;
430
431 if (cdx_dev->is_bus)
432 /* Reset all the devices attached to cdx bus */
433 ret = device_for_each_child(dev, NULL, fn: reset_cdx_device);
434 else
435 ret = cdx_dev_reset(dev);
436
437 return ret < 0 ? ret : count;
438}
439static DEVICE_ATTR_WO(reset);
440
441static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
442 char *buf)
443{
444 struct cdx_device *cdx_dev = to_cdx_device(dev);
445
446 return sprintf(buf, fmt: "cdx:v%04Xd%04Xsv%04Xsd%04Xc%06X\n", cdx_dev->vendor,
447 cdx_dev->device, cdx_dev->subsystem_vendor, cdx_dev->subsystem_device,
448 cdx_dev->class);
449}
450static DEVICE_ATTR_RO(modalias);
451
452static ssize_t driver_override_store(struct device *dev,
453 struct device_attribute *attr,
454 const char *buf, size_t count)
455{
456 struct cdx_device *cdx_dev = to_cdx_device(dev);
457 int ret;
458
459 if (WARN_ON(dev->bus != &cdx_bus_type))
460 return -EINVAL;
461
462 ret = driver_set_override(dev, override: &cdx_dev->driver_override, s: buf, len: count);
463 if (ret)
464 return ret;
465
466 return count;
467}
468
469static ssize_t driver_override_show(struct device *dev,
470 struct device_attribute *attr, char *buf)
471{
472 struct cdx_device *cdx_dev = to_cdx_device(dev);
473
474 return sysfs_emit(buf, fmt: "%s\n", cdx_dev->driver_override);
475}
476static DEVICE_ATTR_RW(driver_override);
477
478static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
479 const char *buf, size_t count)
480{
481 struct cdx_device *cdx_dev = to_cdx_device(dev);
482 struct cdx_controller *cdx = cdx_dev->cdx;
483 bool enable;
484 int ret;
485
486 if (kstrtobool(s: buf, res: &enable) < 0)
487 return -EINVAL;
488
489 if (enable == cdx_dev->enabled)
490 return count;
491
492 if (enable && cdx->ops->bus_enable)
493 ret = cdx->ops->bus_enable(cdx, cdx_dev->bus_num);
494 else if (!enable && cdx->ops->bus_disable)
495 ret = cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
496 else
497 ret = -EOPNOTSUPP;
498
499 if (!ret)
500 cdx_dev->enabled = enable;
501
502 return ret < 0 ? ret : count;
503}
504
505static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)
506{
507 struct cdx_device *cdx_dev = to_cdx_device(dev);
508
509 return sysfs_emit(buf, fmt: "%u\n", cdx_dev->enabled);
510}
511static DEVICE_ATTR_RW(enable);
512
513static umode_t cdx_dev_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
514{
515 struct device *dev = kobj_to_dev(kobj);
516 struct cdx_device *cdx_dev;
517
518 cdx_dev = to_cdx_device(dev);
519 if (!cdx_dev->is_bus)
520 return a->mode;
521
522 return 0;
523}
524
525static umode_t cdx_bus_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
526{
527 struct device *dev = kobj_to_dev(kobj);
528 struct cdx_device *cdx_dev;
529
530 cdx_dev = to_cdx_device(dev);
531 if (cdx_dev->is_bus)
532 return a->mode;
533
534 return 0;
535}
536
537static struct attribute *cdx_dev_attrs[] = {
538 &dev_attr_remove.attr,
539 &dev_attr_reset.attr,
540 &dev_attr_vendor.attr,
541 &dev_attr_device.attr,
542 &dev_attr_subsystem_vendor.attr,
543 &dev_attr_subsystem_device.attr,
544 &dev_attr_class.attr,
545 &dev_attr_revision.attr,
546 &dev_attr_modalias.attr,
547 &dev_attr_driver_override.attr,
548 NULL,
549};
550
551static const struct attribute_group cdx_dev_group = {
552 .attrs = cdx_dev_attrs,
553 .is_visible = cdx_dev_attrs_are_visible,
554};
555
556static struct attribute *cdx_bus_dev_attrs[] = {
557 &dev_attr_enable.attr,
558 &dev_attr_reset.attr,
559 NULL,
560};
561
562static const struct attribute_group cdx_bus_dev_group = {
563 .attrs = cdx_bus_dev_attrs,
564 .is_visible = cdx_bus_attrs_are_visible,
565};
566
567static const struct attribute_group *cdx_dev_groups[] = {
568 &cdx_dev_group,
569 &cdx_bus_dev_group,
570 NULL,
571};
572
573static int cdx_debug_resource_show(struct seq_file *s, void *data)
574{
575 struct cdx_device *cdx_dev = s->private;
576 int i;
577
578 for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
579 struct resource *res = &cdx_dev->res[i];
580
581 seq_printf(m: s, fmt: "%pr\n", res);
582 }
583
584 return 0;
585}
586DEFINE_SHOW_ATTRIBUTE(cdx_debug_resource);
587
588static void cdx_device_debugfs_init(struct cdx_device *cdx_dev)
589{
590 cdx_dev->debugfs_dir = debugfs_create_dir(name: dev_name(dev: &cdx_dev->dev), parent: cdx_debugfs_dir);
591 if (IS_ERR(ptr: cdx_dev->debugfs_dir))
592 return;
593
594 debugfs_create_file(name: "resource", mode: 0444, parent: cdx_dev->debugfs_dir, data: cdx_dev,
595 fops: &cdx_debug_resource_fops);
596}
597
598static ssize_t rescan_store(const struct bus_type *bus,
599 const char *buf, size_t count)
600{
601 struct cdx_controller *cdx;
602 struct platform_device *pd;
603 struct device_node *np;
604 bool val;
605
606 if (kstrtobool(s: buf, res: &val) < 0)
607 return -EINVAL;
608
609 if (!val)
610 return -EINVAL;
611
612 mutex_lock(&cdx_controller_lock);
613
614 /* Unregister all the devices on the bus */
615 cdx_unregister_devices(bus: &cdx_bus_type);
616
617 /* Rescan all the devices */
618 for_each_compatible_node(np, NULL, compat_node_name) {
619 pd = of_find_device_by_node(np);
620 if (!pd) {
621 of_node_put(node: np);
622 count = -EINVAL;
623 goto unlock;
624 }
625
626 cdx = platform_get_drvdata(pdev: pd);
627 if (cdx && cdx->controller_registered && cdx->ops->scan)
628 cdx->ops->scan(cdx);
629
630 put_device(dev: &pd->dev);
631 }
632
633unlock:
634 mutex_unlock(lock: &cdx_controller_lock);
635
636 return count;
637}
638static BUS_ATTR_WO(rescan);
639
640static struct attribute *cdx_bus_attrs[] = {
641 &bus_attr_rescan.attr,
642 NULL,
643};
644ATTRIBUTE_GROUPS(cdx_bus);
645
646struct bus_type cdx_bus_type = {
647 .name = "cdx",
648 .match = cdx_bus_match,
649 .probe = cdx_probe,
650 .remove = cdx_remove,
651 .shutdown = cdx_shutdown,
652 .dma_configure = cdx_dma_configure,
653 .dma_cleanup = cdx_dma_cleanup,
654 .bus_groups = cdx_bus_groups,
655 .dev_groups = cdx_dev_groups,
656};
657EXPORT_SYMBOL_GPL(cdx_bus_type);
658
659int __cdx_driver_register(struct cdx_driver *cdx_driver,
660 struct module *owner)
661{
662 int error;
663
664 cdx_driver->driver.owner = owner;
665 cdx_driver->driver.bus = &cdx_bus_type;
666
667 error = driver_register(drv: &cdx_driver->driver);
668 if (error) {
669 pr_err("driver_register() failed for %s: %d\n",
670 cdx_driver->driver.name, error);
671 return error;
672 }
673
674 return 0;
675}
676EXPORT_SYMBOL_GPL(__cdx_driver_register);
677
678void cdx_driver_unregister(struct cdx_driver *cdx_driver)
679{
680 driver_unregister(drv: &cdx_driver->driver);
681}
682EXPORT_SYMBOL_GPL(cdx_driver_unregister);
683
684static void cdx_device_release(struct device *dev)
685{
686 struct cdx_device *cdx_dev = to_cdx_device(dev);
687
688 kfree(objp: cdx_dev);
689}
690
691static const struct vm_operations_struct cdx_phys_vm_ops = {
692#ifdef CONFIG_HAVE_IOREMAP_PROT
693 .access = generic_access_phys,
694#endif
695};
696
697/**
698 * cdx_mmap_resource - map a CDX resource into user memory space
699 * @fp: File pointer. Not used in this function, but required where
700 * this API is registered as a callback.
701 * @kobj: kobject for mapping
702 * @attr: struct bin_attribute for the file being mapped
703 * @vma: struct vm_area_struct passed into the mmap
704 *
705 * Use the regular CDX mapping routines to map a CDX resource into userspace.
706 *
707 * Return: true on success, false otherwise.
708 */
709static int cdx_mmap_resource(struct file *fp, struct kobject *kobj,
710 struct bin_attribute *attr,
711 struct vm_area_struct *vma)
712{
713 struct cdx_device *cdx_dev = to_cdx_device(kobj_to_dev(kobj));
714 int num = (unsigned long)attr->private;
715 struct resource *res;
716 unsigned long size;
717
718 res = &cdx_dev->res[num];
719 if (iomem_is_exclusive(addr: res->start))
720 return -EINVAL;
721
722 /* Make sure the caller is mapping a valid resource for this device */
723 size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1;
724 if (vma->vm_pgoff + vma_pages(vma) > size)
725 return -EINVAL;
726
727 /*
728 * Map memory region and vm->vm_pgoff is expected to be an
729 * offset within that region.
730 */
731 vma->vm_page_prot = pgprot_device(vma->vm_page_prot);
732 vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT);
733 vma->vm_ops = &cdx_phys_vm_ops;
734 return io_remap_pfn_range(vma, addr: vma->vm_start, pfn: vma->vm_pgoff,
735 size: vma->vm_end - vma->vm_start,
736 prot: vma->vm_page_prot);
737}
738
739static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num)
740{
741 int i;
742
743 /* removing the bin attributes */
744 for (i = 0; i < num; i++) {
745 struct bin_attribute *res_attr;
746
747 res_attr = cdx_dev->res_attr[i];
748 if (res_attr) {
749 sysfs_remove_bin_file(kobj: &cdx_dev->dev.kobj, attr: res_attr);
750 kfree(objp: res_attr);
751 }
752 }
753}
754
755#define CDX_RES_ATTR_NAME_LEN 10
756static int cdx_create_res_attr(struct cdx_device *cdx_dev, int num)
757{
758 struct bin_attribute *res_attr;
759 char *res_attr_name;
760 int ret;
761
762 res_attr = kzalloc(size: sizeof(*res_attr) + CDX_RES_ATTR_NAME_LEN, GFP_ATOMIC);
763 if (!res_attr)
764 return -ENOMEM;
765
766 res_attr_name = (char *)(res_attr + 1);
767
768 sysfs_bin_attr_init(res_attr);
769
770 cdx_dev->res_attr[num] = res_attr;
771 sprintf(buf: res_attr_name, fmt: "resource%d", num);
772
773 res_attr->mmap = cdx_mmap_resource;
774 res_attr->attr.name = res_attr_name;
775 res_attr->attr.mode = 0600;
776 res_attr->size = cdx_resource_len(cdx_dev, num);
777 res_attr->private = (void *)(unsigned long)num;
778 ret = sysfs_create_bin_file(kobj: &cdx_dev->dev.kobj, attr: res_attr);
779 if (ret)
780 kfree(objp: res_attr);
781
782 return ret;
783}
784
785int cdx_device_add(struct cdx_dev_params *dev_params)
786{
787 struct cdx_controller *cdx = dev_params->cdx;
788 struct cdx_device *cdx_dev;
789 int ret, i;
790
791 cdx_dev = kzalloc(size: sizeof(*cdx_dev), GFP_KERNEL);
792 if (!cdx_dev)
793 return -ENOMEM;
794
795 /* Populate resource */
796 memcpy(cdx_dev->res, dev_params->res, sizeof(struct resource) *
797 dev_params->res_count);
798 cdx_dev->res_count = dev_params->res_count;
799
800 /* Populate CDX dev params */
801 cdx_dev->req_id = dev_params->req_id;
802 cdx_dev->msi_dev_id = dev_params->msi_dev_id;
803 cdx_dev->vendor = dev_params->vendor;
804 cdx_dev->device = dev_params->device;
805 cdx_dev->subsystem_vendor = dev_params->subsys_vendor;
806 cdx_dev->subsystem_device = dev_params->subsys_device;
807 cdx_dev->class = dev_params->class;
808 cdx_dev->revision = dev_params->revision;
809 cdx_dev->bus_num = dev_params->bus_num;
810 cdx_dev->dev_num = dev_params->dev_num;
811 cdx_dev->cdx = dev_params->cdx;
812 cdx_dev->dma_mask = CDX_DEFAULT_DMA_MASK;
813
814 /* Initialize generic device */
815 device_initialize(dev: &cdx_dev->dev);
816 cdx_dev->dev.parent = dev_params->parent;
817 cdx_dev->dev.bus = &cdx_bus_type;
818 cdx_dev->dev.dma_mask = &cdx_dev->dma_mask;
819 cdx_dev->dev.release = cdx_device_release;
820 cdx_dev->msi_write_pending = false;
821 mutex_init(&cdx_dev->irqchip_lock);
822
823 /* Set Name */
824 dev_set_name(dev: &cdx_dev->dev, name: "cdx-%02x:%02x",
825 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (cdx_dev->bus_num & CDX_BUS_NUM_MASK)),
826 cdx_dev->dev_num);
827
828 if (cdx->msi_domain) {
829 cdx_dev->num_msi = dev_params->num_msi;
830 dev_set_msi_domain(dev: &cdx_dev->dev, d: cdx->msi_domain);
831 }
832
833 ret = device_add(dev: &cdx_dev->dev);
834 if (ret) {
835 dev_err(&cdx_dev->dev,
836 "cdx device add failed: %d", ret);
837 goto fail;
838 }
839
840 /* Create resource<N> attributes */
841 for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
842 if (cdx_resource_flags(cdx_dev, i) & IORESOURCE_MEM) {
843 /* skip empty resources */
844 if (!cdx_resource_len(cdx_dev, i))
845 continue;
846
847 ret = cdx_create_res_attr(cdx_dev, num: i);
848 if (ret != 0) {
849 dev_err(&cdx_dev->dev,
850 "cdx device resource<%d> file creation failed: %d", i, ret);
851 goto resource_create_fail;
852 }
853 }
854 }
855
856 cdx_device_debugfs_init(cdx_dev);
857
858 return 0;
859resource_create_fail:
860 cdx_destroy_res_attr(cdx_dev, num: i);
861 device_del(dev: &cdx_dev->dev);
862fail:
863 /*
864 * Do not free cdx_dev here as it would be freed in
865 * cdx_device_release() called from put_device().
866 */
867 put_device(dev: &cdx_dev->dev);
868
869 return ret;
870}
871EXPORT_SYMBOL_NS_GPL(cdx_device_add, CDX_BUS_CONTROLLER);
872
873struct device *cdx_bus_add(struct cdx_controller *cdx, u8 bus_num)
874{
875 struct cdx_device *cdx_dev;
876 int ret;
877
878 cdx_dev = kzalloc(size: sizeof(*cdx_dev), GFP_KERNEL);
879 if (!cdx_dev)
880 return NULL;
881
882 device_initialize(dev: &cdx_dev->dev);
883 cdx_dev->cdx = cdx;
884
885 cdx_dev->dev.parent = cdx->dev;
886 cdx_dev->dev.bus = &cdx_bus_type;
887 cdx_dev->dev.release = cdx_device_release;
888 cdx_dev->is_bus = true;
889 cdx_dev->bus_num = bus_num;
890
891 dev_set_name(dev: &cdx_dev->dev, name: "cdx-%02x",
892 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (bus_num & CDX_BUS_NUM_MASK)));
893
894 ret = device_add(dev: &cdx_dev->dev);
895 if (ret) {
896 dev_err(&cdx_dev->dev, "cdx bus device add failed: %d\n", ret);
897 goto device_add_fail;
898 }
899
900 if (cdx->ops->bus_enable) {
901 ret = cdx->ops->bus_enable(cdx, bus_num);
902 if (ret && ret != -EALREADY) {
903 dev_err(cdx->dev, "cdx bus enable failed: %d\n", ret);
904 goto bus_enable_fail;
905 }
906 }
907
908 cdx_dev->enabled = true;
909 return &cdx_dev->dev;
910
911bus_enable_fail:
912 device_del(dev: &cdx_dev->dev);
913device_add_fail:
914 put_device(dev: &cdx_dev->dev);
915
916 return NULL;
917}
918EXPORT_SYMBOL_NS_GPL(cdx_bus_add, CDX_BUS_CONTROLLER);
919
920int cdx_register_controller(struct cdx_controller *cdx)
921{
922 int ret;
923
924 ret = ida_alloc_range(&cdx_controller_ida, min: 0, MAX_CDX_CONTROLLERS - 1, GFP_KERNEL);
925 if (ret < 0) {
926 dev_err(cdx->dev,
927 "No free index available. Maximum controllers already registered\n");
928 cdx->id = (u8)MAX_CDX_CONTROLLERS;
929 return ret;
930 }
931
932 mutex_lock(&cdx_controller_lock);
933 cdx->id = ret;
934
935 /* Scan all the devices */
936 if (cdx->ops->scan)
937 cdx->ops->scan(cdx);
938 cdx->controller_registered = true;
939 mutex_unlock(lock: &cdx_controller_lock);
940
941 return 0;
942}
943EXPORT_SYMBOL_NS_GPL(cdx_register_controller, CDX_BUS_CONTROLLER);
944
945void cdx_unregister_controller(struct cdx_controller *cdx)
946{
947 if (cdx->id >= MAX_CDX_CONTROLLERS)
948 return;
949
950 mutex_lock(&cdx_controller_lock);
951
952 cdx->controller_registered = false;
953 device_for_each_child(dev: cdx->dev, NULL, fn: cdx_unregister_device);
954 ida_free(&cdx_controller_ida, id: cdx->id);
955
956 mutex_unlock(lock: &cdx_controller_lock);
957}
958EXPORT_SYMBOL_NS_GPL(cdx_unregister_controller, CDX_BUS_CONTROLLER);
959
960static int __init cdx_bus_init(void)
961{
962 int ret;
963
964 ret = bus_register(bus: &cdx_bus_type);
965 if (!ret)
966 cdx_debugfs_dir = debugfs_create_dir(name: cdx_bus_type.name, NULL);
967
968 return ret;
969}
970postcore_initcall(cdx_bus_init);
971

source code of linux/drivers/cdx/cdx.c