source: rtems/cpukit/libdrvmgr/drvmgr_unregister.c

/* SPDX-License-Identifier: BSD-2-Clause */

/* Driver Manager Device Unregister (removal) implementation
 *
 * COPYRIGHT (c) 2011 Cobham Gaisler AB.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>

#include <drvmgr/drvmgr.h>
#include <drvmgr/drvmgr_list.h>
#include "drvmgr_internal.h"

/* Unregister all children on a bus.
 *
 * This function is called from the bus driver, from a "safe" state where
 * devices will not be added or removed on this particular bus at this time
 */
int drvmgr_children_unregister(struct drvmgr_bus *bus)
{
        int err;

        while (bus->children != NULL) {
                err = drvmgr_dev_unregister(bus->children);
                if (err != DRVMGR_OK) {
                        /* An error occurred */
                        bus->children->error = err;
                        return err;
                }
        }

        return DRVMGR_OK;
}

/* Unregister a BUS and all it's devices.
 *
 * It is up to the bus driver to remove all it's devices, either manually
 * one by one calling drvmgr_dev_unregister(), or by letting the driver
 * manager unregister all children by calling drvmgr_children_unregister().
 */
int drvmgr_bus_unregister(struct drvmgr_bus *bus)
{
        struct drvmgr *mgr = &drvmgr;
        struct drvmgr_list *list;

        if (bus->ops->remove == NULL)
                return DRVMGR_ENOSYS;

        /* Call Bus driver to clean things up, it must remove all children */
        bus->error = bus->ops->remove(bus);
        if (bus->error != DRVMGR_OK)
                return bus->error;
        /* Check that bus driver has done its job and removed all children */
        if (bus->children != NULL)
                return DRVMGR_FAIL;
        /* Remove References to bus */
        bus->dev->bus = NULL;

        DRVMGR_LOCK_WRITE();

        /* Remove bus from bus-list */
        if (bus->state & BUS_STATE_LIST_INACTIVE)
                list = &mgr->buses_inactive;
        else
                list = &mgr->buses[bus->level];
        drvmgr_list_remove(list, bus);

        DRVMGR_UNLOCK();

        /* All references to this bus has been removed at this point */
        free(bus);

        return DRVMGR_OK;
}

/* Separate Driver and Device from each other */
int drvmgr_dev_drv_separate(struct drvmgr_dev *dev)
{
        struct drvmgr *mgr = &drvmgr;
        struct drvmgr_dev *subdev, **pprev;
        int rc;

        /* Remove children if this device exports a bus of devices. All
         * children must be removed first as they depend upon the bus
         * services this bridge provide.
         */
        if (dev->bus) {
                rc = drvmgr_bus_unregister(dev->bus);
                if (rc != DRVMGR_OK)
                        return rc;
        }

        if (dev->drv == NULL)
                return DRVMGR_OK;

        /* Remove device by letting assigned driver take care of hardware
         * issues
         */
        if (!dev->drv->ops->remove) {
                /* No remove function is considered severe when someone
                 * is trying to remove the device
                 */
                return DRVMGR_ENOSYS;
        }
        dev->error = dev->drv->ops->remove(dev);
        if (dev->error != DRVMGR_OK)
                return DRVMGR_FAIL;

        DRVMGR_LOCK_WRITE();

        /* Delete device from driver's device list */
        pprev = &dev->drv->dev;
        subdev = dev->drv->dev;
        while (subdev != dev) {
                pprev = &subdev->next_in_drv;
                subdev = subdev->next_in_drv;
        }
        *pprev = subdev->next_in_drv;
        dev->drv->dev_cnt--;

        /* Move device to inactive list */
        drvmgr_list_remove(&mgr->devices[dev->level], dev);
        dev->level = 0;
        dev->state &= ~(DEV_STATE_UNITED|DEV_STATE_INIT_DONE);
        dev->state |= DEV_STATE_LIST_INACTIVE;
        drvmgr_list_add_tail(&mgr->devices_inactive, dev);

        DRVMGR_UNLOCK();

        /* Free Device Driver Private memory if allocated previously by
         * Driver manager.
         */
        if (dev->drv->dev_priv_size && dev->priv) {
                free(dev->priv);
                dev->priv = NULL;
        }
        dev->drv = NULL;

        return DRVMGR_OK;
}

/* Unregister device,
 *  - let assigned driver handle deletion
 *  - remove from device list
 *  - remove from driver list
 *  - remove from bus list
 */
int drvmgr_dev_unregister(struct drvmgr_dev *dev)
{
        struct drvmgr *mgr = &drvmgr;
        struct drvmgr_dev *subdev, **pprev;
        int err;

        /* Separate device from driver, if the device is united with a driver.
         *
         * If this device is a bridge all child buses/devices are also removed.
         */
        err = drvmgr_dev_drv_separate(dev);
        if (err != DRVMGR_OK)
                return err;

        DRVMGR_LOCK_WRITE();

        /* Remove it from inactive list */
        drvmgr_list_remove(&mgr->devices_inactive, dev);

        /* Remove device from parent bus list (no check if dev not in list) */
        pprev = &dev->parent->children;
        subdev = dev->parent->children;
        while (subdev != dev) {
                pprev = &subdev->next_in_bus;
                subdev = subdev->next_in_bus;
        }
        *pprev = subdev->next_in_bus;
        dev->parent->dev_cnt--;

        DRVMGR_UNLOCK();

        /* All references to this device has been removed at this point */
        free(dev);

        return DRVMGR_OK;
}