drivers/bus/fsl-mc/fsl-mc-allocator.c

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