1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Freescale Management Complex (MC) bus driver
4  *
5  * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
6  * Copyright 2019-2020 NXP
7  * Author: German Rivera <German.Rivera@freescale.com>
8  *
9  */
10 
11 #define pr_fmt(fmt) "fsl-mc: " fmt
12 
13 #include <linux/module.h>
14 #include <linux/of_device.h>
15 #include <linux/of_address.h>
16 #include <linux/ioport.h>
17 #include <linux/slab.h>
18 #include <linux/limits.h>
19 #include <linux/bitops.h>
20 #include <linux/dma-mapping.h>
21 #include <linux/acpi.h>
22 #include <linux/iommu.h>
23 #include <linux/dma-map-ops.h>
24 
25 #include "fsl-mc-private.h"
26 
27 /*
28  * Default DMA mask for devices on a fsl-mc bus
29  */
30 #define FSL_MC_DEFAULT_DMA_MASK	(~0ULL)
31 
32 static struct fsl_mc_version mc_version;
33 
34 /**
35  * struct fsl_mc - Private data of a "fsl,qoriq-mc" platform device
36  * @root_mc_bus_dev: fsl-mc device representing the root DPRC
37  * @num_translation_ranges: number of entries in addr_translation_ranges
38  * @translation_ranges: array of bus to system address translation ranges
39  * @fsl_mc_regs: base address of register bank
40  */
41 struct fsl_mc {
42 	struct fsl_mc_device *root_mc_bus_dev;
43 	u8 num_translation_ranges;
44 	struct fsl_mc_addr_translation_range *translation_ranges;
45 	void __iomem *fsl_mc_regs;
46 };
47 
48 /**
49  * struct fsl_mc_addr_translation_range - bus to system address translation
50  * range
51  * @mc_region_type: Type of MC region for the range being translated
52  * @start_mc_offset: Start MC offset of the range being translated
53  * @end_mc_offset: MC offset of the first byte after the range (last MC
54  * offset of the range is end_mc_offset - 1)
55  * @start_phys_addr: system physical address corresponding to start_mc_addr
56  */
57 struct fsl_mc_addr_translation_range {
58 	enum dprc_region_type mc_region_type;
59 	u64 start_mc_offset;
60 	u64 end_mc_offset;
61 	phys_addr_t start_phys_addr;
62 };
63 
64 #define FSL_MC_GCR1	0x0
65 #define GCR1_P1_STOP	BIT(31)
66 #define GCR1_P2_STOP	BIT(30)
67 
68 #define FSL_MC_FAPR	0x28
69 #define MC_FAPR_PL	BIT(18)
70 #define MC_FAPR_BMT	BIT(17)
71 
72 static phys_addr_t mc_portal_base_phys_addr;
73 
74 /**
75  * fsl_mc_bus_match - device to driver matching callback
76  * @dev: the fsl-mc device to match against
77  * @drv: the device driver to search for matching fsl-mc object type
78  * structures
79  *
80  * Returns 1 on success, 0 otherwise.
81  */
fsl_mc_bus_match(struct device * dev,struct device_driver * drv)82 static int fsl_mc_bus_match(struct device *dev, struct device_driver *drv)
83 {
84 	const struct fsl_mc_device_id *id;
85 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
86 	struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(drv);
87 	bool found = false;
88 
89 	/* When driver_override is set, only bind to the matching driver */
90 	if (mc_dev->driver_override) {
91 		found = !strcmp(mc_dev->driver_override, mc_drv->driver.name);
92 		goto out;
93 	}
94 
95 	if (!mc_drv->match_id_table)
96 		goto out;
97 
98 	/*
99 	 * If the object is not 'plugged' don't match.
100 	 * Only exception is the root DPRC, which is a special case.
101 	 */
102 	if ((mc_dev->obj_desc.state & FSL_MC_OBJ_STATE_PLUGGED) == 0 &&
103 	    !fsl_mc_is_root_dprc(&mc_dev->dev))
104 		goto out;
105 
106 	/*
107 	 * Traverse the match_id table of the given driver, trying to find
108 	 * a matching for the given device.
109 	 */
110 	for (id = mc_drv->match_id_table; id->vendor != 0x0; id++) {
111 		if (id->vendor == mc_dev->obj_desc.vendor &&
112 		    strcmp(id->obj_type, mc_dev->obj_desc.type) == 0) {
113 			found = true;
114 
115 			break;
116 		}
117 	}
118 
119 out:
120 	dev_dbg(dev, "%smatched\n", found ? "" : "not ");
121 	return found;
122 }
123 
124 /*
125  * fsl_mc_bus_uevent - callback invoked when a device is added
126  */
fsl_mc_bus_uevent(const struct device * dev,struct kobj_uevent_env * env)127 static int fsl_mc_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
128 {
129 	const struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
130 
131 	if (add_uevent_var(env, "MODALIAS=fsl-mc:v%08Xd%s",
132 			   mc_dev->obj_desc.vendor,
133 			   mc_dev->obj_desc.type))
134 		return -ENOMEM;
135 
136 	return 0;
137 }
138 
fsl_mc_dma_configure(struct device * dev)139 static int fsl_mc_dma_configure(struct device *dev)
140 {
141 	struct device *dma_dev = dev;
142 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
143 	struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(dev->driver);
144 	u32 input_id = mc_dev->icid;
145 	int ret;
146 
147 	while (dev_is_fsl_mc(dma_dev))
148 		dma_dev = dma_dev->parent;
149 
150 	if (dev_of_node(dma_dev))
151 		ret = of_dma_configure_id(dev, dma_dev->of_node, 0, &input_id);
152 	else
153 		ret = acpi_dma_configure_id(dev, DEV_DMA_COHERENT, &input_id);
154 
155 	if (!ret && !mc_drv->driver_managed_dma) {
156 		ret = iommu_device_use_default_domain(dev);
157 		if (ret)
158 			arch_teardown_dma_ops(dev);
159 	}
160 
161 	return ret;
162 }
163 
fsl_mc_dma_cleanup(struct device * dev)164 static void fsl_mc_dma_cleanup(struct device *dev)
165 {
166 	struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(dev->driver);
167 
168 	if (!mc_drv->driver_managed_dma)
169 		iommu_device_unuse_default_domain(dev);
170 }
171 
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)172 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
173 			     char *buf)
174 {
175 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
176 
177 	return sprintf(buf, "fsl-mc:v%08Xd%s\n", mc_dev->obj_desc.vendor,
178 		       mc_dev->obj_desc.type);
179 }
180 static DEVICE_ATTR_RO(modalias);
181 
driver_override_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)182 static ssize_t driver_override_store(struct device *dev,
183 				     struct device_attribute *attr,
184 				     const char *buf, size_t count)
185 {
186 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
187 	int ret;
188 
189 	if (WARN_ON(dev->bus != &fsl_mc_bus_type))
190 		return -EINVAL;
191 
192 	ret = driver_set_override(dev, &mc_dev->driver_override, buf, count);
193 	if (ret)
194 		return ret;
195 
196 	return count;
197 }
198 
driver_override_show(struct device * dev,struct device_attribute * attr,char * buf)199 static ssize_t driver_override_show(struct device *dev,
200 				    struct device_attribute *attr, char *buf)
201 {
202 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
203 
204 	return snprintf(buf, PAGE_SIZE, "%s\n", mc_dev->driver_override);
205 }
206 static DEVICE_ATTR_RW(driver_override);
207 
208 static struct attribute *fsl_mc_dev_attrs[] = {
209 	&dev_attr_modalias.attr,
210 	&dev_attr_driver_override.attr,
211 	NULL,
212 };
213 
214 ATTRIBUTE_GROUPS(fsl_mc_dev);
215 
scan_fsl_mc_bus(struct device * dev,void * data)216 static int scan_fsl_mc_bus(struct device *dev, void *data)
217 {
218 	struct fsl_mc_device *root_mc_dev;
219 	struct fsl_mc_bus *root_mc_bus;
220 
221 	if (!fsl_mc_is_root_dprc(dev))
222 		goto exit;
223 
224 	root_mc_dev = to_fsl_mc_device(dev);
225 	root_mc_bus = to_fsl_mc_bus(root_mc_dev);
226 	mutex_lock(&root_mc_bus->scan_mutex);
227 	dprc_scan_objects(root_mc_dev, false);
228 	mutex_unlock(&root_mc_bus->scan_mutex);
229 
230 exit:
231 	return 0;
232 }
233 
rescan_store(struct bus_type * bus,const char * buf,size_t count)234 static ssize_t rescan_store(struct bus_type *bus,
235 			    const char *buf, size_t count)
236 {
237 	unsigned long val;
238 
239 	if (kstrtoul(buf, 0, &val) < 0)
240 		return -EINVAL;
241 
242 	if (val)
243 		bus_for_each_dev(bus, NULL, NULL, scan_fsl_mc_bus);
244 
245 	return count;
246 }
247 static BUS_ATTR_WO(rescan);
248 
fsl_mc_bus_set_autorescan(struct device * dev,void * data)249 static int fsl_mc_bus_set_autorescan(struct device *dev, void *data)
250 {
251 	struct fsl_mc_device *root_mc_dev;
252 	unsigned long val;
253 	char *buf = data;
254 
255 	if (!fsl_mc_is_root_dprc(dev))
256 		goto exit;
257 
258 	root_mc_dev = to_fsl_mc_device(dev);
259 
260 	if (kstrtoul(buf, 0, &val) < 0)
261 		return -EINVAL;
262 
263 	if (val)
264 		enable_dprc_irq(root_mc_dev);
265 	else
266 		disable_dprc_irq(root_mc_dev);
267 
268 exit:
269 	return 0;
270 }
271 
fsl_mc_bus_get_autorescan(struct device * dev,void * data)272 static int fsl_mc_bus_get_autorescan(struct device *dev, void *data)
273 {
274 	struct fsl_mc_device *root_mc_dev;
275 	char *buf = data;
276 
277 	if (!fsl_mc_is_root_dprc(dev))
278 		goto exit;
279 
280 	root_mc_dev = to_fsl_mc_device(dev);
281 
282 	sprintf(buf, "%d\n", get_dprc_irq_state(root_mc_dev));
283 exit:
284 	return 0;
285 }
286 
autorescan_store(struct bus_type * bus,const char * buf,size_t count)287 static ssize_t autorescan_store(struct bus_type *bus,
288 				const char *buf, size_t count)
289 {
290 	bus_for_each_dev(bus, NULL, (void *)buf, fsl_mc_bus_set_autorescan);
291 
292 	return count;
293 }
294 
autorescan_show(struct bus_type * bus,char * buf)295 static ssize_t autorescan_show(struct bus_type *bus, char *buf)
296 {
297 	bus_for_each_dev(bus, NULL, (void *)buf, fsl_mc_bus_get_autorescan);
298 	return strlen(buf);
299 }
300 
301 static BUS_ATTR_RW(autorescan);
302 
303 static struct attribute *fsl_mc_bus_attrs[] = {
304 	&bus_attr_rescan.attr,
305 	&bus_attr_autorescan.attr,
306 	NULL,
307 };
308 
309 ATTRIBUTE_GROUPS(fsl_mc_bus);
310 
311 struct bus_type fsl_mc_bus_type = {
312 	.name = "fsl-mc",
313 	.match = fsl_mc_bus_match,
314 	.uevent = fsl_mc_bus_uevent,
315 	.dma_configure  = fsl_mc_dma_configure,
316 	.dma_cleanup = fsl_mc_dma_cleanup,
317 	.dev_groups = fsl_mc_dev_groups,
318 	.bus_groups = fsl_mc_bus_groups,
319 };
320 EXPORT_SYMBOL_GPL(fsl_mc_bus_type);
321 
322 struct device_type fsl_mc_bus_dprc_type = {
323 	.name = "fsl_mc_bus_dprc"
324 };
325 EXPORT_SYMBOL_GPL(fsl_mc_bus_dprc_type);
326 
327 struct device_type fsl_mc_bus_dpni_type = {
328 	.name = "fsl_mc_bus_dpni"
329 };
330 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpni_type);
331 
332 struct device_type fsl_mc_bus_dpio_type = {
333 	.name = "fsl_mc_bus_dpio"
334 };
335 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpio_type);
336 
337 struct device_type fsl_mc_bus_dpsw_type = {
338 	.name = "fsl_mc_bus_dpsw"
339 };
340 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpsw_type);
341 
342 struct device_type fsl_mc_bus_dpbp_type = {
343 	.name = "fsl_mc_bus_dpbp"
344 };
345 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpbp_type);
346 
347 struct device_type fsl_mc_bus_dpcon_type = {
348 	.name = "fsl_mc_bus_dpcon"
349 };
350 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpcon_type);
351 
352 struct device_type fsl_mc_bus_dpmcp_type = {
353 	.name = "fsl_mc_bus_dpmcp"
354 };
355 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpmcp_type);
356 
357 struct device_type fsl_mc_bus_dpmac_type = {
358 	.name = "fsl_mc_bus_dpmac"
359 };
360 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpmac_type);
361 
362 struct device_type fsl_mc_bus_dprtc_type = {
363 	.name = "fsl_mc_bus_dprtc"
364 };
365 EXPORT_SYMBOL_GPL(fsl_mc_bus_dprtc_type);
366 
367 struct device_type fsl_mc_bus_dpseci_type = {
368 	.name = "fsl_mc_bus_dpseci"
369 };
370 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpseci_type);
371 
372 struct device_type fsl_mc_bus_dpdmux_type = {
373 	.name = "fsl_mc_bus_dpdmux"
374 };
375 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpdmux_type);
376 
377 struct device_type fsl_mc_bus_dpdcei_type = {
378 	.name = "fsl_mc_bus_dpdcei"
379 };
380 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpdcei_type);
381 
382 struct device_type fsl_mc_bus_dpaiop_type = {
383 	.name = "fsl_mc_bus_dpaiop"
384 };
385 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpaiop_type);
386 
387 struct device_type fsl_mc_bus_dpci_type = {
388 	.name = "fsl_mc_bus_dpci"
389 };
390 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpci_type);
391 
392 struct device_type fsl_mc_bus_dpdmai_type = {
393 	.name = "fsl_mc_bus_dpdmai"
394 };
395 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpdmai_type);
396 
397 struct device_type fsl_mc_bus_dpdbg_type = {
398 	.name = "fsl_mc_bus_dpdbg"
399 };
400 EXPORT_SYMBOL_GPL(fsl_mc_bus_dpdbg_type);
401 
fsl_mc_get_device_type(const char * type)402 static struct device_type *fsl_mc_get_device_type(const char *type)
403 {
404 	static const struct {
405 		struct device_type *dev_type;
406 		const char *type;
407 	} dev_types[] = {
408 		{ &fsl_mc_bus_dprc_type, "dprc" },
409 		{ &fsl_mc_bus_dpni_type, "dpni" },
410 		{ &fsl_mc_bus_dpio_type, "dpio" },
411 		{ &fsl_mc_bus_dpsw_type, "dpsw" },
412 		{ &fsl_mc_bus_dpbp_type, "dpbp" },
413 		{ &fsl_mc_bus_dpcon_type, "dpcon" },
414 		{ &fsl_mc_bus_dpmcp_type, "dpmcp" },
415 		{ &fsl_mc_bus_dpmac_type, "dpmac" },
416 		{ &fsl_mc_bus_dprtc_type, "dprtc" },
417 		{ &fsl_mc_bus_dpseci_type, "dpseci" },
418 		{ &fsl_mc_bus_dpdmux_type, "dpdmux" },
419 		{ &fsl_mc_bus_dpdcei_type, "dpdcei" },
420 		{ &fsl_mc_bus_dpaiop_type, "dpaiop" },
421 		{ &fsl_mc_bus_dpci_type, "dpci" },
422 		{ &fsl_mc_bus_dpdmai_type, "dpdmai" },
423 		{ &fsl_mc_bus_dpdbg_type, "dpdbg" },
424 		{ NULL, NULL }
425 	};
426 	int i;
427 
428 	for (i = 0; dev_types[i].dev_type; i++)
429 		if (!strcmp(dev_types[i].type, type))
430 			return dev_types[i].dev_type;
431 
432 	return NULL;
433 }
434 
fsl_mc_driver_probe(struct device * dev)435 static int fsl_mc_driver_probe(struct device *dev)
436 {
437 	struct fsl_mc_driver *mc_drv;
438 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
439 	int error;
440 
441 	mc_drv = to_fsl_mc_driver(dev->driver);
442 
443 	error = mc_drv->probe(mc_dev);
444 	if (error < 0) {
445 		if (error != -EPROBE_DEFER)
446 			dev_err(dev, "%s failed: %d\n", __func__, error);
447 		return error;
448 	}
449 
450 	return 0;
451 }
452 
fsl_mc_driver_remove(struct device * dev)453 static int fsl_mc_driver_remove(struct device *dev)
454 {
455 	struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(dev->driver);
456 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
457 	int error;
458 
459 	error = mc_drv->remove(mc_dev);
460 	if (error < 0) {
461 		dev_err(dev, "%s failed: %d\n", __func__, error);
462 		return error;
463 	}
464 
465 	return 0;
466 }
467 
fsl_mc_driver_shutdown(struct device * dev)468 static void fsl_mc_driver_shutdown(struct device *dev)
469 {
470 	struct fsl_mc_driver *mc_drv = to_fsl_mc_driver(dev->driver);
471 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
472 
473 	mc_drv->shutdown(mc_dev);
474 }
475 
476 /*
477  * __fsl_mc_driver_register - registers a child device driver with the
478  * MC bus
479  *
480  * This function is implicitly invoked from the registration function of
481  * fsl_mc device drivers, which is generated by the
482  * module_fsl_mc_driver() macro.
483  */
__fsl_mc_driver_register(struct fsl_mc_driver * mc_driver,struct module * owner)484 int __fsl_mc_driver_register(struct fsl_mc_driver *mc_driver,
485 			     struct module *owner)
486 {
487 	int error;
488 
489 	mc_driver->driver.owner = owner;
490 	mc_driver->driver.bus = &fsl_mc_bus_type;
491 
492 	if (mc_driver->probe)
493 		mc_driver->driver.probe = fsl_mc_driver_probe;
494 
495 	if (mc_driver->remove)
496 		mc_driver->driver.remove = fsl_mc_driver_remove;
497 
498 	if (mc_driver->shutdown)
499 		mc_driver->driver.shutdown = fsl_mc_driver_shutdown;
500 
501 	error = driver_register(&mc_driver->driver);
502 	if (error < 0) {
503 		pr_err("driver_register() failed for %s: %d\n",
504 		       mc_driver->driver.name, error);
505 		return error;
506 	}
507 
508 	return 0;
509 }
510 EXPORT_SYMBOL_GPL(__fsl_mc_driver_register);
511 
512 /*
513  * fsl_mc_driver_unregister - unregisters a device driver from the
514  * MC bus
515  */
fsl_mc_driver_unregister(struct fsl_mc_driver * mc_driver)516 void fsl_mc_driver_unregister(struct fsl_mc_driver *mc_driver)
517 {
518 	driver_unregister(&mc_driver->driver);
519 }
520 EXPORT_SYMBOL_GPL(fsl_mc_driver_unregister);
521 
522 /**
523  * mc_get_version() - Retrieves the Management Complex firmware
524  *			version information
525  * @mc_io:		Pointer to opaque I/O object
526  * @cmd_flags:		Command flags; one or more of 'MC_CMD_FLAG_'
527  * @mc_ver_info:	Returned version information structure
528  *
529  * Return:	'0' on Success; Error code otherwise.
530  */
mc_get_version(struct fsl_mc_io * mc_io,u32 cmd_flags,struct fsl_mc_version * mc_ver_info)531 static int mc_get_version(struct fsl_mc_io *mc_io,
532 			  u32 cmd_flags,
533 			  struct fsl_mc_version *mc_ver_info)
534 {
535 	struct fsl_mc_command cmd = { 0 };
536 	struct dpmng_rsp_get_version *rsp_params;
537 	int err;
538 
539 	/* prepare command */
540 	cmd.header = mc_encode_cmd_header(DPMNG_CMDID_GET_VERSION,
541 					  cmd_flags,
542 					  0);
543 
544 	/* send command to mc*/
545 	err = mc_send_command(mc_io, &cmd);
546 	if (err)
547 		return err;
548 
549 	/* retrieve response parameters */
550 	rsp_params = (struct dpmng_rsp_get_version *)cmd.params;
551 	mc_ver_info->revision = le32_to_cpu(rsp_params->revision);
552 	mc_ver_info->major = le32_to_cpu(rsp_params->version_major);
553 	mc_ver_info->minor = le32_to_cpu(rsp_params->version_minor);
554 
555 	return 0;
556 }
557 
558 /**
559  * fsl_mc_get_version - function to retrieve the MC f/w version information
560  *
561  * Return:	mc version when called after fsl-mc-bus probe; NULL otherwise.
562  */
fsl_mc_get_version(void)563 struct fsl_mc_version *fsl_mc_get_version(void)
564 {
565 	if (mc_version.major)
566 		return &mc_version;
567 
568 	return NULL;
569 }
570 EXPORT_SYMBOL_GPL(fsl_mc_get_version);
571 
572 /*
573  * fsl_mc_get_root_dprc - function to traverse to the root dprc
574  */
fsl_mc_get_root_dprc(struct device * dev,struct device ** root_dprc_dev)575 void fsl_mc_get_root_dprc(struct device *dev,
576 			 struct device **root_dprc_dev)
577 {
578 	if (!dev) {
579 		*root_dprc_dev = NULL;
580 	} else if (!dev_is_fsl_mc(dev)) {
581 		*root_dprc_dev = NULL;
582 	} else {
583 		*root_dprc_dev = dev;
584 		while (dev_is_fsl_mc((*root_dprc_dev)->parent))
585 			*root_dprc_dev = (*root_dprc_dev)->parent;
586 	}
587 }
588 
get_dprc_attr(struct fsl_mc_io * mc_io,int container_id,struct dprc_attributes * attr)589 static int get_dprc_attr(struct fsl_mc_io *mc_io,
590 			 int container_id, struct dprc_attributes *attr)
591 {
592 	u16 dprc_handle;
593 	int error;
594 
595 	error = dprc_open(mc_io, 0, container_id, &dprc_handle);
596 	if (error < 0) {
597 		dev_err(mc_io->dev, "dprc_open() failed: %d\n", error);
598 		return error;
599 	}
600 
601 	memset(attr, 0, sizeof(struct dprc_attributes));
602 	error = dprc_get_attributes(mc_io, 0, dprc_handle, attr);
603 	if (error < 0) {
604 		dev_err(mc_io->dev, "dprc_get_attributes() failed: %d\n",
605 			error);
606 		goto common_cleanup;
607 	}
608 
609 	error = 0;
610 
611 common_cleanup:
612 	(void)dprc_close(mc_io, 0, dprc_handle);
613 	return error;
614 }
615 
get_dprc_icid(struct fsl_mc_io * mc_io,int container_id,u32 * icid)616 static int get_dprc_icid(struct fsl_mc_io *mc_io,
617 			 int container_id, u32 *icid)
618 {
619 	struct dprc_attributes attr;
620 	int error;
621 
622 	error = get_dprc_attr(mc_io, container_id, &attr);
623 	if (error == 0)
624 		*icid = attr.icid;
625 
626 	return error;
627 }
628 
translate_mc_addr(struct fsl_mc_device * mc_dev,enum dprc_region_type mc_region_type,u64 mc_offset,phys_addr_t * phys_addr)629 static int translate_mc_addr(struct fsl_mc_device *mc_dev,
630 			     enum dprc_region_type mc_region_type,
631 			     u64 mc_offset, phys_addr_t *phys_addr)
632 {
633 	int i;
634 	struct device *root_dprc_dev;
635 	struct fsl_mc *mc;
636 
637 	fsl_mc_get_root_dprc(&mc_dev->dev, &root_dprc_dev);
638 	mc = dev_get_drvdata(root_dprc_dev->parent);
639 
640 	if (mc->num_translation_ranges == 0) {
641 		/*
642 		 * Do identity mapping:
643 		 */
644 		*phys_addr = mc_offset;
645 		return 0;
646 	}
647 
648 	for (i = 0; i < mc->num_translation_ranges; i++) {
649 		struct fsl_mc_addr_translation_range *range =
650 			&mc->translation_ranges[i];
651 
652 		if (mc_region_type == range->mc_region_type &&
653 		    mc_offset >= range->start_mc_offset &&
654 		    mc_offset < range->end_mc_offset) {
655 			*phys_addr = range->start_phys_addr +
656 				     (mc_offset - range->start_mc_offset);
657 			return 0;
658 		}
659 	}
660 
661 	return -EFAULT;
662 }
663 
fsl_mc_device_get_mmio_regions(struct fsl_mc_device * mc_dev,struct fsl_mc_device * mc_bus_dev)664 static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev,
665 					  struct fsl_mc_device *mc_bus_dev)
666 {
667 	int i;
668 	int error;
669 	struct resource *regions;
670 	struct fsl_mc_obj_desc *obj_desc = &mc_dev->obj_desc;
671 	struct device *parent_dev = mc_dev->dev.parent;
672 	enum dprc_region_type mc_region_type;
673 
674 	if (is_fsl_mc_bus_dprc(mc_dev) ||
675 	    is_fsl_mc_bus_dpmcp(mc_dev)) {
676 		mc_region_type = DPRC_REGION_TYPE_MC_PORTAL;
677 	} else if (is_fsl_mc_bus_dpio(mc_dev)) {
678 		mc_region_type = DPRC_REGION_TYPE_QBMAN_PORTAL;
679 	} else {
680 		/*
681 		 * This function should not have been called for this MC object
682 		 * type, as this object type is not supposed to have MMIO
683 		 * regions
684 		 */
685 		return -EINVAL;
686 	}
687 
688 	regions = kmalloc_array(obj_desc->region_count,
689 				sizeof(regions[0]), GFP_KERNEL);
690 	if (!regions)
691 		return -ENOMEM;
692 
693 	for (i = 0; i < obj_desc->region_count; i++) {
694 		struct dprc_region_desc region_desc;
695 
696 		error = dprc_get_obj_region(mc_bus_dev->mc_io,
697 					    0,
698 					    mc_bus_dev->mc_handle,
699 					    obj_desc->type,
700 					    obj_desc->id, i, &region_desc);
701 		if (error < 0) {
702 			dev_err(parent_dev,
703 				"dprc_get_obj_region() failed: %d\n", error);
704 			goto error_cleanup_regions;
705 		}
706 		/*
707 		 * Older MC only returned region offset and no base address
708 		 * If base address is in the region_desc use it otherwise
709 		 * revert to old mechanism
710 		 */
711 		if (region_desc.base_address) {
712 			regions[i].start = region_desc.base_address +
713 						region_desc.base_offset;
714 		} else {
715 			error = translate_mc_addr(mc_dev, mc_region_type,
716 					  region_desc.base_offset,
717 					  &regions[i].start);
718 
719 			/*
720 			 * Some versions of the MC firmware wrongly report
721 			 * 0 for register base address of the DPMCP associated
722 			 * with child DPRC objects thus rendering them unusable.
723 			 * This is particularly troublesome in ACPI boot
724 			 * scenarios where the legacy way of extracting this
725 			 * base address from the device tree does not apply.
726 			 * Given that DPMCPs share the same base address,
727 			 * workaround this by using the base address extracted
728 			 * from the root DPRC container.
729 			 */
730 			if (is_fsl_mc_bus_dprc(mc_dev) &&
731 			    regions[i].start == region_desc.base_offset)
732 				regions[i].start += mc_portal_base_phys_addr;
733 		}
734 
735 		if (error < 0) {
736 			dev_err(parent_dev,
737 				"Invalid MC offset: %#x (for %s.%d\'s region %d)\n",
738 				region_desc.base_offset,
739 				obj_desc->type, obj_desc->id, i);
740 			goto error_cleanup_regions;
741 		}
742 
743 		regions[i].end = regions[i].start + region_desc.size - 1;
744 		regions[i].name = "fsl-mc object MMIO region";
745 		regions[i].flags = region_desc.flags & IORESOURCE_BITS;
746 		regions[i].flags |= IORESOURCE_MEM;
747 	}
748 
749 	mc_dev->regions = regions;
750 	return 0;
751 
752 error_cleanup_regions:
753 	kfree(regions);
754 	return error;
755 }
756 
757 /*
758  * fsl_mc_is_root_dprc - function to check if a given device is a root dprc
759  */
fsl_mc_is_root_dprc(struct device * dev)760 bool fsl_mc_is_root_dprc(struct device *dev)
761 {
762 	struct device *root_dprc_dev;
763 
764 	fsl_mc_get_root_dprc(dev, &root_dprc_dev);
765 	if (!root_dprc_dev)
766 		return false;
767 	return dev == root_dprc_dev;
768 }
769 
fsl_mc_device_release(struct device * dev)770 static void fsl_mc_device_release(struct device *dev)
771 {
772 	struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
773 
774 	kfree(mc_dev->regions);
775 
776 	if (is_fsl_mc_bus_dprc(mc_dev))
777 		kfree(to_fsl_mc_bus(mc_dev));
778 	else
779 		kfree(mc_dev);
780 }
781 
782 /*
783  * Add a newly discovered fsl-mc device to be visible in Linux
784  */
fsl_mc_device_add(struct fsl_mc_obj_desc * obj_desc,struct fsl_mc_io * mc_io,struct device * parent_dev,struct fsl_mc_device ** new_mc_dev)785 int fsl_mc_device_add(struct fsl_mc_obj_desc *obj_desc,
786 		      struct fsl_mc_io *mc_io,
787 		      struct device *parent_dev,
788 		      struct fsl_mc_device **new_mc_dev)
789 {
790 	int error;
791 	struct fsl_mc_device *mc_dev = NULL;
792 	struct fsl_mc_bus *mc_bus = NULL;
793 	struct fsl_mc_device *parent_mc_dev;
794 
795 	if (dev_is_fsl_mc(parent_dev))
796 		parent_mc_dev = to_fsl_mc_device(parent_dev);
797 	else
798 		parent_mc_dev = NULL;
799 
800 	if (strcmp(obj_desc->type, "dprc") == 0) {
801 		/*
802 		 * Allocate an MC bus device object:
803 		 */
804 		mc_bus = kzalloc(sizeof(*mc_bus), GFP_KERNEL);
805 		if (!mc_bus)
806 			return -ENOMEM;
807 
808 		mutex_init(&mc_bus->scan_mutex);
809 		mc_dev = &mc_bus->mc_dev;
810 	} else {
811 		/*
812 		 * Allocate a regular fsl_mc_device object:
813 		 */
814 		mc_dev = kzalloc(sizeof(*mc_dev), GFP_KERNEL);
815 		if (!mc_dev)
816 			return -ENOMEM;
817 	}
818 
819 	mc_dev->obj_desc = *obj_desc;
820 	mc_dev->mc_io = mc_io;
821 	device_initialize(&mc_dev->dev);
822 	mc_dev->dev.parent = parent_dev;
823 	mc_dev->dev.bus = &fsl_mc_bus_type;
824 	mc_dev->dev.release = fsl_mc_device_release;
825 	mc_dev->dev.type = fsl_mc_get_device_type(obj_desc->type);
826 	if (!mc_dev->dev.type) {
827 		error = -ENODEV;
828 		dev_err(parent_dev, "unknown device type %s\n", obj_desc->type);
829 		goto error_cleanup_dev;
830 	}
831 	dev_set_name(&mc_dev->dev, "%s.%d", obj_desc->type, obj_desc->id);
832 
833 	if (strcmp(obj_desc->type, "dprc") == 0) {
834 		struct fsl_mc_io *mc_io2;
835 
836 		mc_dev->flags |= FSL_MC_IS_DPRC;
837 
838 		/*
839 		 * To get the DPRC's ICID, we need to open the DPRC
840 		 * in get_dprc_icid(). For child DPRCs, we do so using the
841 		 * parent DPRC's MC portal instead of the child DPRC's MC
842 		 * portal, in case the child DPRC is already opened with
843 		 * its own portal (e.g., the DPRC used by AIOP).
844 		 *
845 		 * NOTE: There cannot be more than one active open for a
846 		 * given MC object, using the same MC portal.
847 		 */
848 		if (parent_mc_dev) {
849 			/*
850 			 * device being added is a child DPRC device
851 			 */
852 			mc_io2 = parent_mc_dev->mc_io;
853 		} else {
854 			/*
855 			 * device being added is the root DPRC device
856 			 */
857 			if (!mc_io) {
858 				error = -EINVAL;
859 				goto error_cleanup_dev;
860 			}
861 
862 			mc_io2 = mc_io;
863 		}
864 
865 		error = get_dprc_icid(mc_io2, obj_desc->id, &mc_dev->icid);
866 		if (error < 0)
867 			goto error_cleanup_dev;
868 	} else {
869 		/*
870 		 * A non-DPRC object has to be a child of a DPRC, use the
871 		 * parent's ICID and interrupt domain.
872 		 */
873 		mc_dev->icid = parent_mc_dev->icid;
874 		mc_dev->dma_mask = FSL_MC_DEFAULT_DMA_MASK;
875 		mc_dev->dev.dma_mask = &mc_dev->dma_mask;
876 		mc_dev->dev.coherent_dma_mask = mc_dev->dma_mask;
877 		dev_set_msi_domain(&mc_dev->dev,
878 				   dev_get_msi_domain(&parent_mc_dev->dev));
879 	}
880 
881 	/*
882 	 * Get MMIO regions for the device from the MC:
883 	 *
884 	 * NOTE: the root DPRC is a special case as its MMIO region is
885 	 * obtained from the device tree
886 	 */
887 	if (parent_mc_dev && obj_desc->region_count != 0) {
888 		error = fsl_mc_device_get_mmio_regions(mc_dev,
889 						       parent_mc_dev);
890 		if (error < 0)
891 			goto error_cleanup_dev;
892 	}
893 
894 	/*
895 	 * The device-specific probe callback will get invoked by device_add()
896 	 */
897 	error = device_add(&mc_dev->dev);
898 	if (error < 0) {
899 		dev_err(parent_dev,
900 			"device_add() failed for device %s: %d\n",
901 			dev_name(&mc_dev->dev), error);
902 		goto error_cleanup_dev;
903 	}
904 
905 	dev_dbg(parent_dev, "added %s\n", dev_name(&mc_dev->dev));
906 
907 	*new_mc_dev = mc_dev;
908 	return 0;
909 
910 error_cleanup_dev:
911 	kfree(mc_dev->regions);
912 	kfree(mc_bus);
913 	kfree(mc_dev);
914 
915 	return error;
916 }
917 EXPORT_SYMBOL_GPL(fsl_mc_device_add);
918 
919 static struct notifier_block fsl_mc_nb;
920 
921 /**
922  * fsl_mc_device_remove - Remove an fsl-mc device from being visible to
923  * Linux
924  *
925  * @mc_dev: Pointer to an fsl-mc device
926  */
fsl_mc_device_remove(struct fsl_mc_device * mc_dev)927 void fsl_mc_device_remove(struct fsl_mc_device *mc_dev)
928 {
929 	kfree(mc_dev->driver_override);
930 	mc_dev->driver_override = NULL;
931 
932 	/*
933 	 * The device-specific remove callback will get invoked by device_del()
934 	 */
935 	device_del(&mc_dev->dev);
936 	put_device(&mc_dev->dev);
937 }
938 EXPORT_SYMBOL_GPL(fsl_mc_device_remove);
939 
fsl_mc_get_endpoint(struct fsl_mc_device * mc_dev,u16 if_id)940 struct fsl_mc_device *fsl_mc_get_endpoint(struct fsl_mc_device *mc_dev,
941 					  u16 if_id)
942 {
943 	struct fsl_mc_device *mc_bus_dev, *endpoint;
944 	struct fsl_mc_obj_desc endpoint_desc = {{ 0 }};
945 	struct dprc_endpoint endpoint1 = {{ 0 }};
946 	struct dprc_endpoint endpoint2 = {{ 0 }};
947 	int state, err;
948 
949 	mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
950 	strcpy(endpoint1.type, mc_dev->obj_desc.type);
951 	endpoint1.id = mc_dev->obj_desc.id;
952 	endpoint1.if_id = if_id;
953 
954 	err = dprc_get_connection(mc_bus_dev->mc_io, 0,
955 				  mc_bus_dev->mc_handle,
956 				  &endpoint1, &endpoint2,
957 				  &state);
958 
959 	if (err == -ENOTCONN || state == -1)
960 		return ERR_PTR(-ENOTCONN);
961 
962 	if (err < 0) {
963 		dev_err(&mc_bus_dev->dev, "dprc_get_connection() = %d\n", err);
964 		return ERR_PTR(err);
965 	}
966 
967 	strcpy(endpoint_desc.type, endpoint2.type);
968 	endpoint_desc.id = endpoint2.id;
969 	endpoint = fsl_mc_device_lookup(&endpoint_desc, mc_bus_dev);
970 
971 	/*
972 	 * We know that the device has an endpoint because we verified by
973 	 * interrogating the firmware. This is the case when the device was not
974 	 * yet discovered by the fsl-mc bus, thus the lookup returned NULL.
975 	 * Force a rescan of the devices in this container and retry the lookup.
976 	 */
977 	if (!endpoint) {
978 		struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
979 
980 		if (mutex_trylock(&mc_bus->scan_mutex)) {
981 			err = dprc_scan_objects(mc_bus_dev, true);
982 			mutex_unlock(&mc_bus->scan_mutex);
983 		}
984 
985 		if (err < 0)
986 			return ERR_PTR(err);
987 	}
988 
989 	endpoint = fsl_mc_device_lookup(&endpoint_desc, mc_bus_dev);
990 	/*
991 	 * This means that the endpoint might reside in a different isolation
992 	 * context (DPRC/container). Not much to do, so return a permssion
993 	 * error.
994 	 */
995 	if (!endpoint)
996 		return ERR_PTR(-EPERM);
997 
998 	return endpoint;
999 }
1000 EXPORT_SYMBOL_GPL(fsl_mc_get_endpoint);
1001 
parse_mc_ranges(struct device * dev,int * paddr_cells,int * mc_addr_cells,int * mc_size_cells,const __be32 ** ranges_start)1002 static int parse_mc_ranges(struct device *dev,
1003 			   int *paddr_cells,
1004 			   int *mc_addr_cells,
1005 			   int *mc_size_cells,
1006 			   const __be32 **ranges_start)
1007 {
1008 	const __be32 *prop;
1009 	int range_tuple_cell_count;
1010 	int ranges_len;
1011 	int tuple_len;
1012 	struct device_node *mc_node = dev->of_node;
1013 
1014 	*ranges_start = of_get_property(mc_node, "ranges", &ranges_len);
1015 	if (!(*ranges_start) || !ranges_len) {
1016 		dev_warn(dev,
1017 			 "missing or empty ranges property for device tree node '%pOFn'\n",
1018 			 mc_node);
1019 		return 0;
1020 	}
1021 
1022 	*paddr_cells = of_n_addr_cells(mc_node);
1023 
1024 	prop = of_get_property(mc_node, "#address-cells", NULL);
1025 	if (prop)
1026 		*mc_addr_cells = be32_to_cpup(prop);
1027 	else
1028 		*mc_addr_cells = *paddr_cells;
1029 
1030 	prop = of_get_property(mc_node, "#size-cells", NULL);
1031 	if (prop)
1032 		*mc_size_cells = be32_to_cpup(prop);
1033 	else
1034 		*mc_size_cells = of_n_size_cells(mc_node);
1035 
1036 	range_tuple_cell_count = *paddr_cells + *mc_addr_cells +
1037 				 *mc_size_cells;
1038 
1039 	tuple_len = range_tuple_cell_count * sizeof(__be32);
1040 	if (ranges_len % tuple_len != 0) {
1041 		dev_err(dev, "malformed ranges property '%pOFn'\n", mc_node);
1042 		return -EINVAL;
1043 	}
1044 
1045 	return ranges_len / tuple_len;
1046 }
1047 
get_mc_addr_translation_ranges(struct device * dev,struct fsl_mc_addr_translation_range ** ranges,u8 * num_ranges)1048 static int get_mc_addr_translation_ranges(struct device *dev,
1049 					  struct fsl_mc_addr_translation_range
1050 						**ranges,
1051 					  u8 *num_ranges)
1052 {
1053 	int ret;
1054 	int paddr_cells;
1055 	int mc_addr_cells;
1056 	int mc_size_cells;
1057 	int i;
1058 	const __be32 *ranges_start;
1059 	const __be32 *cell;
1060 
1061 	ret = parse_mc_ranges(dev,
1062 			      &paddr_cells,
1063 			      &mc_addr_cells,
1064 			      &mc_size_cells,
1065 			      &ranges_start);
1066 	if (ret < 0)
1067 		return ret;
1068 
1069 	*num_ranges = ret;
1070 	if (!ret) {
1071 		/*
1072 		 * Missing or empty ranges property ("ranges;") for the
1073 		 * 'fsl,qoriq-mc' node. In this case, identity mapping
1074 		 * will be used.
1075 		 */
1076 		*ranges = NULL;
1077 		return 0;
1078 	}
1079 
1080 	*ranges = devm_kcalloc(dev, *num_ranges,
1081 			       sizeof(struct fsl_mc_addr_translation_range),
1082 			       GFP_KERNEL);
1083 	if (!(*ranges))
1084 		return -ENOMEM;
1085 
1086 	cell = ranges_start;
1087 	for (i = 0; i < *num_ranges; ++i) {
1088 		struct fsl_mc_addr_translation_range *range = &(*ranges)[i];
1089 
1090 		range->mc_region_type = of_read_number(cell, 1);
1091 		range->start_mc_offset = of_read_number(cell + 1,
1092 							mc_addr_cells - 1);
1093 		cell += mc_addr_cells;
1094 		range->start_phys_addr = of_read_number(cell, paddr_cells);
1095 		cell += paddr_cells;
1096 		range->end_mc_offset = range->start_mc_offset +
1097 				     of_read_number(cell, mc_size_cells);
1098 
1099 		cell += mc_size_cells;
1100 	}
1101 
1102 	return 0;
1103 }
1104 
1105 /*
1106  * fsl_mc_bus_probe - callback invoked when the root MC bus is being
1107  * added
1108  */
fsl_mc_bus_probe(struct platform_device * pdev)1109 static int fsl_mc_bus_probe(struct platform_device *pdev)
1110 {
1111 	struct fsl_mc_obj_desc obj_desc;
1112 	int error;
1113 	struct fsl_mc *mc;
1114 	struct fsl_mc_device *mc_bus_dev = NULL;
1115 	struct fsl_mc_io *mc_io = NULL;
1116 	int container_id;
1117 	phys_addr_t mc_portal_phys_addr;
1118 	u32 mc_portal_size, mc_stream_id;
1119 	struct resource *plat_res;
1120 
1121 	mc = devm_kzalloc(&pdev->dev, sizeof(*mc), GFP_KERNEL);
1122 	if (!mc)
1123 		return -ENOMEM;
1124 
1125 	platform_set_drvdata(pdev, mc);
1126 
1127 	plat_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1128 	if (plat_res) {
1129 		mc->fsl_mc_regs = devm_ioremap_resource(&pdev->dev, plat_res);
1130 		if (IS_ERR(mc->fsl_mc_regs))
1131 			return PTR_ERR(mc->fsl_mc_regs);
1132 	}
1133 
1134 	if (mc->fsl_mc_regs) {
1135 		if (IS_ENABLED(CONFIG_ACPI) && !dev_of_node(&pdev->dev)) {
1136 			mc_stream_id = readl(mc->fsl_mc_regs + FSL_MC_FAPR);
1137 			/*
1138 			 * HW ORs the PL and BMT bit, places the result in bit
1139 			 * 14 of the StreamID and ORs in the ICID. Calculate it
1140 			 * accordingly.
1141 			 */
1142 			mc_stream_id = (mc_stream_id & 0xffff) |
1143 				((mc_stream_id & (MC_FAPR_PL | MC_FAPR_BMT)) ?
1144 					BIT(14) : 0);
1145 			error = acpi_dma_configure_id(&pdev->dev,
1146 						      DEV_DMA_COHERENT,
1147 						      &mc_stream_id);
1148 			if (error == -EPROBE_DEFER)
1149 				return error;
1150 			if (error)
1151 				dev_warn(&pdev->dev,
1152 					 "failed to configure dma: %d.\n",
1153 					 error);
1154 		}
1155 
1156 		/*
1157 		 * Some bootloaders pause the MC firmware before booting the
1158 		 * kernel so that MC will not cause faults as soon as the
1159 		 * SMMU probes due to the fact that there's no configuration
1160 		 * in place for MC.
1161 		 * At this point MC should have all its SMMU setup done so make
1162 		 * sure it is resumed.
1163 		 */
1164 		writel(readl(mc->fsl_mc_regs + FSL_MC_GCR1) &
1165 			     (~(GCR1_P1_STOP | GCR1_P2_STOP)),
1166 		       mc->fsl_mc_regs + FSL_MC_GCR1);
1167 	}
1168 
1169 	/*
1170 	 * Get physical address of MC portal for the root DPRC:
1171 	 */
1172 	plat_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1173 	mc_portal_phys_addr = plat_res->start;
1174 	mc_portal_size = resource_size(plat_res);
1175 	mc_portal_base_phys_addr = mc_portal_phys_addr & ~0x3ffffff;
1176 
1177 	error = fsl_create_mc_io(&pdev->dev, mc_portal_phys_addr,
1178 				 mc_portal_size, NULL,
1179 				 FSL_MC_IO_ATOMIC_CONTEXT_PORTAL, &mc_io);
1180 	if (error < 0)
1181 		return error;
1182 
1183 	error = mc_get_version(mc_io, 0, &mc_version);
1184 	if (error != 0) {
1185 		dev_err(&pdev->dev,
1186 			"mc_get_version() failed with error %d\n", error);
1187 		goto error_cleanup_mc_io;
1188 	}
1189 
1190 	dev_info(&pdev->dev, "MC firmware version: %u.%u.%u\n",
1191 		 mc_version.major, mc_version.minor, mc_version.revision);
1192 
1193 	if (dev_of_node(&pdev->dev)) {
1194 		error = get_mc_addr_translation_ranges(&pdev->dev,
1195 						&mc->translation_ranges,
1196 						&mc->num_translation_ranges);
1197 		if (error < 0)
1198 			goto error_cleanup_mc_io;
1199 	}
1200 
1201 	error = dprc_get_container_id(mc_io, 0, &container_id);
1202 	if (error < 0) {
1203 		dev_err(&pdev->dev,
1204 			"dprc_get_container_id() failed: %d\n", error);
1205 		goto error_cleanup_mc_io;
1206 	}
1207 
1208 	memset(&obj_desc, 0, sizeof(struct fsl_mc_obj_desc));
1209 	error = dprc_get_api_version(mc_io, 0,
1210 				     &obj_desc.ver_major,
1211 				     &obj_desc.ver_minor);
1212 	if (error < 0)
1213 		goto error_cleanup_mc_io;
1214 
1215 	obj_desc.vendor = FSL_MC_VENDOR_FREESCALE;
1216 	strcpy(obj_desc.type, "dprc");
1217 	obj_desc.id = container_id;
1218 	obj_desc.irq_count = 1;
1219 	obj_desc.region_count = 0;
1220 
1221 	error = fsl_mc_device_add(&obj_desc, mc_io, &pdev->dev, &mc_bus_dev);
1222 	if (error < 0)
1223 		goto error_cleanup_mc_io;
1224 
1225 	mc->root_mc_bus_dev = mc_bus_dev;
1226 	mc_bus_dev->dev.fwnode = pdev->dev.fwnode;
1227 	return 0;
1228 
1229 error_cleanup_mc_io:
1230 	fsl_destroy_mc_io(mc_io);
1231 	return error;
1232 }
1233 
1234 /*
1235  * fsl_mc_bus_remove - callback invoked when the root MC bus is being
1236  * removed
1237  */
fsl_mc_bus_remove(struct platform_device * pdev)1238 static int fsl_mc_bus_remove(struct platform_device *pdev)
1239 {
1240 	struct fsl_mc *mc = platform_get_drvdata(pdev);
1241 	struct fsl_mc_io *mc_io;
1242 
1243 	if (!fsl_mc_is_root_dprc(&mc->root_mc_bus_dev->dev))
1244 		return -EINVAL;
1245 
1246 	mc_io = mc->root_mc_bus_dev->mc_io;
1247 	fsl_mc_device_remove(mc->root_mc_bus_dev);
1248 	fsl_destroy_mc_io(mc_io);
1249 
1250 	bus_unregister_notifier(&fsl_mc_bus_type, &fsl_mc_nb);
1251 
1252 	if (mc->fsl_mc_regs) {
1253 		/*
1254 		 * Pause the MC firmware so that it doesn't crash in certain
1255 		 * scenarios, such as kexec.
1256 		 */
1257 		writel(readl(mc->fsl_mc_regs + FSL_MC_GCR1) |
1258 		       (GCR1_P1_STOP | GCR1_P2_STOP),
1259 		       mc->fsl_mc_regs + FSL_MC_GCR1);
1260 	}
1261 
1262 	return 0;
1263 }
1264 
fsl_mc_bus_shutdown(struct platform_device * pdev)1265 static void fsl_mc_bus_shutdown(struct platform_device *pdev)
1266 {
1267 	fsl_mc_bus_remove(pdev);
1268 }
1269 
1270 static const struct of_device_id fsl_mc_bus_match_table[] = {
1271 	{.compatible = "fsl,qoriq-mc",},
1272 	{},
1273 };
1274 
1275 MODULE_DEVICE_TABLE(of, fsl_mc_bus_match_table);
1276 
1277 static const struct acpi_device_id fsl_mc_bus_acpi_match_table[] = {
1278 	{"NXP0008", 0 },
1279 	{ }
1280 };
1281 MODULE_DEVICE_TABLE(acpi, fsl_mc_bus_acpi_match_table);
1282 
1283 static struct platform_driver fsl_mc_bus_driver = {
1284 	.driver = {
1285 		   .name = "fsl_mc_bus",
1286 		   .pm = NULL,
1287 		   .of_match_table = fsl_mc_bus_match_table,
1288 		   .acpi_match_table = fsl_mc_bus_acpi_match_table,
1289 		   },
1290 	.probe = fsl_mc_bus_probe,
1291 	.remove = fsl_mc_bus_remove,
1292 	.shutdown = fsl_mc_bus_shutdown,
1293 };
1294 
fsl_mc_bus_notifier(struct notifier_block * nb,unsigned long action,void * data)1295 static int fsl_mc_bus_notifier(struct notifier_block *nb,
1296 			       unsigned long action, void *data)
1297 {
1298 	struct device *dev = data;
1299 	struct resource *res;
1300 	void __iomem *fsl_mc_regs;
1301 
1302 	if (action != BUS_NOTIFY_ADD_DEVICE)
1303 		return 0;
1304 
1305 	if (!of_match_device(fsl_mc_bus_match_table, dev) &&
1306 	    !acpi_match_device(fsl_mc_bus_acpi_match_table, dev))
1307 		return 0;
1308 
1309 	res = platform_get_resource(to_platform_device(dev), IORESOURCE_MEM, 1);
1310 	if (!res)
1311 		return 0;
1312 
1313 	fsl_mc_regs = ioremap(res->start, resource_size(res));
1314 	if (!fsl_mc_regs)
1315 		return 0;
1316 
1317 	/*
1318 	 * Make sure that the MC firmware is paused before the IOMMU setup for
1319 	 * it is done or otherwise the firmware will crash right after the SMMU
1320 	 * gets probed and enabled.
1321 	 */
1322 	writel(readl(fsl_mc_regs + FSL_MC_GCR1) | (GCR1_P1_STOP | GCR1_P2_STOP),
1323 	       fsl_mc_regs + FSL_MC_GCR1);
1324 	iounmap(fsl_mc_regs);
1325 
1326 	return 0;
1327 }
1328 
1329 static struct notifier_block fsl_mc_nb = {
1330 	.notifier_call = fsl_mc_bus_notifier,
1331 };
1332 
fsl_mc_bus_driver_init(void)1333 static int __init fsl_mc_bus_driver_init(void)
1334 {
1335 	int error;
1336 
1337 	error = bus_register(&fsl_mc_bus_type);
1338 	if (error < 0) {
1339 		pr_err("bus type registration failed: %d\n", error);
1340 		goto error_cleanup_cache;
1341 	}
1342 
1343 	error = platform_driver_register(&fsl_mc_bus_driver);
1344 	if (error < 0) {
1345 		pr_err("platform_driver_register() failed: %d\n", error);
1346 		goto error_cleanup_bus;
1347 	}
1348 
1349 	error = dprc_driver_init();
1350 	if (error < 0)
1351 		goto error_cleanup_driver;
1352 
1353 	error = fsl_mc_allocator_driver_init();
1354 	if (error < 0)
1355 		goto error_cleanup_dprc_driver;
1356 
1357 	return bus_register_notifier(&platform_bus_type, &fsl_mc_nb);
1358 
1359 error_cleanup_dprc_driver:
1360 	dprc_driver_exit();
1361 
1362 error_cleanup_driver:
1363 	platform_driver_unregister(&fsl_mc_bus_driver);
1364 
1365 error_cleanup_bus:
1366 	bus_unregister(&fsl_mc_bus_type);
1367 
1368 error_cleanup_cache:
1369 	return error;
1370 }
1371 postcore_initcall(fsl_mc_bus_driver_init);
1372