LXR 6.1/​cpukit/​libdrvmgr/​drvmgr_print.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:16

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /* Driver Manager Information printing Interface Implementation
  *
  * COPYRIGHT (c) 2009 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.
  */
 
 /*
  *  These functions print stuff about the driver manager, what devices were
  *  found and were united with a driver, the Bus topology, memory taken, etc.
  *
  */
 
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <drvmgr/drvmgr.h>
 #include "drvmgr_internal.h"
 
 typedef void (*fun_ptr)(void);
 
 static int print_dev_found(struct drvmgr_dev *dev, void *arg)
 {
     char **pparg = arg;
 
     if (pparg && *pparg) {
         printf(*pparg);
         *pparg = NULL;
     }
 
     printf(" DEV %p  %s on bus %p\n", dev,
         dev->name ? dev->name : "NO_NAME", dev->parent);
 
     return 0; /* Continue to next device */
 }
 
 void drvmgr_print_devs(unsigned int options)
 {
     struct drvmgr *mgr = &drvmgr;
     char *parg;
 
     /* Print Drivers */
     if (options & PRINT_DEVS_ASSIGNED) {
         parg = " --- DEVICES ASSIGNED TO DRIVER ---\n";
         drvmgr_for_each_listdev(&mgr->devices[DRVMGR_LEVEL_MAX],
                 DEV_STATE_UNITED, 0, print_dev_found, &parg);
         if (parg != NULL)
             printf("\n NO DEVICES WERE ASSIGNED A DRIVER\n");
     }
 
     if (options & PRINT_DEVS_UNASSIGNED) {
         parg = "\n --- DEVICES WITHOUT DRIVER ---\n";
         drvmgr_for_each_listdev(&mgr->devices_inactive, 0,
             DEV_STATE_UNITED, print_dev_found, &parg);
         if (parg != NULL)
             printf("\n NO DEVICES WERE WITHOUT DRIVER\n");
     }
 
     if (options & PRINT_DEVS_FAILED) {
         parg = "\n --- DEVICES FAILED TO INITIALIZE ---\n";
         drvmgr_for_each_listdev(&mgr->devices_inactive,
             DEV_STATE_INIT_FAILED, 0, print_dev_found, &parg);
         if (parg != NULL)
             printf("\n NO DEVICES FAILED TO INITIALIZE\n");
     }
 
     if (options & PRINT_DEVS_IGNORED) {
         parg = "\n --- DEVICES IGNORED ---\n";
         drvmgr_for_each_listdev(&mgr->devices_inactive,
             DEV_STATE_IGNORED, 0, print_dev_found, &parg);
         if (parg != NULL)
             printf("\n NO DEVICES WERE IGNORED\n");
     }
 
     printf("\n\n");
 }
 
 static intptr_t drvmgr_topo_func(struct drvmgr_dev *dev, void *arg)
 {
     char prefix[32];
     int depth = dev->parent->depth;
 
     if (depth > 30)
         return 0; /* depth more than 30 not supported */
     memset(prefix, ' ', depth + 1);
     prefix[depth + 1] = '\0';
 
     printf(" %s|-> DEV  %p  %s\n", prefix, dev,
         dev->name ? dev->name :  "NO_NAME");
     return 0;
 }
 
 void drvmgr_print_topo(void)
 {
     /* Print Bus topology */
     printf(" --- BUS TOPOLOGY ---\n");
     drvmgr_for_each_dev(drvmgr_topo_func, NULL, DRVMGR_FED_DF);
     printf("\n\n");
 }
 
 /* Print the memory usage */
 void drvmgr_print_mem(void)
 {
     struct drvmgr *mgr = &drvmgr;
     struct drvmgr_bus *bus;
     struct drvmgr_dev *dev;
     struct drvmgr_drv *drv;
 
     struct drvmgr_bus_res *node;
     struct drvmgr_drv_res *res;
     struct drvmgr_key *key;
 
     unsigned int busmem = 0;
     unsigned int devmem = 0;
     unsigned int drvmem = 0;
     unsigned int resmem = 0;
     unsigned int devprivmem = 0;
 
     DRVMGR_LOCK_READ();
 
     bus = BUS_LIST_HEAD(&mgr->buses[DRVMGR_LEVEL_MAX]);
     while (bus) {
         busmem += sizeof(struct drvmgr_bus);
 
         /* Get size of resources on this bus */
         node = bus->reslist;
         while (node) {
             resmem += sizeof(struct drvmgr_bus_res);
 
             res = node->resource;
             while (res->keys) {
                 resmem += sizeof(struct drvmgr_drv_res);
 
                 key = res->keys;
                 while (key->key_type != DRVMGR_KT_NONE) {
                     resmem += sizeof
                         (struct drvmgr_key);
                     key++;
                 }
                 resmem += sizeof(struct drvmgr_key);
                 res++;
             }
 
             node = node->next;
         }
 
         bus = bus->next;
     }
 
     drv = DRV_LIST_HEAD(&mgr->drivers);
     while (drv) {
         drvmem += sizeof(struct drvmgr_drv);
         drv = drv->next;
     }
 
     dev = DEV_LIST_HEAD(&mgr->devices[DRVMGR_LEVEL_MAX]);
     while (dev) {
         devmem += sizeof(struct drvmgr_dev);
         if (dev->drv && dev->drv->dev_priv_size > 0)
             devprivmem += dev->drv->dev_priv_size;
         dev = dev->next;
     }
 
     DRVMGR_UNLOCK();
 
     printf(" --- MEMORY USAGE ---\n");
     printf(" BUS:          %d bytes\n", busmem);
     printf(" DRV:          %d bytes\n", drvmem);
     printf(" DEV:          %d bytes\n", devmem);
     printf(" DEV private:  %d bytes\n", devprivmem);
     printf(" RES:          %d bytes\n", resmem);
     printf(" TOTAL:        %d bytes\n",
             busmem + drvmem + devmem + devprivmem + resmem);
     printf("\n\n");
 }
 
 /* Print the memory usage */
 void drvmgr_summary(void)
 {
     struct drvmgr *mgr = &drvmgr;
     struct drvmgr_bus *bus;
     struct drvmgr_dev *dev;
     struct drvmgr_drv *drv;
     int i, buscnt = 0, devcnt = 0, drvcnt = 0;
 
     printf(" --- SUMMARY ---\n");
 
     drv = DRV_LIST_HEAD(&mgr->drivers);
     while (drv) {
         drvcnt++;
         drv = drv->next;
     }
     printf(" NUMBER OF DRIVERS:               %d\n", drvcnt);
 
     DRVMGR_LOCK_READ();
 
     for (i = 0; i <= DRVMGR_LEVEL_MAX; i++) {
         buscnt = 0;
         bus = BUS_LIST_HEAD(&mgr->buses[i]);
         while (bus) {
             buscnt++;
             bus = bus->next;
         }
         if (buscnt > 0) {
             printf(" NUMBER OF BUSES IN LEVEL[%d]:     %d\n",
                 i, buscnt);
         }
     }
 
     for (i = 0; i <= DRVMGR_LEVEL_MAX; i++) {
         devcnt = 0;
         dev = DEV_LIST_HEAD(&mgr->devices[i]);
         while (dev) {
             devcnt++;
             dev = dev->next;
         }
         if (devcnt > 0) {
             printf(" NUMBER OF DEVS IN LEVEL[%d]:      %d\n",
                 i, devcnt);
         }
     }
 
     DRVMGR_UNLOCK();
 
     printf("\n\n");
 }
 
 static void print_info(void *p, char *str)
 {
     printf("  ");
     puts(str);
 }
 
 void drvmgr_info_dev(struct drvmgr_dev *dev, unsigned int options)
 {
     if (!dev)
         return;
 
     printf(" -- DEVICE %p --\n", dev);
     if (options & OPTION_DEV_GENINFO) {
         printf("  PARENT BUS:  %p\n", dev->parent);
         printf("  NAME:        %s\n", dev->name ? dev->name : "NO_NAME");
         printf("  STATE:       0x%08x\n", dev->state);
         if (dev->bus)
             printf("  BRIDGE TO:   %p\n", dev->bus);
         printf("  INIT LEVEL:  %d\n", dev->level);
         printf("  ERROR:       %d\n", dev->error);
         printf("  MINOR BUS:   %d\n", dev->minor_bus);
         if (dev->drv) {
             printf("  MINOR DRV:   %d\n", dev->minor_drv);
             printf("  DRIVER:      %p (%s)\n", dev->drv,
                 dev->drv->name ? dev->drv->name : "NO_NAME");
             printf("  PRIVATE:     %p\n", dev->priv);
         }
     }
 
     if (options & OPTION_DEV_BUSINFO) {
         printf("  --- DEVICE INFO FROM BUS DRIVER ---\n");
         if (!dev->parent)
             printf("  !! device has no parent bus !!\n");
         else if (dev->parent->ops->get_info_dev)
             dev->parent->ops->get_info_dev(dev, print_info, NULL);
         else
             printf("  Bus doesn't implement get_info_dev func\n");
     }
 
     if (options & OPTION_DEV_DRVINFO) {
         if (dev->drv) {
             printf("  --- DEVICE INFO FROM DEVICE DRIVER ---\n");
             if (dev->drv->ops->info)
                 dev->drv->ops->info(dev, print_info, NULL, 0, 0);
             else
                 printf("  Driver doesn't implement info func\n");
         }
     }
 }
 
 static void drvmgr_info_bus_map(struct drvmgr_map_entry *map)
 {
     if (map == NULL)
         printf("    Addresses mapped 1:1\n");
     else if (map == DRVMGR_TRANSLATE_NO_BRIDGE)
         printf("    No bridge in this direction\n");
     else {
         while (map->size != 0) {
             printf("    0x%08lx-0x%08lx => 0x%08lx-0x%08lx  %s\n",
                 (unsigned long)map->from_adr,
                 (unsigned long)(map->from_adr + map->size - 1),
                 (unsigned long)map->to_adr,
                 (unsigned long)(map->to_adr + map->size - 1),
                 map->name ? map->name : "no label");
             map++;
         }
     }
 }
 
 void drvmgr_info_bus(struct drvmgr_bus *bus, unsigned int options)
 {
     struct drvmgr_dev *dev;
 
     /* Print Driver */
     printf("-- BUS %p --\n", bus);
     printf("  BUS TYPE:    %d\n", bus->bus_type);
     printf("  DEVICE:      %p (%s)\n", bus->dev,
         bus->dev->name ? bus->dev->name : "NO_NAME");
     printf("  OPS:         %p\n", bus->ops);
     printf("  CHILDREN:    %d devices\n", bus->dev_cnt);
     printf("  LEVEL:       %d\n", bus->level);
     printf("  STATE:       0x%08x\n", bus->state);
     printf("  ERROR:       %d\n", bus->error);
 
     /* Print address mappings up- (to parent) and down- (from parent to
      * this bus) stream the bridge of this bus
      */
     printf("  DOWN STREAMS BRIDGE MAPPINGS  (from parent to this bus)\n");
     drvmgr_info_bus_map(bus->maps_down);
     printf("  UP STREAMS BRIDGE MAPPINGS    (from this bus to parent)\n");
     drvmgr_info_bus_map(bus->maps_up);
 
     /* Print Devices on this bus? */
     if (options & OPTION_BUS_DEVS) {
         printf("  CHILDREN:\n");
         DRVMGR_LOCK_READ();
         dev = bus->children;
         while (dev) {
             printf("   |- DEV[%02d]: %p  %s\n", dev->minor_bus,
                 dev, dev->name ? dev->name : "NO_NAME");
             dev = dev->next_in_bus;
         }
         DRVMGR_UNLOCK();
     }
 }
 
 void drvmgr_info_drv(struct drvmgr_drv *drv, unsigned int options)
 {
     struct drvmgr_dev *dev;
     int i;
 
     /* Print Driver */
     printf(" -- DRIVER %p --\n", drv);
     printf("  DRIVER ID:   0x%" PRIx64 "\n", drv->drv_id);
     printf("  NAME:        %s\n", drv->name ? drv->name : "NO_NAME");
     printf("  BUS TYPE:    %d\n", drv->bus_type);
     printf("  OPERATIONS:\n");
     for (i = 0; i < DRVMGR_LEVEL_MAX; i++)
         printf("   init[%d]:    %p\n", i + 1, drv->ops->init[i]);
     printf("   remove:     %p\n", drv->ops->remove);
     printf("   info:       %p\n", drv->ops->info);
     printf("  NO. DEVICES: %d\n", drv->dev_cnt);
 
     /* Print devices united with this driver? */
     if (options & OPTION_DRV_DEVS) {
         DRVMGR_LOCK_READ();
         dev = drv->dev;
         while (dev) {
             printf("  DEV[%02d]:     %p  %s\n", dev->minor_drv,
                 dev, dev->name ? dev->name : "NO_NAME");
             dev = dev->next_in_drv;
         }
         DRVMGR_UNLOCK();
     }
 }
 
 void (*info_obj[3])(void *obj, unsigned int) = {
     /* DRVMGR_OBJ_DRV */ (void (*)(void *, unsigned int))drvmgr_info_drv,
     /* DRVMGR_OBJ_BUS */ (void (*)(void *, unsigned int))drvmgr_info_bus,
     /* DRVMGR_OBJ_DEV */ (void (*)(void *, unsigned int))drvmgr_info_dev,
 };
 
 /* Get information about a device/bus/driver */
 void drvmgr_info(void *id, unsigned int options)
 {
     int obj_type;
     void (*func)(void *, unsigned int);
 
     if (!id)
         return;
     obj_type = *(int *)id;
     if ((obj_type < DRVMGR_OBJ_DRV) || (obj_type > DRVMGR_OBJ_DEV))
         return;
     func = info_obj[obj_type - 1];
     func(id, options);
 }
 
 void drvmgr_info_devs_on_bus(struct drvmgr_bus *bus, unsigned int options)
 {
     struct drvmgr_dev *dev;
 
     /* Print All Devices on Bus */
     printf("\n\n  -= All Devices on BUS %p =-\n\n", bus);
     dev = bus->children;
     while (dev) {
         drvmgr_info_dev(dev, options);
         puts("");
         dev = dev->next_in_bus;
     }
 
     if ((options & OPTION_RECURSIVE) == 0)
         return;
 
     /* This device provides a bus, print the bus */
     dev = bus->children;
     while (dev) {
         if (dev->bus)
             drvmgr_info_devs_on_bus(dev->bus, options);
         dev = dev->next_in_bus;
     }
 }
 
 void drvmgr_info_devs(unsigned int options)
 {
     struct drvmgr *mgr = &drvmgr;
     struct drvmgr_dev *dev;
 
     /* Print device information of all devices and their child devices */
     dev = &mgr->root_dev;
     drvmgr_info_devs_on_bus(dev->bus, options);
     printf("\n\n");
 }
 
 void drvmgr_info_drvs(unsigned int options)
 {
     struct drvmgr *mgr = &drvmgr;
     struct drvmgr_drv *drv;
 
     drv = DRV_LIST_HEAD(&mgr->drivers);
     while (drv) {
         drvmgr_info_drv(drv, options);
         puts("\n");
         drv = drv->next;
     }
 }
 
 void drvmgr_info_buses(unsigned int options)
 {
     struct drvmgr *mgr = &drvmgr;
     struct drvmgr_bus *bus;
 
     bus = BUS_LIST_HEAD(&mgr->buses[DRVMGR_LEVEL_MAX]);
     while (bus) {
         drvmgr_info_bus(bus, options);
         puts("\n");
         bus = bus->next;
     }
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team