2015-03-06 01:29:11 +00:00
|
|
|
/*
|
|
|
|
* Freescale data path resource container (DPRC) driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2014 Freescale Semiconductor, Inc.
|
|
|
|
* Author: German Rivera <German.Rivera@freescale.com>
|
|
|
|
*
|
|
|
|
* This file is licensed under the terms of the GNU General Public
|
|
|
|
* License version 2. This program is licensed "as is" without any
|
|
|
|
* warranty of any kind, whether express or implied.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "../include/mc-private.h"
|
|
|
|
#include "../include/mc-sys.h"
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include "dprc-cmd.h"
|
|
|
|
|
|
|
|
struct dprc_child_objs {
|
|
|
|
int child_count;
|
|
|
|
struct dprc_obj_desc *child_array;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __fsl_mc_device_remove_if_not_in_mc(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct dprc_child_objs *objs;
|
|
|
|
struct fsl_mc_device *mc_dev;
|
|
|
|
|
|
|
|
WARN_ON(!dev);
|
|
|
|
WARN_ON(!data);
|
|
|
|
mc_dev = to_fsl_mc_device(dev);
|
|
|
|
objs = data;
|
|
|
|
|
|
|
|
for (i = 0; i < objs->child_count; i++) {
|
|
|
|
struct dprc_obj_desc *obj_desc = &objs->child_array[i];
|
|
|
|
|
|
|
|
if (strlen(obj_desc->type) != 0 &&
|
|
|
|
FSL_MC_DEVICE_MATCH(mc_dev, obj_desc))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == objs->child_count)
|
|
|
|
fsl_mc_device_remove(mc_dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __fsl_mc_device_remove(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
WARN_ON(!dev);
|
|
|
|
WARN_ON(data);
|
|
|
|
fsl_mc_device_remove(to_fsl_mc_device(dev));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dprc_remove_devices - Removes devices for objects removed from a DPRC
|
|
|
|
*
|
|
|
|
* @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object
|
|
|
|
* @obj_desc_array: array of object descriptors for child objects currently
|
|
|
|
* present in the DPRC in the MC.
|
|
|
|
* @num_child_objects_in_mc: number of entries in obj_desc_array
|
|
|
|
*
|
|
|
|
* Synchronizes the state of the Linux bus driver with the actual state of
|
|
|
|
* the MC by removing devices that represent MC objects that have
|
|
|
|
* been dynamically removed in the physical DPRC.
|
|
|
|
*/
|
|
|
|
static void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev,
|
|
|
|
struct dprc_obj_desc *obj_desc_array,
|
|
|
|
int num_child_objects_in_mc)
|
|
|
|
{
|
|
|
|
if (num_child_objects_in_mc != 0) {
|
|
|
|
/*
|
|
|
|
* Remove child objects that are in the DPRC in Linux,
|
|
|
|
* but not in the MC:
|
|
|
|
*/
|
|
|
|
struct dprc_child_objs objs;
|
|
|
|
|
|
|
|
objs.child_count = num_child_objects_in_mc;
|
|
|
|
objs.child_array = obj_desc_array;
|
|
|
|
device_for_each_child(&mc_bus_dev->dev, &objs,
|
|
|
|
__fsl_mc_device_remove_if_not_in_mc);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* There are no child objects for this DPRC in the MC.
|
|
|
|
* So, remove all the child devices from Linux:
|
|
|
|
*/
|
|
|
|
device_for_each_child(&mc_bus_dev->dev, NULL,
|
|
|
|
__fsl_mc_device_remove);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __fsl_mc_device_match(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct dprc_obj_desc *obj_desc = data;
|
|
|
|
struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
|
|
|
|
|
|
|
|
return FSL_MC_DEVICE_MATCH(mc_dev, obj_desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct fsl_mc_device *fsl_mc_device_lookup(struct dprc_obj_desc
|
|
|
|
*obj_desc,
|
|
|
|
struct fsl_mc_device
|
|
|
|
*mc_bus_dev)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
dev = device_find_child(&mc_bus_dev->dev, obj_desc,
|
|
|
|
__fsl_mc_device_match);
|
|
|
|
|
|
|
|
return dev ? to_fsl_mc_device(dev) : NULL;
|
|
|
|
}
|
|
|
|
|
2015-03-27 21:01:06 +00:00
|
|
|
/**
|
|
|
|
* check_plugged_state_change - Check change in an MC object's plugged state
|
|
|
|
*
|
|
|
|
* @mc_dev: pointer to the fsl-mc device for a given MC object
|
|
|
|
* @obj_desc: pointer to the MC object's descriptor in the MC
|
|
|
|
*
|
|
|
|
* If the plugged state has changed from unplugged to plugged, the fsl-mc
|
|
|
|
* device is bound to the corresponding device driver.
|
|
|
|
* If the plugged state has changed from plugged to unplugged, the fsl-mc
|
|
|
|
* device is unbound from the corresponding device driver.
|
|
|
|
*/
|
|
|
|
static void check_plugged_state_change(struct fsl_mc_device *mc_dev,
|
|
|
|
struct dprc_obj_desc *obj_desc)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
uint32_t plugged_flag_at_mc =
|
|
|
|
(obj_desc->state & DPRC_OBJ_STATE_PLUGGED);
|
|
|
|
|
|
|
|
if (plugged_flag_at_mc !=
|
|
|
|
(mc_dev->obj_desc.state & DPRC_OBJ_STATE_PLUGGED)) {
|
|
|
|
if (plugged_flag_at_mc) {
|
|
|
|
mc_dev->obj_desc.state |= DPRC_OBJ_STATE_PLUGGED;
|
|
|
|
error = device_attach(&mc_dev->dev);
|
|
|
|
if (error < 0) {
|
|
|
|
dev_err(&mc_dev->dev,
|
|
|
|
"device_attach() failed: %d\n",
|
|
|
|
error);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mc_dev->obj_desc.state &= ~DPRC_OBJ_STATE_PLUGGED;
|
|
|
|
device_release_driver(&mc_dev->dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-06 01:29:11 +00:00
|
|
|
/**
|
|
|
|
* dprc_add_new_devices - Adds devices to the logical bus for a DPRC
|
|
|
|
*
|
|
|
|
* @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object
|
|
|
|
* @obj_desc_array: array of device descriptors for child devices currently
|
|
|
|
* present in the physical DPRC.
|
|
|
|
* @num_child_objects_in_mc: number of entries in obj_desc_array
|
|
|
|
*
|
|
|
|
* Synchronizes the state of the Linux bus driver with the actual
|
|
|
|
* state of the MC by adding objects that have been newly discovered
|
|
|
|
* in the physical DPRC.
|
|
|
|
*/
|
|
|
|
static void dprc_add_new_devices(struct fsl_mc_device *mc_bus_dev,
|
|
|
|
struct dprc_obj_desc *obj_desc_array,
|
|
|
|
int num_child_objects_in_mc)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_child_objects_in_mc; i++) {
|
|
|
|
struct fsl_mc_device *child_dev;
|
|
|
|
struct dprc_obj_desc *obj_desc = &obj_desc_array[i];
|
|
|
|
|
|
|
|
if (strlen(obj_desc->type) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if device is already known to Linux:
|
|
|
|
*/
|
|
|
|
child_dev = fsl_mc_device_lookup(obj_desc, mc_bus_dev);
|
2015-03-27 21:01:06 +00:00
|
|
|
if (child_dev) {
|
|
|
|
check_plugged_state_change(child_dev, obj_desc);
|
2015-03-06 01:29:11 +00:00
|
|
|
continue;
|
2015-03-27 21:01:06 +00:00
|
|
|
}
|
2015-03-06 01:29:11 +00:00
|
|
|
|
2015-03-27 21:01:07 +00:00
|
|
|
error = fsl_mc_device_add(obj_desc, NULL, &mc_bus_dev->dev,
|
2015-03-06 01:29:11 +00:00
|
|
|
&child_dev);
|
2015-03-27 21:01:07 +00:00
|
|
|
if (error < 0)
|
2015-03-06 01:29:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-06 01:35:25 +00:00
|
|
|
static void dprc_init_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
|
|
|
|
{
|
|
|
|
int pool_type;
|
|
|
|
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
|
|
|
|
|
|
|
|
for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++) {
|
|
|
|
struct fsl_mc_resource_pool *res_pool =
|
|
|
|
&mc_bus->resource_pools[pool_type];
|
|
|
|
|
|
|
|
res_pool->type = pool_type;
|
|
|
|
res_pool->max_count = 0;
|
|
|
|
res_pool->free_count = 0;
|
|
|
|
res_pool->mc_bus = mc_bus;
|
|
|
|
INIT_LIST_HEAD(&res_pool->free_list);
|
|
|
|
mutex_init(&res_pool->mutex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dprc_cleanup_resource_pool(struct fsl_mc_device *mc_bus_dev,
|
|
|
|
enum fsl_mc_pool_type pool_type)
|
|
|
|
{
|
|
|
|
struct fsl_mc_resource *resource;
|
|
|
|
struct fsl_mc_resource *next;
|
|
|
|
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
|
|
|
|
struct fsl_mc_resource_pool *res_pool =
|
|
|
|
&mc_bus->resource_pools[pool_type];
|
|
|
|
int free_count = 0;
|
|
|
|
|
|
|
|
WARN_ON(res_pool->type != pool_type);
|
|
|
|
WARN_ON(res_pool->free_count != res_pool->max_count);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(resource, next, &res_pool->free_list, node) {
|
|
|
|
free_count++;
|
|
|
|
WARN_ON(resource->type != res_pool->type);
|
|
|
|
WARN_ON(resource->parent_pool != res_pool);
|
|
|
|
devm_kfree(&mc_bus_dev->dev, resource);
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(free_count != res_pool->free_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dprc_cleanup_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
|
|
|
|
{
|
|
|
|
int pool_type;
|
|
|
|
|
|
|
|
for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++)
|
|
|
|
dprc_cleanup_resource_pool(mc_bus_dev, pool_type);
|
|
|
|
}
|
|
|
|
|
2015-03-06 01:29:11 +00:00
|
|
|
/**
|
|
|
|
* dprc_scan_objects - Discover objects in a DPRC
|
|
|
|
*
|
|
|
|
* @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object
|
|
|
|
*
|
|
|
|
* Detects objects added and removed from a DPRC and synchronizes the
|
|
|
|
* state of the Linux bus driver, MC by adding and removing
|
|
|
|
* devices accordingly.
|
2015-03-06 01:35:25 +00:00
|
|
|
* Two types of devices can be found in a DPRC: allocatable objects (e.g.,
|
|
|
|
* dpbp, dpmcp) and non-allocatable devices (e.g., dprc, dpni).
|
|
|
|
* All allocatable devices needed to be probed before all non-allocatable
|
|
|
|
* devices, to ensure that device drivers for non-allocatable
|
|
|
|
* devices can allocate any type of allocatable devices.
|
|
|
|
* That is, we need to ensure that the corresponding resource pools are
|
|
|
|
* populated before they can get allocation requests from probe callbacks
|
|
|
|
* of the device drivers for the non-allocatable devices.
|
2015-03-06 01:29:11 +00:00
|
|
|
*/
|
|
|
|
int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev)
|
|
|
|
{
|
|
|
|
int num_child_objects;
|
|
|
|
int dprc_get_obj_failures;
|
|
|
|
int error;
|
|
|
|
struct dprc_obj_desc *child_obj_desc_array = NULL;
|
|
|
|
|
|
|
|
error = dprc_get_obj_count(mc_bus_dev->mc_io,
|
|
|
|
mc_bus_dev->mc_handle,
|
|
|
|
&num_child_objects);
|
|
|
|
if (error < 0) {
|
|
|
|
dev_err(&mc_bus_dev->dev, "dprc_get_obj_count() failed: %d\n",
|
|
|
|
error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_child_objects != 0) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
child_obj_desc_array =
|
|
|
|
devm_kmalloc_array(&mc_bus_dev->dev, num_child_objects,
|
|
|
|
sizeof(*child_obj_desc_array),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!child_obj_desc_array)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discover objects currently present in the physical DPRC:
|
|
|
|
*/
|
|
|
|
dprc_get_obj_failures = 0;
|
|
|
|
for (i = 0; i < num_child_objects; i++) {
|
|
|
|
struct dprc_obj_desc *obj_desc =
|
|
|
|
&child_obj_desc_array[i];
|
|
|
|
|
|
|
|
error = dprc_get_obj(mc_bus_dev->mc_io,
|
|
|
|
mc_bus_dev->mc_handle,
|
|
|
|
i, obj_desc);
|
|
|
|
if (error < 0) {
|
|
|
|
dev_err(&mc_bus_dev->dev,
|
|
|
|
"dprc_get_obj(i=%d) failed: %d\n",
|
|
|
|
i, error);
|
|
|
|
/*
|
|
|
|
* Mark the obj entry as "invalid", by using the
|
|
|
|
* empty string as obj type:
|
|
|
|
*/
|
|
|
|
obj_desc->type[0] = '\0';
|
|
|
|
obj_desc->id = error;
|
|
|
|
dprc_get_obj_failures++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(&mc_bus_dev->dev,
|
|
|
|
"Discovered object: type %s, id %d\n",
|
|
|
|
obj_desc->type, obj_desc->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dprc_get_obj_failures != 0) {
|
|
|
|
dev_err(&mc_bus_dev->dev,
|
|
|
|
"%d out of %d devices could not be retrieved\n",
|
|
|
|
dprc_get_obj_failures, num_child_objects);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dprc_remove_devices(mc_bus_dev, child_obj_desc_array,
|
|
|
|
num_child_objects);
|
|
|
|
|
|
|
|
dprc_add_new_devices(mc_bus_dev, child_obj_desc_array,
|
|
|
|
num_child_objects);
|
|
|
|
|
|
|
|
if (child_obj_desc_array)
|
|
|
|
devm_kfree(&mc_bus_dev->dev, child_obj_desc_array);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dprc_scan_objects);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dprc_scan_container - Scans a physical DPRC and synchronizes Linux bus state
|
|
|
|
*
|
|
|
|
* @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object
|
|
|
|
*
|
|
|
|
* Scans the physical DPRC and synchronizes the state of the Linux
|
|
|
|
* bus driver with the actual state of the MC by adding and removing
|
|
|
|
* devices as appropriate.
|
|
|
|
*/
|
|
|
|
int dprc_scan_container(struct fsl_mc_device *mc_bus_dev)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
|
|
|
|
|
2015-03-06 01:35:25 +00:00
|
|
|
dprc_init_all_resource_pools(mc_bus_dev);
|
|
|
|
|
2015-03-06 01:29:11 +00:00
|
|
|
/*
|
|
|
|
* Discover objects in the DPRC:
|
|
|
|
*/
|
|
|
|
mutex_lock(&mc_bus->scan_mutex);
|
|
|
|
error = dprc_scan_objects(mc_bus_dev);
|
|
|
|
mutex_unlock(&mc_bus->scan_mutex);
|
2015-03-06 01:35:25 +00:00
|
|
|
if (error < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
dprc_cleanup_all_resource_pools(mc_bus_dev);
|
2015-03-06 01:29:11 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dprc_scan_container);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dprc_probe - callback invoked when a DPRC is being bound to this driver
|
|
|
|
*
|
|
|
|
* @mc_dev: Pointer to fsl-mc device representing a DPRC
|
|
|
|
*
|
|
|
|
* It opens the physical DPRC in the MC.
|
|
|
|
* It scans the DPRC to discover the MC objects contained in it.
|
2015-03-06 01:35:25 +00:00
|
|
|
* It creates the interrupt pool for the MC bus associated with the DPRC.
|
|
|
|
* It configures the interrupts for the DPRC device itself.
|
2015-03-06 01:29:11 +00:00
|
|
|
*/
|
|
|
|
static int dprc_probe(struct fsl_mc_device *mc_dev)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
size_t region_size;
|
|
|
|
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);
|
|
|
|
|
|
|
|
if (WARN_ON(strcmp(mc_dev->obj_desc.type, "dprc") != 0))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!mc_dev->mc_io) {
|
|
|
|
/*
|
|
|
|
* This is a child DPRC:
|
|
|
|
*/
|
|
|
|
if (WARN_ON(mc_dev->obj_desc.region_count == 0))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
region_size = mc_dev->regions[0].end -
|
|
|
|
mc_dev->regions[0].start + 1;
|
|
|
|
|
|
|
|
error = fsl_create_mc_io(&mc_dev->dev,
|
|
|
|
mc_dev->regions[0].start,
|
|
|
|
region_size,
|
2015-03-06 01:35:25 +00:00
|
|
|
NULL, 0, &mc_dev->mc_io);
|
2015-03-06 01:29:11 +00:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = dprc_open(mc_dev->mc_io, mc_dev->obj_desc.id,
|
|
|
|
&mc_dev->mc_handle);
|
|
|
|
if (error < 0) {
|
|
|
|
dev_err(&mc_dev->dev, "dprc_open() failed: %d\n", error);
|
|
|
|
goto error_cleanup_mc_io;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_init(&mc_bus->scan_mutex);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discover MC objects in DPRC object:
|
|
|
|
*/
|
|
|
|
error = dprc_scan_container(mc_dev);
|
|
|
|
if (error < 0)
|
|
|
|
goto error_cleanup_open;
|
|
|
|
|
|
|
|
dev_info(&mc_dev->dev, "DPRC device bound to driver");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_cleanup_open:
|
|
|
|
(void)dprc_close(mc_dev->mc_io, mc_dev->mc_handle);
|
|
|
|
|
|
|
|
error_cleanup_mc_io:
|
|
|
|
fsl_destroy_mc_io(mc_dev->mc_io);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dprc_remove - callback invoked when a DPRC is being unbound from this driver
|
|
|
|
*
|
|
|
|
* @mc_dev: Pointer to fsl-mc device representing the DPRC
|
|
|
|
*
|
|
|
|
* It removes the DPRC's child objects from Linux (not from the MC) and
|
|
|
|
* closes the DPRC device in the MC.
|
2015-03-06 01:35:25 +00:00
|
|
|
* It tears down the interrupts that were configured for the DPRC device.
|
|
|
|
* It destroys the interrupt pool associated with this MC bus.
|
2015-03-06 01:29:11 +00:00
|
|
|
*/
|
|
|
|
static int dprc_remove(struct fsl_mc_device *mc_dev)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (WARN_ON(strcmp(mc_dev->obj_desc.type, "dprc") != 0))
|
|
|
|
return -EINVAL;
|
|
|
|
if (WARN_ON(!mc_dev->mc_io))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
device_for_each_child(&mc_dev->dev, NULL, __fsl_mc_device_remove);
|
2015-03-06 01:35:25 +00:00
|
|
|
dprc_cleanup_all_resource_pools(mc_dev);
|
2015-03-06 01:29:11 +00:00
|
|
|
error = dprc_close(mc_dev->mc_io, mc_dev->mc_handle);
|
|
|
|
if (error < 0)
|
|
|
|
dev_err(&mc_dev->dev, "dprc_close() failed: %d\n", error);
|
|
|
|
|
|
|
|
dev_info(&mc_dev->dev, "DPRC device unbound from driver");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct fsl_mc_device_match_id match_id_table[] = {
|
|
|
|
{
|
|
|
|
.vendor = FSL_MC_VENDOR_FREESCALE,
|
|
|
|
.obj_type = "dprc",
|
|
|
|
.ver_major = DPRC_VER_MAJOR,
|
|
|
|
.ver_minor = DPRC_VER_MINOR},
|
|
|
|
{.vendor = 0x0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fsl_mc_driver dprc_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = FSL_MC_DPRC_DRIVER_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.pm = NULL,
|
|
|
|
},
|
|
|
|
.match_id_table = match_id_table,
|
|
|
|
.probe = dprc_probe,
|
|
|
|
.remove = dprc_remove,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init dprc_driver_init(void)
|
|
|
|
{
|
|
|
|
return fsl_mc_driver_register(&dprc_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __exit dprc_driver_exit(void)
|
|
|
|
{
|
|
|
|
fsl_mc_driver_unregister(&dprc_driver);
|
|
|
|
}
|