890 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Freescale data path resource container (DPRC) driver4 *5 * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.6 * Copyright 2019-2020 NXP7 * Author: German Rivera <German.Rivera@freescale.com>8 *9 */10 11#include <linux/module.h>12#include <linux/slab.h>13#include <linux/interrupt.h>14#include <linux/fsl/mc.h>15 16#include "fsl-mc-private.h"17 18#define FSL_MC_DPRC_DRIVER_NAME "fsl_mc_dprc"19 20struct fsl_mc_child_objs {21 int child_count;22 struct fsl_mc_obj_desc *child_array;23};24 25static bool fsl_mc_device_match(struct fsl_mc_device *mc_dev,26 struct fsl_mc_obj_desc *obj_desc)27{28 return mc_dev->obj_desc.id == obj_desc->id &&29 strcmp(mc_dev->obj_desc.type, obj_desc->type) == 0;30}31 32static bool fsl_mc_obj_desc_is_allocatable(struct fsl_mc_obj_desc *obj)33{34 if (strcmp(obj->type, "dpmcp") == 0 ||35 strcmp(obj->type, "dpcon") == 0 ||36 strcmp(obj->type, "dpbp") == 0)37 return true;38 else39 return false;40}41 42static int __fsl_mc_device_remove_if_not_in_mc(struct device *dev, void *data)43{44 int i;45 struct fsl_mc_child_objs *objs;46 struct fsl_mc_device *mc_dev;47 48 if (!dev_is_fsl_mc(dev))49 return 0;50 51 mc_dev = to_fsl_mc_device(dev);52 objs = data;53 54 for (i = 0; i < objs->child_count; i++) {55 struct fsl_mc_obj_desc *obj_desc = &objs->child_array[i];56 57 if (strlen(obj_desc->type) != 0 &&58 fsl_mc_device_match(mc_dev, obj_desc))59 break;60 }61 62 if (i == objs->child_count)63 fsl_mc_device_remove(mc_dev);64 65 return 0;66}67 68static int __fsl_mc_device_remove(struct device *dev, void *data)69{70 if (!dev_is_fsl_mc(dev))71 return 0;72 73 fsl_mc_device_remove(to_fsl_mc_device(dev));74 return 0;75}76 77/**78 * dprc_remove_devices - Removes devices for objects removed from a DPRC79 *80 * @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object81 * @obj_desc_array: array of object descriptors for child objects currently82 * present in the DPRC in the MC.83 * @num_child_objects_in_mc: number of entries in obj_desc_array84 *85 * Synchronizes the state of the Linux bus driver with the actual state of86 * the MC by removing devices that represent MC objects that have87 * been dynamically removed in the physical DPRC.88 */89void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev,90 struct fsl_mc_obj_desc *obj_desc_array,91 int num_child_objects_in_mc)92{93 if (num_child_objects_in_mc != 0) {94 /*95 * Remove child objects that are in the DPRC in Linux,96 * but not in the MC:97 */98 struct fsl_mc_child_objs objs;99 100 objs.child_count = num_child_objects_in_mc;101 objs.child_array = obj_desc_array;102 device_for_each_child(&mc_bus_dev->dev, &objs,103 __fsl_mc_device_remove_if_not_in_mc);104 } else {105 /*106 * There are no child objects for this DPRC in the MC.107 * So, remove all the child devices from Linux:108 */109 device_for_each_child(&mc_bus_dev->dev, NULL,110 __fsl_mc_device_remove);111 }112}113EXPORT_SYMBOL_GPL(dprc_remove_devices);114 115static int __fsl_mc_device_match(struct device *dev, void *data)116{117 struct fsl_mc_obj_desc *obj_desc = data;118 struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);119 120 return fsl_mc_device_match(mc_dev, obj_desc);121}122 123struct fsl_mc_device *fsl_mc_device_lookup(struct fsl_mc_obj_desc *obj_desc,124 struct fsl_mc_device *mc_bus_dev)125{126 struct device *dev;127 128 dev = device_find_child(&mc_bus_dev->dev, obj_desc,129 __fsl_mc_device_match);130 131 return dev ? to_fsl_mc_device(dev) : NULL;132}133 134/**135 * check_plugged_state_change - Check change in an MC object's plugged state136 *137 * @mc_dev: pointer to the fsl-mc device for a given MC object138 * @obj_desc: pointer to the MC object's descriptor in the MC139 *140 * If the plugged state has changed from unplugged to plugged, the fsl-mc141 * device is bound to the corresponding device driver.142 * If the plugged state has changed from plugged to unplugged, the fsl-mc143 * device is unbound from the corresponding device driver.144 */145static void check_plugged_state_change(struct fsl_mc_device *mc_dev,146 struct fsl_mc_obj_desc *obj_desc)147{148 int error;149 u32 plugged_flag_at_mc =150 obj_desc->state & FSL_MC_OBJ_STATE_PLUGGED;151 152 if (plugged_flag_at_mc !=153 (mc_dev->obj_desc.state & FSL_MC_OBJ_STATE_PLUGGED)) {154 if (plugged_flag_at_mc) {155 mc_dev->obj_desc.state |= FSL_MC_OBJ_STATE_PLUGGED;156 error = device_attach(&mc_dev->dev);157 if (error < 0) {158 dev_err(&mc_dev->dev,159 "device_attach() failed: %d\n",160 error);161 }162 } else {163 mc_dev->obj_desc.state &= ~FSL_MC_OBJ_STATE_PLUGGED;164 device_release_driver(&mc_dev->dev);165 }166 }167}168 169static void fsl_mc_obj_device_add(struct fsl_mc_device *mc_bus_dev,170 struct fsl_mc_obj_desc *obj_desc)171{172 int error;173 struct fsl_mc_device *child_dev;174 175 /*176 * Check if device is already known to Linux:177 */178 child_dev = fsl_mc_device_lookup(obj_desc, mc_bus_dev);179 if (child_dev) {180 check_plugged_state_change(child_dev, obj_desc);181 put_device(&child_dev->dev);182 } else {183 error = fsl_mc_device_add(obj_desc, NULL, &mc_bus_dev->dev,184 &child_dev);185 if (error < 0)186 return;187 }188}189 190/**191 * dprc_add_new_devices - Adds devices to the logical bus for a DPRC192 *193 * @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object194 * @obj_desc_array: array of device descriptors for child devices currently195 * present in the physical DPRC.196 * @num_child_objects_in_mc: number of entries in obj_desc_array197 *198 * Synchronizes the state of the Linux bus driver with the actual199 * state of the MC by adding objects that have been newly discovered200 * in the physical DPRC.201 */202static void dprc_add_new_devices(struct fsl_mc_device *mc_bus_dev,203 struct fsl_mc_obj_desc *obj_desc_array,204 int num_child_objects_in_mc)205{206 int i;207 208 /* probe the allocable objects first */209 for (i = 0; i < num_child_objects_in_mc; i++) {210 struct fsl_mc_obj_desc *obj_desc = &obj_desc_array[i];211 212 if (strlen(obj_desc->type) > 0 &&213 fsl_mc_obj_desc_is_allocatable(obj_desc))214 fsl_mc_obj_device_add(mc_bus_dev, obj_desc);215 }216 217 for (i = 0; i < num_child_objects_in_mc; i++) {218 struct fsl_mc_obj_desc *obj_desc = &obj_desc_array[i];219 220 if (strlen(obj_desc->type) > 0 &&221 !fsl_mc_obj_desc_is_allocatable(obj_desc))222 fsl_mc_obj_device_add(mc_bus_dev, obj_desc);223 }224}225 226/**227 * dprc_scan_objects - Discover objects in a DPRC228 *229 * @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object230 * @alloc_interrupts: if true the function allocates the interrupt pool,231 * otherwise the interrupt allocation is delayed232 *233 * Detects objects added and removed from a DPRC and synchronizes the234 * state of the Linux bus driver, MC by adding and removing235 * devices accordingly.236 * Two types of devices can be found in a DPRC: allocatable objects (e.g.,237 * dpbp, dpmcp) and non-allocatable devices (e.g., dprc, dpni).238 * All allocatable devices needed to be probed before all non-allocatable239 * devices, to ensure that device drivers for non-allocatable240 * devices can allocate any type of allocatable devices.241 * That is, we need to ensure that the corresponding resource pools are242 * populated before they can get allocation requests from probe callbacks243 * of the device drivers for the non-allocatable devices.244 */245int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev,246 bool alloc_interrupts)247{248 int num_child_objects;249 int dprc_get_obj_failures;250 int error;251 unsigned int irq_count = mc_bus_dev->obj_desc.irq_count;252 struct fsl_mc_obj_desc *child_obj_desc_array = NULL;253 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);254 255 error = dprc_get_obj_count(mc_bus_dev->mc_io,256 0,257 mc_bus_dev->mc_handle,258 &num_child_objects);259 if (error < 0) {260 dev_err(&mc_bus_dev->dev, "dprc_get_obj_count() failed: %d\n",261 error);262 return error;263 }264 265 if (num_child_objects != 0) {266 int i;267 268 child_obj_desc_array =269 devm_kmalloc_array(&mc_bus_dev->dev, num_child_objects,270 sizeof(*child_obj_desc_array),271 GFP_KERNEL);272 if (!child_obj_desc_array)273 return -ENOMEM;274 275 /*276 * Discover objects currently present in the physical DPRC:277 */278 dprc_get_obj_failures = 0;279 for (i = 0; i < num_child_objects; i++) {280 struct fsl_mc_obj_desc *obj_desc =281 &child_obj_desc_array[i];282 283 error = dprc_get_obj(mc_bus_dev->mc_io,284 0,285 mc_bus_dev->mc_handle,286 i, obj_desc);287 if (error < 0) {288 dev_err(&mc_bus_dev->dev,289 "dprc_get_obj(i=%d) failed: %d\n",290 i, error);291 /*292 * Mark the obj entry as "invalid", by using the293 * empty string as obj type:294 */295 obj_desc->type[0] = '\0';296 obj_desc->id = error;297 dprc_get_obj_failures++;298 continue;299 }300 301 /*302 * add a quirk for all versions of dpsec < 4.0...none303 * are coherent regardless of what the MC reports.304 */305 if ((strcmp(obj_desc->type, "dpseci") == 0) &&306 (obj_desc->ver_major < 4))307 obj_desc->flags |=308 FSL_MC_OBJ_FLAG_NO_MEM_SHAREABILITY;309 310 irq_count += obj_desc->irq_count;311 dev_dbg(&mc_bus_dev->dev,312 "Discovered object: type %s, id %d\n",313 obj_desc->type, obj_desc->id);314 }315 316 if (dprc_get_obj_failures != 0) {317 dev_err(&mc_bus_dev->dev,318 "%d out of %d devices could not be retrieved\n",319 dprc_get_obj_failures, num_child_objects);320 }321 }322 323 /*324 * Allocate IRQ's before binding the scanned devices with their325 * respective drivers.326 */327 if (dev_get_msi_domain(&mc_bus_dev->dev)) {328 if (irq_count > FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS) {329 dev_warn(&mc_bus_dev->dev,330 "IRQs needed (%u) exceed IRQs preallocated (%u)\n",331 irq_count, FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);332 }333 334 if (alloc_interrupts && !mc_bus->irq_resources) {335 error = fsl_mc_populate_irq_pool(mc_bus_dev,336 FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);337 if (error < 0)338 return error;339 }340 }341 342 dprc_remove_devices(mc_bus_dev, child_obj_desc_array,343 num_child_objects);344 345 dprc_add_new_devices(mc_bus_dev, child_obj_desc_array,346 num_child_objects);347 348 if (child_obj_desc_array)349 devm_kfree(&mc_bus_dev->dev, child_obj_desc_array);350 351 return 0;352}353 354/**355 * dprc_scan_container - Scans a physical DPRC and synchronizes Linux bus state356 *357 * @mc_bus_dev: pointer to the fsl-mc device that represents a DPRC object358 * @alloc_interrupts: if true the function allocates the interrupt pool,359 * otherwise the interrupt allocation is delayed360 * Scans the physical DPRC and synchronizes the state of the Linux361 * bus driver with the actual state of the MC by adding and removing362 * devices as appropriate.363 */364int dprc_scan_container(struct fsl_mc_device *mc_bus_dev,365 bool alloc_interrupts)366{367 int error = 0;368 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);369 370 fsl_mc_init_all_resource_pools(mc_bus_dev);371 372 /*373 * Discover objects in the DPRC:374 */375 mutex_lock(&mc_bus->scan_mutex);376 error = dprc_scan_objects(mc_bus_dev, alloc_interrupts);377 mutex_unlock(&mc_bus->scan_mutex);378 379 return error;380}381EXPORT_SYMBOL_GPL(dprc_scan_container);382 383/**384 * dprc_irq0_handler - Regular ISR for DPRC interrupt 0385 *386 * @irq_num: IRQ number of the interrupt being handled387 * @arg: Pointer to device structure388 */389static irqreturn_t dprc_irq0_handler(int irq_num, void *arg)390{391 return IRQ_WAKE_THREAD;392}393 394/**395 * dprc_irq0_handler_thread - Handler thread function for DPRC interrupt 0396 *397 * @irq_num: IRQ number of the interrupt being handled398 * @arg: Pointer to device structure399 */400static irqreturn_t dprc_irq0_handler_thread(int irq_num, void *arg)401{402 int error;403 u32 status;404 struct device *dev = arg;405 struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);406 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);407 struct fsl_mc_io *mc_io = mc_dev->mc_io;408 int irq = mc_dev->irqs[0]->virq;409 410 dev_dbg(dev, "DPRC IRQ %d triggered on CPU %u\n",411 irq_num, smp_processor_id());412 413 if (!(mc_dev->flags & FSL_MC_IS_DPRC))414 return IRQ_HANDLED;415 416 mutex_lock(&mc_bus->scan_mutex);417 if (irq != (u32)irq_num)418 goto out;419 420 status = 0;421 error = dprc_get_irq_status(mc_io, 0, mc_dev->mc_handle, 0,422 &status);423 if (error < 0) {424 dev_err(dev,425 "dprc_get_irq_status() failed: %d\n", error);426 goto out;427 }428 429 error = dprc_clear_irq_status(mc_io, 0, mc_dev->mc_handle, 0,430 status);431 if (error < 0) {432 dev_err(dev,433 "dprc_clear_irq_status() failed: %d\n", error);434 goto out;435 }436 437 if (status & (DPRC_IRQ_EVENT_OBJ_ADDED |438 DPRC_IRQ_EVENT_OBJ_REMOVED |439 DPRC_IRQ_EVENT_CONTAINER_DESTROYED |440 DPRC_IRQ_EVENT_OBJ_DESTROYED |441 DPRC_IRQ_EVENT_OBJ_CREATED)) {442 443 error = dprc_scan_objects(mc_dev, true);444 if (error < 0) {445 /*446 * If the error is -ENXIO, we ignore it, as it indicates447 * that the object scan was aborted, as we detected that448 * an object was removed from the DPRC in the MC, while449 * we were scanning the DPRC.450 */451 if (error != -ENXIO) {452 dev_err(dev, "dprc_scan_objects() failed: %d\n",453 error);454 }455 456 goto out;457 }458 }459 460out:461 mutex_unlock(&mc_bus->scan_mutex);462 return IRQ_HANDLED;463}464 465/*466 * Disable and clear interrupt for a given DPRC object467 */468int disable_dprc_irq(struct fsl_mc_device *mc_dev)469{470 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);471 int error;472 struct fsl_mc_io *mc_io = mc_dev->mc_io;473 474 /*475 * Disable generation of interrupt, while we configure it:476 */477 error = dprc_set_irq_enable(mc_io, 0, mc_dev->mc_handle, 0, 0);478 if (error < 0) {479 dev_err(&mc_dev->dev,480 "Disabling DPRC IRQ failed: dprc_set_irq_enable() failed: %d\n",481 error);482 return error;483 }484 485 /*486 * Disable all interrupt causes for the interrupt:487 */488 error = dprc_set_irq_mask(mc_io, 0, mc_dev->mc_handle, 0, 0x0);489 if (error < 0) {490 dev_err(&mc_dev->dev,491 "Disabling DPRC IRQ failed: dprc_set_irq_mask() failed: %d\n",492 error);493 return error;494 }495 496 /*497 * Clear any leftover interrupts:498 */499 error = dprc_clear_irq_status(mc_io, 0, mc_dev->mc_handle, 0, ~0x0U);500 if (error < 0) {501 dev_err(&mc_dev->dev,502 "Disabling DPRC IRQ failed: dprc_clear_irq_status() failed: %d\n",503 error);504 return error;505 }506 507 mc_bus->irq_enabled = 0;508 509 return 0;510}511 512int get_dprc_irq_state(struct fsl_mc_device *mc_dev)513{514 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);515 516 return mc_bus->irq_enabled;517}518 519static int register_dprc_irq_handler(struct fsl_mc_device *mc_dev)520{521 int error;522 struct fsl_mc_device_irq *irq = mc_dev->irqs[0];523 524 /*525 * NOTE: devm_request_threaded_irq() invokes the device-specific526 * function that programs the MSI physically in the device527 */528 error = devm_request_threaded_irq(&mc_dev->dev,529 irq->virq,530 dprc_irq0_handler,531 dprc_irq0_handler_thread,532 IRQF_NO_SUSPEND | IRQF_ONESHOT,533 dev_name(&mc_dev->dev),534 &mc_dev->dev);535 if (error < 0) {536 dev_err(&mc_dev->dev,537 "devm_request_threaded_irq() failed: %d\n",538 error);539 return error;540 }541 542 return 0;543}544 545int enable_dprc_irq(struct fsl_mc_device *mc_dev)546{547 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);548 int error;549 550 /*551 * Enable all interrupt causes for the interrupt:552 */553 error = dprc_set_irq_mask(mc_dev->mc_io, 0, mc_dev->mc_handle, 0,554 ~0x0u);555 if (error < 0) {556 dev_err(&mc_dev->dev,557 "Enabling DPRC IRQ failed: dprc_set_irq_mask() failed: %d\n",558 error);559 560 return error;561 }562 563 /*564 * Enable generation of the interrupt:565 */566 error = dprc_set_irq_enable(mc_dev->mc_io, 0, mc_dev->mc_handle, 0, 1);567 if (error < 0) {568 dev_err(&mc_dev->dev,569 "Enabling DPRC IRQ failed: dprc_set_irq_enable() failed: %d\n",570 error);571 572 return error;573 }574 575 mc_bus->irq_enabled = 1;576 577 return 0;578}579 580/*581 * Setup interrupt for a given DPRC device582 */583static int dprc_setup_irq(struct fsl_mc_device *mc_dev)584{585 int error;586 587 error = fsl_mc_allocate_irqs(mc_dev);588 if (error < 0)589 return error;590 591 error = disable_dprc_irq(mc_dev);592 if (error < 0)593 goto error_free_irqs;594 595 error = register_dprc_irq_handler(mc_dev);596 if (error < 0)597 goto error_free_irqs;598 599 error = enable_dprc_irq(mc_dev);600 if (error < 0)601 goto error_free_irqs;602 603 return 0;604 605error_free_irqs:606 fsl_mc_free_irqs(mc_dev);607 return error;608}609 610/**611 * dprc_setup - opens and creates a mc_io for DPRC612 *613 * @mc_dev: Pointer to fsl-mc device representing a DPRC614 *615 * It opens the physical DPRC in the MC.616 * It configures the DPRC portal used to communicate with MC617 */618 619int dprc_setup(struct fsl_mc_device *mc_dev)620{621 struct device *parent_dev = mc_dev->dev.parent;622 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);623 struct irq_domain *mc_msi_domain;624 bool mc_io_created = false;625 bool msi_domain_set = false;626 bool uapi_created = false;627 u16 major_ver, minor_ver;628 size_t region_size;629 int error;630 631 if (!is_fsl_mc_bus_dprc(mc_dev))632 return -EINVAL;633 634 if (dev_get_msi_domain(&mc_dev->dev))635 return -EINVAL;636 637 if (!mc_dev->mc_io) {638 /*639 * This is a child DPRC:640 */641 if (!dev_is_fsl_mc(parent_dev))642 return -EINVAL;643 644 if (mc_dev->obj_desc.region_count == 0)645 return -EINVAL;646 647 region_size = resource_size(mc_dev->regions);648 649 error = fsl_create_mc_io(&mc_dev->dev,650 mc_dev->regions[0].start,651 region_size,652 NULL,653 FSL_MC_IO_ATOMIC_CONTEXT_PORTAL,654 &mc_dev->mc_io);655 if (error < 0)656 return error;657 658 mc_io_created = true;659 } else {660 error = fsl_mc_uapi_create_device_file(mc_bus);661 if (error < 0)662 return -EPROBE_DEFER;663 uapi_created = true;664 }665 666 mc_msi_domain = fsl_mc_find_msi_domain(&mc_dev->dev);667 if (!mc_msi_domain) {668 dev_warn(&mc_dev->dev,669 "WARNING: MC bus without interrupt support\n");670 } else {671 dev_set_msi_domain(&mc_dev->dev, mc_msi_domain);672 msi_domain_set = true;673 }674 675 error = dprc_open(mc_dev->mc_io, 0, mc_dev->obj_desc.id,676 &mc_dev->mc_handle);677 if (error < 0) {678 dev_err(&mc_dev->dev, "dprc_open() failed: %d\n", error);679 goto error_cleanup_msi_domain;680 }681 682 error = dprc_get_attributes(mc_dev->mc_io, 0, mc_dev->mc_handle,683 &mc_bus->dprc_attr);684 if (error < 0) {685 dev_err(&mc_dev->dev, "dprc_get_attributes() failed: %d\n",686 error);687 goto error_cleanup_open;688 }689 690 error = dprc_get_api_version(mc_dev->mc_io, 0,691 &major_ver,692 &minor_ver);693 if (error < 0) {694 dev_err(&mc_dev->dev, "dprc_get_api_version() failed: %d\n",695 error);696 goto error_cleanup_open;697 }698 699 if (major_ver < DPRC_MIN_VER_MAJOR) {700 dev_err(&mc_dev->dev,701 "ERROR: DPRC version %d.%d not supported\n",702 major_ver, minor_ver);703 error = -ENOTSUPP;704 goto error_cleanup_open;705 }706 707 return 0;708 709error_cleanup_open:710 (void)dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);711 712error_cleanup_msi_domain:713 if (msi_domain_set)714 dev_set_msi_domain(&mc_dev->dev, NULL);715 716 if (mc_io_created) {717 fsl_destroy_mc_io(mc_dev->mc_io);718 mc_dev->mc_io = NULL;719 }720 721 if (uapi_created)722 fsl_mc_uapi_remove_device_file(mc_bus);723 724 return error;725}726EXPORT_SYMBOL_GPL(dprc_setup);727 728/**729 * dprc_probe - callback invoked when a DPRC is being bound to this driver730 *731 * @mc_dev: Pointer to fsl-mc device representing a DPRC732 *733 * It opens the physical DPRC in the MC.734 * It scans the DPRC to discover the MC objects contained in it.735 * It creates the interrupt pool for the MC bus associated with the DPRC.736 * It configures the interrupts for the DPRC device itself.737 */738static int dprc_probe(struct fsl_mc_device *mc_dev)739{740 int error;741 742 error = dprc_setup(mc_dev);743 if (error < 0)744 return error;745 746 /*747 * Discover MC objects in DPRC object:748 */749 error = dprc_scan_container(mc_dev, true);750 if (error < 0)751 goto dprc_cleanup;752 753 /*754 * Configure interrupt for the DPRC object associated with this MC bus:755 */756 error = dprc_setup_irq(mc_dev);757 if (error < 0)758 goto scan_cleanup;759 760 dev_info(&mc_dev->dev, "DPRC device bound to driver");761 return 0;762 763scan_cleanup:764 device_for_each_child(&mc_dev->dev, NULL, __fsl_mc_device_remove);765dprc_cleanup:766 dprc_cleanup(mc_dev);767 return error;768}769 770/*771 * Tear down interrupt for a given DPRC object772 */773static void dprc_teardown_irq(struct fsl_mc_device *mc_dev)774{775 struct fsl_mc_device_irq *irq = mc_dev->irqs[0];776 777 (void)disable_dprc_irq(mc_dev);778 779 devm_free_irq(&mc_dev->dev, irq->virq, &mc_dev->dev);780 781 fsl_mc_free_irqs(mc_dev);782}783 784/**785 * dprc_cleanup - function that cleanups a DPRC786 *787 * @mc_dev: Pointer to fsl-mc device representing the DPRC788 *789 * It closes the DPRC device in the MC.790 * It destroys the interrupt pool associated with this MC bus.791 */792 793int dprc_cleanup(struct fsl_mc_device *mc_dev)794{795 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);796 int error;797 798 /* this function should be called only for DPRCs, it799 * is an error to call it for regular objects800 */801 if (!is_fsl_mc_bus_dprc(mc_dev))802 return -EINVAL;803 804 if (dev_get_msi_domain(&mc_dev->dev)) {805 fsl_mc_cleanup_irq_pool(mc_dev);806 dev_set_msi_domain(&mc_dev->dev, NULL);807 }808 809 fsl_mc_cleanup_all_resource_pools(mc_dev);810 811 /* if this step fails we cannot go further with cleanup as there is no way of812 * communicating with the firmware813 */814 if (!mc_dev->mc_io) {815 dev_err(&mc_dev->dev, "mc_io is NULL, tear down cannot be performed in firmware\n");816 return -EINVAL;817 }818 819 error = dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);820 if (error < 0)821 dev_err(&mc_dev->dev, "dprc_close() failed: %d\n", error);822 823 if (!fsl_mc_is_root_dprc(&mc_dev->dev)) {824 fsl_destroy_mc_io(mc_dev->mc_io);825 mc_dev->mc_io = NULL;826 } else {827 fsl_mc_uapi_remove_device_file(mc_bus);828 }829 830 return 0;831}832EXPORT_SYMBOL_GPL(dprc_cleanup);833 834/**835 * dprc_remove - callback invoked when a DPRC is being unbound from this driver836 *837 * @mc_dev: Pointer to fsl-mc device representing the DPRC838 *839 * It removes the DPRC's child objects from Linux (not from the MC) and840 * closes the DPRC device in the MC.841 * It tears down the interrupts that were configured for the DPRC device.842 * It destroys the interrupt pool associated with this MC bus.843 */844static void dprc_remove(struct fsl_mc_device *mc_dev)845{846 struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev);847 848 if (!mc_bus->irq_resources) {849 dev_err(&mc_dev->dev, "No irq resources, so unbinding the device failed\n");850 return;851 }852 853 if (dev_get_msi_domain(&mc_dev->dev))854 dprc_teardown_irq(mc_dev);855 856 device_for_each_child(&mc_dev->dev, NULL, __fsl_mc_device_remove);857 858 dprc_cleanup(mc_dev);859 860 dev_info(&mc_dev->dev, "DPRC device unbound from driver");861}862 863static const struct fsl_mc_device_id match_id_table[] = {864 {865 .vendor = FSL_MC_VENDOR_FREESCALE,866 .obj_type = "dprc"},867 {.vendor = 0x0},868};869 870static struct fsl_mc_driver dprc_driver = {871 .driver = {872 .name = FSL_MC_DPRC_DRIVER_NAME,873 .owner = THIS_MODULE,874 .pm = NULL,875 },876 .match_id_table = match_id_table,877 .probe = dprc_probe,878 .remove = dprc_remove,879};880 881int __init dprc_driver_init(void)882{883 return fsl_mc_driver_register(&dprc_driver);884}885 886void dprc_driver_exit(void)887{888 fsl_mc_driver_unregister(&dprc_driver);889}890