1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * fsl-mc object allocator driver
4  *
5  * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
6  *
7  */
8 
9 #include <linux/module.h>
10 #include <linux/msi.h>
11 #include <linux/fsl/mc.h>
12 
13 #include "fsl-mc-private.h"
14 
fsl_mc_is_allocatable(struct fsl_mc_device * mc_dev)15 static bool __must_check fsl_mc_is_allocatable(struct fsl_mc_device *mc_dev)
16 {
17 	return is_fsl_mc_bus_dpbp(mc_dev) ||
18 	       is_fsl_mc_bus_dpmcp(mc_dev) ||
19 	       is_fsl_mc_bus_dpcon(mc_dev);
20 }
21 
22 /**
23  * fsl_mc_resource_pool_add_device - add allocatable object to a resource
24  * pool of a given fsl-mc bus
25  *
26  * @mc_bus: pointer to the fsl-mc bus
27  * @pool_type: pool type
28  * @mc_dev: pointer to allocatable fsl-mc device
29  */
fsl_mc_resource_pool_add_device(struct fsl_mc_bus * mc_bus,enum fsl_mc_pool_type pool_type,struct fsl_mc_device * mc_dev)30 static int __must_check fsl_mc_resource_pool_add_device(struct fsl_mc_bus
31 								*mc_bus,
32 							enum fsl_mc_pool_type
33 								pool_type,
34 							struct fsl_mc_device
35 								*mc_dev)
36 {
37 	struct fsl_mc_resource_pool *res_pool;
38 	struct fsl_mc_resource *resource;
39 	struct fsl_mc_device *mc_bus_dev = &mc_bus->mc_dev;
40 	int error = -EINVAL;
41 
42 	if (pool_type < 0 || pool_type >= FSL_MC_NUM_POOL_TYPES)
43 		goto out;
44 	if (!fsl_mc_is_allocatable(mc_dev))
45 		goto out;
46 	if (mc_dev->resource)
47 		goto out;
48 
49 	res_pool = &mc_bus->resource_pools[pool_type];
50 	if (res_pool->type != pool_type)
51 		goto out;
52 	if (res_pool->mc_bus != mc_bus)
53 		goto out;
54 
55 	mutex_lock(&res_pool->mutex);
56 
57 	if (res_pool->max_count < 0)
58 		goto out_unlock;
59 	if (res_pool->free_count < 0 ||
60 	    res_pool->free_count > res_pool->max_count)
61 		goto out_unlock;
62 
63 	resource = devm_kzalloc(&mc_bus_dev->dev, sizeof(*resource),
64 				GFP_KERNEL);
65 	if (!resource) {
66 		error = -ENOMEM;
67 		dev_err(&mc_bus_dev->dev,
68 			"Failed to allocate memory for fsl_mc_resource\n");
69 		goto out_unlock;
70 	}
71 
72 	resource->type = pool_type;
73 	resource->id = mc_dev->obj_desc.id;
74 	resource->data = mc_dev;
75 	resource->parent_pool = res_pool;
76 	INIT_LIST_HEAD(&resource->node);
77 	list_add_tail(&resource->node, &res_pool->free_list);
78 	mc_dev->resource = resource;
79 	res_pool->free_count++;
80 	res_pool->max_count++;
81 	error = 0;
82 out_unlock:
83 	mutex_unlock(&res_pool->mutex);
84 out:
85 	return error;
86 }
87 
88 /**
89  * fsl_mc_resource_pool_remove_device - remove an allocatable device from a
90  * resource pool
91  *
92  * @mc_dev: pointer to allocatable fsl-mc device
93  *
94  * It permanently removes an allocatable fsl-mc device from the resource
95  * pool. It's an error if the device is in use.
96  */
fsl_mc_resource_pool_remove_device(struct fsl_mc_device * mc_dev)97 static int __must_check fsl_mc_resource_pool_remove_device(struct fsl_mc_device
98 								   *mc_dev)
99 {
100 	struct fsl_mc_device *mc_bus_dev;
101 	struct fsl_mc_bus *mc_bus;
102 	struct fsl_mc_resource_pool *res_pool;
103 	struct fsl_mc_resource *resource;
104 	int error = -EINVAL;
105 
106 	mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
107 	mc_bus = to_fsl_mc_bus(mc_bus_dev);
108 
109 	resource = mc_dev->resource;
110 	if (!resource || resource->data != mc_dev) {
111 		dev_err(&mc_bus_dev->dev, "resource mismatch\n");
112 		goto out;
113 	}
114 
115 	res_pool = resource->parent_pool;
116 	if (res_pool != &mc_bus->resource_pools[resource->type]) {
117 		dev_err(&mc_bus_dev->dev, "pool mismatch\n");
118 		goto out;
119 	}
120 
121 	mutex_lock(&res_pool->mutex);
122 
123 	if (res_pool->max_count <= 0) {
124 		dev_err(&mc_bus_dev->dev, "max_count underflow\n");
125 		goto out_unlock;
126 	}
127 	if (res_pool->free_count <= 0 ||
128 	    res_pool->free_count > res_pool->max_count) {
129 		dev_err(&mc_bus_dev->dev, "free_count mismatch\n");
130 		goto out_unlock;
131 	}
132 
133 	/*
134 	 * If the device is currently allocated, its resource is not
135 	 * in the free list and thus, the device cannot be removed.
136 	 */
137 	if (list_empty(&resource->node)) {
138 		error = -EBUSY;
139 		dev_err(&mc_bus_dev->dev,
140 			"Device %s cannot be removed from resource pool\n",
141 			dev_name(&mc_dev->dev));
142 		goto out_unlock;
143 	}
144 
145 	list_del_init(&resource->node);
146 	res_pool->free_count--;
147 	res_pool->max_count--;
148 
149 	devm_kfree(&mc_bus_dev->dev, resource);
150 	mc_dev->resource = NULL;
151 	error = 0;
152 out_unlock:
153 	mutex_unlock(&res_pool->mutex);
154 out:
155 	return error;
156 }
157 
158 static const char *const fsl_mc_pool_type_strings[] = {
159 	[FSL_MC_POOL_DPMCP] = "dpmcp",
160 	[FSL_MC_POOL_DPBP] = "dpbp",
161 	[FSL_MC_POOL_DPCON] = "dpcon",
162 	[FSL_MC_POOL_IRQ] = "irq",
163 };
164 
object_type_to_pool_type(const char * object_type,enum fsl_mc_pool_type * pool_type)165 static int __must_check object_type_to_pool_type(const char *object_type,
166 						 enum fsl_mc_pool_type
167 								*pool_type)
168 {
169 	unsigned int i;
170 
171 	for (i = 0; i < ARRAY_SIZE(fsl_mc_pool_type_strings); i++) {
172 		if (strcmp(object_type, fsl_mc_pool_type_strings[i]) == 0) {
173 			*pool_type = i;
174 			return 0;
175 		}
176 	}
177 
178 	return -EINVAL;
179 }
180 
fsl_mc_resource_allocate(struct fsl_mc_bus * mc_bus,enum fsl_mc_pool_type pool_type,struct fsl_mc_resource ** new_resource)181 int __must_check fsl_mc_resource_allocate(struct fsl_mc_bus *mc_bus,
182 					  enum fsl_mc_pool_type pool_type,
183 					  struct fsl_mc_resource **new_resource)
184 {
185 	struct fsl_mc_resource_pool *res_pool;
186 	struct fsl_mc_resource *resource;
187 	struct fsl_mc_device *mc_bus_dev = &mc_bus->mc_dev;
188 	int error = -EINVAL;
189 
190 	BUILD_BUG_ON(ARRAY_SIZE(fsl_mc_pool_type_strings) !=
191 		     FSL_MC_NUM_POOL_TYPES);
192 
193 	*new_resource = NULL;
194 	if (pool_type < 0 || pool_type >= FSL_MC_NUM_POOL_TYPES)
195 		goto out;
196 
197 	res_pool = &mc_bus->resource_pools[pool_type];
198 	if (res_pool->mc_bus != mc_bus)
199 		goto out;
200 
201 	mutex_lock(&res_pool->mutex);
202 	resource = list_first_entry_or_null(&res_pool->free_list,
203 					    struct fsl_mc_resource, node);
204 
205 	if (!resource) {
206 		error = -ENXIO;
207 		dev_err(&mc_bus_dev->dev,
208 			"No more resources of type %s left\n",
209 			fsl_mc_pool_type_strings[pool_type]);
210 		goto out_unlock;
211 	}
212 
213 	if (resource->type != pool_type)
214 		goto out_unlock;
215 	if (resource->parent_pool != res_pool)
216 		goto out_unlock;
217 	if (res_pool->free_count <= 0 ||
218 	    res_pool->free_count > res_pool->max_count)
219 		goto out_unlock;
220 
221 	list_del_init(&resource->node);
222 
223 	res_pool->free_count--;
224 	error = 0;
225 out_unlock:
226 	mutex_unlock(&res_pool->mutex);
227 	*new_resource = resource;
228 out:
229 	return error;
230 }
231 EXPORT_SYMBOL_GPL(fsl_mc_resource_allocate);
232 
fsl_mc_resource_free(struct fsl_mc_resource * resource)233 void fsl_mc_resource_free(struct fsl_mc_resource *resource)
234 {
235 	struct fsl_mc_resource_pool *res_pool;
236 
237 	res_pool = resource->parent_pool;
238 	if (resource->type != res_pool->type)
239 		return;
240 
241 	mutex_lock(&res_pool->mutex);
242 	if (res_pool->free_count < 0 ||
243 	    res_pool->free_count >= res_pool->max_count)
244 		goto out_unlock;
245 
246 	if (!list_empty(&resource->node))
247 		goto out_unlock;
248 
249 	list_add_tail(&resource->node, &res_pool->free_list);
250 	res_pool->free_count++;
251 out_unlock:
252 	mutex_unlock(&res_pool->mutex);
253 }
254 EXPORT_SYMBOL_GPL(fsl_mc_resource_free);
255 
256 /**
257  * fsl_mc_object_allocate - Allocates an fsl-mc object of the given
258  * pool type from a given fsl-mc bus instance
259  *
260  * @mc_dev: fsl-mc device which is used in conjunction with the
261  * allocated object
262  * @pool_type: pool type
263  * @new_mc_adev: pointer to area where the pointer to the allocated device
264  * is to be returned
265  *
266  * Allocatable objects are always used in conjunction with some functional
267  * device.  This function allocates an object of the specified type from
268  * the DPRC containing the functional device.
269  *
270  * NOTE: pool_type must be different from FSL_MC_POOL_MCP, since MC
271  * portals are allocated using fsl_mc_portal_allocate(), instead of
272  * this function.
273  */
fsl_mc_object_allocate(struct fsl_mc_device * mc_dev,enum fsl_mc_pool_type pool_type,struct fsl_mc_device ** new_mc_adev)274 int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
275 					enum fsl_mc_pool_type pool_type,
276 					struct fsl_mc_device **new_mc_adev)
277 {
278 	struct fsl_mc_device *mc_bus_dev;
279 	struct fsl_mc_bus *mc_bus;
280 	struct fsl_mc_device *mc_adev;
281 	int error = -EINVAL;
282 	struct fsl_mc_resource *resource = NULL;
283 
284 	*new_mc_adev = NULL;
285 	if (mc_dev->flags & FSL_MC_IS_DPRC)
286 		goto error;
287 
288 	if (!dev_is_fsl_mc(mc_dev->dev.parent))
289 		goto error;
290 
291 	if (pool_type == FSL_MC_POOL_DPMCP)
292 		goto error;
293 
294 	mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
295 	mc_bus = to_fsl_mc_bus(mc_bus_dev);
296 	error = fsl_mc_resource_allocate(mc_bus, pool_type, &resource);
297 	if (error < 0)
298 		goto error;
299 
300 	mc_adev = resource->data;
301 	if (!mc_adev) {
302 		error = -EINVAL;
303 		goto error;
304 	}
305 
306 	mc_adev->consumer_link = device_link_add(&mc_dev->dev,
307 						 &mc_adev->dev,
308 						 DL_FLAG_AUTOREMOVE_CONSUMER);
309 	if (!mc_adev->consumer_link) {
310 		error = -EINVAL;
311 		goto error;
312 	}
313 
314 	*new_mc_adev = mc_adev;
315 	return 0;
316 error:
317 	if (resource)
318 		fsl_mc_resource_free(resource);
319 
320 	return error;
321 }
322 EXPORT_SYMBOL_GPL(fsl_mc_object_allocate);
323 
324 /**
325  * fsl_mc_object_free - Returns an fsl-mc object to the resource
326  * pool where it came from.
327  * @mc_adev: Pointer to the fsl-mc device
328  */
fsl_mc_object_free(struct fsl_mc_device * mc_adev)329 void fsl_mc_object_free(struct fsl_mc_device *mc_adev)
330 {
331 	struct fsl_mc_resource *resource;
332 
333 	resource = mc_adev->resource;
334 	if (resource->type == FSL_MC_POOL_DPMCP)
335 		return;
336 	if (resource->data != mc_adev)
337 		return;
338 
339 	fsl_mc_resource_free(resource);
340 
341 	mc_adev->consumer_link = NULL;
342 }
343 EXPORT_SYMBOL_GPL(fsl_mc_object_free);
344 
345 /*
346  * A DPRC and the devices in the DPRC all share the same GIC-ITS device
347  * ID.  A block of IRQs is pre-allocated and maintained in a pool
348  * from which devices can allocate them when needed.
349  */
350 
351 /*
352  * Initialize the interrupt pool associated with an fsl-mc bus.
353  * It allocates a block of IRQs from the GIC-ITS.
354  */
fsl_mc_populate_irq_pool(struct fsl_mc_device * mc_bus_dev,unsigned int irq_count)355 int fsl_mc_populate_irq_pool(struct fsl_mc_device *mc_bus_dev,
356 			     unsigned int irq_count)
357 {
358 	unsigned int i;
359 	struct fsl_mc_device_irq *irq_resources;
360 	struct fsl_mc_device_irq *mc_dev_irq;
361 	int error;
362 	struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
363 	struct fsl_mc_resource_pool *res_pool =
364 			&mc_bus->resource_pools[FSL_MC_POOL_IRQ];
365 
366 	/* do nothing if the IRQ pool is already populated */
367 	if (mc_bus->irq_resources)
368 		return 0;
369 
370 	if (irq_count == 0 ||
371 	    irq_count > FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS)
372 		return -EINVAL;
373 
374 	error = fsl_mc_msi_domain_alloc_irqs(&mc_bus_dev->dev, irq_count);
375 	if (error < 0)
376 		return error;
377 
378 	irq_resources = devm_kcalloc(&mc_bus_dev->dev,
379 				     irq_count, sizeof(*irq_resources),
380 				     GFP_KERNEL);
381 	if (!irq_resources) {
382 		error = -ENOMEM;
383 		goto cleanup_msi_irqs;
384 	}
385 
386 	for (i = 0; i < irq_count; i++) {
387 		mc_dev_irq = &irq_resources[i];
388 
389 		/*
390 		 * NOTE: This mc_dev_irq's MSI addr/value pair will be set
391 		 * by the fsl_mc_msi_write_msg() callback
392 		 */
393 		mc_dev_irq->resource.type = res_pool->type;
394 		mc_dev_irq->resource.data = mc_dev_irq;
395 		mc_dev_irq->resource.parent_pool = res_pool;
396 		mc_dev_irq->virq = msi_get_virq(&mc_bus_dev->dev, i);
397 		mc_dev_irq->resource.id = mc_dev_irq->virq;
398 		INIT_LIST_HEAD(&mc_dev_irq->resource.node);
399 		list_add_tail(&mc_dev_irq->resource.node, &res_pool->free_list);
400 	}
401 
402 	res_pool->max_count = irq_count;
403 	res_pool->free_count = irq_count;
404 	mc_bus->irq_resources = irq_resources;
405 	return 0;
406 
407 cleanup_msi_irqs:
408 	fsl_mc_msi_domain_free_irqs(&mc_bus_dev->dev);
409 	return error;
410 }
411 EXPORT_SYMBOL_GPL(fsl_mc_populate_irq_pool);
412 
413 /*
414  * Teardown the interrupt pool associated with an fsl-mc bus.
415  * It frees the IRQs that were allocated to the pool, back to the GIC-ITS.
416  */
fsl_mc_cleanup_irq_pool(struct fsl_mc_device * mc_bus_dev)417 void fsl_mc_cleanup_irq_pool(struct fsl_mc_device *mc_bus_dev)
418 {
419 	struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
420 	struct fsl_mc_resource_pool *res_pool =
421 			&mc_bus->resource_pools[FSL_MC_POOL_IRQ];
422 
423 	if (!mc_bus->irq_resources)
424 		return;
425 
426 	if (res_pool->max_count == 0)
427 		return;
428 
429 	if (res_pool->free_count != res_pool->max_count)
430 		return;
431 
432 	INIT_LIST_HEAD(&res_pool->free_list);
433 	res_pool->max_count = 0;
434 	res_pool->free_count = 0;
435 	mc_bus->irq_resources = NULL;
436 	fsl_mc_msi_domain_free_irqs(&mc_bus_dev->dev);
437 }
438 EXPORT_SYMBOL_GPL(fsl_mc_cleanup_irq_pool);
439 
440 /*
441  * Allocate the IRQs required by a given fsl-mc device.
442  */
fsl_mc_allocate_irqs(struct fsl_mc_device * mc_dev)443 int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev)
444 {
445 	int i;
446 	int irq_count;
447 	int res_allocated_count = 0;
448 	int error = -EINVAL;
449 	struct fsl_mc_device_irq **irqs = NULL;
450 	struct fsl_mc_bus *mc_bus;
451 	struct fsl_mc_resource_pool *res_pool;
452 
453 	if (mc_dev->irqs)
454 		return -EINVAL;
455 
456 	irq_count = mc_dev->obj_desc.irq_count;
457 	if (irq_count == 0)
458 		return -EINVAL;
459 
460 	if (is_fsl_mc_bus_dprc(mc_dev))
461 		mc_bus = to_fsl_mc_bus(mc_dev);
462 	else
463 		mc_bus = to_fsl_mc_bus(to_fsl_mc_device(mc_dev->dev.parent));
464 
465 	if (!mc_bus->irq_resources)
466 		return -EINVAL;
467 
468 	res_pool = &mc_bus->resource_pools[FSL_MC_POOL_IRQ];
469 	if (res_pool->free_count < irq_count) {
470 		dev_err(&mc_dev->dev,
471 			"Not able to allocate %u irqs for device\n", irq_count);
472 		return -ENOSPC;
473 	}
474 
475 	irqs = devm_kcalloc(&mc_dev->dev, irq_count, sizeof(irqs[0]),
476 			    GFP_KERNEL);
477 	if (!irqs)
478 		return -ENOMEM;
479 
480 	for (i = 0; i < irq_count; i++) {
481 		struct fsl_mc_resource *resource;
482 
483 		error = fsl_mc_resource_allocate(mc_bus, FSL_MC_POOL_IRQ,
484 						 &resource);
485 		if (error < 0)
486 			goto error_resource_alloc;
487 
488 		irqs[i] = to_fsl_mc_irq(resource);
489 		res_allocated_count++;
490 
491 		irqs[i]->mc_dev = mc_dev;
492 		irqs[i]->dev_irq_index = i;
493 	}
494 
495 	mc_dev->irqs = irqs;
496 	return 0;
497 
498 error_resource_alloc:
499 	for (i = 0; i < res_allocated_count; i++) {
500 		irqs[i]->mc_dev = NULL;
501 		fsl_mc_resource_free(&irqs[i]->resource);
502 	}
503 
504 	return error;
505 }
506 EXPORT_SYMBOL_GPL(fsl_mc_allocate_irqs);
507 
508 /*
509  * Frees the IRQs that were allocated for an fsl-mc device.
510  */
fsl_mc_free_irqs(struct fsl_mc_device * mc_dev)511 void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev)
512 {
513 	int i;
514 	int irq_count;
515 	struct fsl_mc_bus *mc_bus;
516 	struct fsl_mc_device_irq **irqs = mc_dev->irqs;
517 
518 	if (!irqs)
519 		return;
520 
521 	irq_count = mc_dev->obj_desc.irq_count;
522 
523 	if (is_fsl_mc_bus_dprc(mc_dev))
524 		mc_bus = to_fsl_mc_bus(mc_dev);
525 	else
526 		mc_bus = to_fsl_mc_bus(to_fsl_mc_device(mc_dev->dev.parent));
527 
528 	if (!mc_bus->irq_resources)
529 		return;
530 
531 	for (i = 0; i < irq_count; i++) {
532 		irqs[i]->mc_dev = NULL;
533 		fsl_mc_resource_free(&irqs[i]->resource);
534 	}
535 
536 	mc_dev->irqs = NULL;
537 }
538 EXPORT_SYMBOL_GPL(fsl_mc_free_irqs);
539 
fsl_mc_init_all_resource_pools(struct fsl_mc_device * mc_bus_dev)540 void fsl_mc_init_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
541 {
542 	int pool_type;
543 	struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
544 
545 	for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++) {
546 		struct fsl_mc_resource_pool *res_pool =
547 		    &mc_bus->resource_pools[pool_type];
548 
549 		res_pool->type = pool_type;
550 		res_pool->max_count = 0;
551 		res_pool->free_count = 0;
552 		res_pool->mc_bus = mc_bus;
553 		INIT_LIST_HEAD(&res_pool->free_list);
554 		mutex_init(&res_pool->mutex);
555 	}
556 }
557 
fsl_mc_cleanup_resource_pool(struct fsl_mc_device * mc_bus_dev,enum fsl_mc_pool_type pool_type)558 static void fsl_mc_cleanup_resource_pool(struct fsl_mc_device *mc_bus_dev,
559 					 enum fsl_mc_pool_type pool_type)
560 {
561 	struct fsl_mc_resource *resource;
562 	struct fsl_mc_resource *next;
563 	struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
564 	struct fsl_mc_resource_pool *res_pool =
565 					&mc_bus->resource_pools[pool_type];
566 
567 	list_for_each_entry_safe(resource, next, &res_pool->free_list, node)
568 		devm_kfree(&mc_bus_dev->dev, resource);
569 }
570 
fsl_mc_cleanup_all_resource_pools(struct fsl_mc_device * mc_bus_dev)571 void fsl_mc_cleanup_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
572 {
573 	int pool_type;
574 
575 	for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++)
576 		fsl_mc_cleanup_resource_pool(mc_bus_dev, pool_type);
577 }
578 
579 /*
580  * fsl_mc_allocator_probe - callback invoked when an allocatable device is
581  * being added to the system
582  */
fsl_mc_allocator_probe(struct fsl_mc_device * mc_dev)583 static int fsl_mc_allocator_probe(struct fsl_mc_device *mc_dev)
584 {
585 	enum fsl_mc_pool_type pool_type;
586 	struct fsl_mc_device *mc_bus_dev;
587 	struct fsl_mc_bus *mc_bus;
588 	int error;
589 
590 	if (!fsl_mc_is_allocatable(mc_dev))
591 		return -EINVAL;
592 
593 	mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
594 	if (!dev_is_fsl_mc(&mc_bus_dev->dev))
595 		return -EINVAL;
596 
597 	mc_bus = to_fsl_mc_bus(mc_bus_dev);
598 	error = object_type_to_pool_type(mc_dev->obj_desc.type, &pool_type);
599 	if (error < 0)
600 		return error;
601 
602 	error = fsl_mc_resource_pool_add_device(mc_bus, pool_type, mc_dev);
603 	if (error < 0)
604 		return error;
605 
606 	dev_dbg(&mc_dev->dev,
607 		"Allocatable fsl-mc device bound to fsl_mc_allocator driver");
608 	return 0;
609 }
610 
611 /*
612  * fsl_mc_allocator_remove - callback invoked when an allocatable device is
613  * being removed from the system
614  */
fsl_mc_allocator_remove(struct fsl_mc_device * mc_dev)615 static void fsl_mc_allocator_remove(struct fsl_mc_device *mc_dev)
616 {
617 	int error;
618 
619 	if (mc_dev->resource) {
620 		error = fsl_mc_resource_pool_remove_device(mc_dev);
621 		if (error < 0)
622 			return;
623 	}
624 
625 	dev_dbg(&mc_dev->dev,
626 		"Allocatable fsl-mc device unbound from fsl_mc_allocator driver");
627 }
628 
629 static const struct fsl_mc_device_id match_id_table[] = {
630 	{
631 	 .vendor = FSL_MC_VENDOR_FREESCALE,
632 	 .obj_type = "dpbp",
633 	},
634 	{
635 	 .vendor = FSL_MC_VENDOR_FREESCALE,
636 	 .obj_type = "dpmcp",
637 	},
638 	{
639 	 .vendor = FSL_MC_VENDOR_FREESCALE,
640 	 .obj_type = "dpcon",
641 	},
642 	{.vendor = 0x0},
643 };
644 
645 static struct fsl_mc_driver fsl_mc_allocator_driver = {
646 	.driver = {
647 		   .name = "fsl_mc_allocator",
648 		   .pm = NULL,
649 		   },
650 	.match_id_table = match_id_table,
651 	.probe = fsl_mc_allocator_probe,
652 	.remove = fsl_mc_allocator_remove,
653 };
654 
fsl_mc_allocator_driver_init(void)655 int __init fsl_mc_allocator_driver_init(void)
656 {
657 	return fsl_mc_driver_register(&fsl_mc_allocator_driver);
658 }
659 
fsl_mc_allocator_driver_exit(void)660 void fsl_mc_allocator_driver_exit(void)
661 {
662 	fsl_mc_driver_unregister(&fsl_mc_allocator_driver);
663 }
664