LXR 6.1/​cpukit/​libmisc/​shell/​main_drvmgr.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

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

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /*
  * DRVMGR Command Implementation
  *
  * COPYRIGHT (c) 2010.
  * 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.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <inttypes.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <drvmgr/drvmgr.h>
 
 #include <rtems.h>
 #include <rtems/shell.h>
 #include "internal.h"
 
 static void usage(void);
 
 static void *get_obj_adr(char *arg)
 {
   unsigned long obj_adr;
 
   obj_adr = strtoul(arg, NULL, 16);
   if (obj_adr == ULONG_MAX || obj_adr == 0) {
     puts(" Not a valid ID");
     return NULL;
   }
 
   return (void *)obj_adr;
 }
 
 /* General info, root bus, number of devices etc. */
 static void show_drvmgr_info(void)
 {
   drvmgr_summary();
   drvmgr_print_devs(PRINT_DEVS_ALL);
 }
 
 static int shell_drvmgr_topo(int argc, char *argv[])
 {
   drvmgr_print_topo();
   return 0;
 }
 
 static int shell_drvmgr_short(int argc, char *argv[])
 {
   void *obj;
 
   if (argc < 2)
     return -1;
   if (argc < 3) {
     /* All Devices */
     drvmgr_info_drvs(0);
     drvmgr_info_buses(0);
     drvmgr_info_devs(OPTION_DEV_GENINFO);
     return 0;
   }
 
   /* Get ID from string */
   obj = get_obj_adr(argv[2]);
   if (!obj)
     return -3;
 
   drvmgr_info(obj, OPTION_DEV_GENINFO);
 
   return 0;
 }
 
 static int shell_drvmgr_info(int argc, char *argv[])
 {
   void *obj;
 
   if (argc < 2)
     return -1;
   if (argc < 3) {
     /* All Drivers, Buses and Devices */
     drvmgr_info_drvs(OPTION_INFO_ALL);
     drvmgr_info_buses(OPTION_INFO_ALL);
     drvmgr_info_devs(OPTION_INFO_ALL);
     return 0;
   }
 
   /* Get ID from string */
   obj = get_obj_adr(argv[2]);
   if (!obj)
     return -3;
 
   drvmgr_info(obj, OPTION_INFO_ALL);
 
   return 0;
 }
 
 static int shell_drvmgr_remove(int argc, char *argv[])
 {
   puts(" Not implemented");
   return 0;
 }
 
 static int shell_drvmgr_parent(int argc, char *argv[])
 {
   void *obj;
   int obj_type;
   struct drvmgr_dev *dev;
   struct drvmgr_bus *bus;
 
   /* Get ID from string */
   if (argc < 3)
     return -2;
   obj = get_obj_adr(argv[2]);
   if (!obj)
     return -3;
 
   obj_type = *(int *)obj;
   if (obj_type == DRVMGR_OBJ_BUS) {
     bus = obj;
     if (!bus->dev) {
       puts(" bus has no bridge device");
     } else if(!bus->dev->parent) {
       puts(" bridge device has no parent");
     } else {
       dev = bus->dev;
       printf(" BUSID=%p\n", dev->parent);
     }
   } else if (obj_type == DRVMGR_OBJ_DEV) {
     dev = obj;
     if (!dev->parent) {
       puts(" device has no parent bus");
     } else {
       printf(" BUSID=%p\n", dev->parent);
     }
   } else {
     puts(" ID is not a device or bus");
     return 1;
   }
 
   return 0;
 }
 
 static void shell_drvmgr_print_key_array(struct drvmgr_key *keys)
 {
   struct drvmgr_key *key;
   static char *type_strs[4] = {"UNKNOWN","INTEGER","STRING ","POINTER"};
   enum drvmgr_kt type;
   union drvmgr_key_value *val;
 
   if (keys == NULL) {
     printf("  DEV HAS NO KEYS\n");
     return;
   }
 
   key = &keys[0];
   while (key->key_type != DRVMGR_KT_NONE) {
     if (key->key_type > DRVMGR_KT_POINTER)
       type = DRVMGR_KT_NONE;
     else
       type = key->key_type;
     printf("  NAME=%-14s TYPE=%s  VALUE=", key->key_name, type_strs[type]);
     val = &key->key_value;
     switch (type) {
       default:
       case DRVMGR_KT_NONE:
       case DRVMGR_KT_INT:
         printf("0x%x (%d)\n", val->i, val->i);
         break;
       case DRVMGR_KT_STRING:
         printf("%s\n", val->str);
         break;
       case DRVMGR_KT_POINTER:
         printf("%p\n", val->ptr);
         break;
     }
     key++;
   }
 }
 
 static void shell_drvmgr_print_res_array(struct drvmgr_drv_res *resources)
 {
   struct drvmgr_drv_res *res = &resources[0];
   struct drvmgr_drv *drv;
   char *drv_name;
 
   while (res->drv_id) {
     /* Find Driver in order to print name of driver */
     drv = drvmgr_drv_by_id(res->drv_id);
     if (drv && drv->name)
       drv_name = drv->name;
     else
       drv_name = "UNKNOWN";
     printf(" RESOURCES FOR DEVICE[%02d] DRIVER[0x%" PRIu64 " (%s)]\n",
             res->minor_bus, res->drv_id, drv_name);
     shell_drvmgr_print_key_array(res->keys);
     res++;
   }
 }
 
 static int shell_drvmgr_res(int argc, char *argv[])
 {
   void *obj;
   int obj_type;
   struct drvmgr_dev *dev;
   struct drvmgr_bus *bus;
   struct drvmgr_key *keys;
   struct drvmgr_bus_res *lst;
   int i;
 
   /* Get ID from string */
   if (argc < 3)
     return -2;
   obj = get_obj_adr(argv[2]);
   if (!obj)
     return -3;
 
   obj_type = *(int *)obj;
   if (obj_type == DRVMGR_OBJ_BUS) {
     bus = obj;
     lst = bus->reslist;
     if (lst == NULL) {
       puts(" BUS does not have resources\n");
       return 0;
     }
     i = 0;
     while (lst) {
       printf(" -- RESOURCES ARRAY %d --\n", i);
       shell_drvmgr_print_res_array(lst->resource);
       puts("");
       i++;
       lst = lst->next;
     }
   } else if (obj_type == DRVMGR_OBJ_DEV) {
     dev = obj;
     if (dev->drv == NULL) {
       puts(" DEVICE has no driver ==> resources not available\n");
       return 0;
     }
     drvmgr_keys_get(dev, &keys);
     if (keys == NULL) {
       puts(" DEVICE does not have resources\n");
       return 0;
     }
     shell_drvmgr_print_key_array(keys);
   } else {
     puts(" ID is not a device or bus");
     return 1;
   }
 
   return 0;
 }
 
 static int shell_drvmgr_buses(int argc, char *argv[])
 {
   drvmgr_info_buses(OPTION_INFO_ALL);
   return 0;
 }
 
 static int shell_drvmgr_devs(int argc, char *argv[])
 {
   drvmgr_info_devs(OPTION_INFO_ALL);
   return 0;
 }
 
 static int shell_drvmgr_drvs(int argc, char *argv[])
 {
   drvmgr_info_drvs(OPTION_INFO_ALL);
   return 0;
 }
 
 static int shell_drvmgr_mem(int argc, char *argv[])
 {
   drvmgr_print_mem();
   return 0;
 }
 
 static int shell_drvmgr_translate(int argc, char *argv[])
 {
   int rc, rev, up, obj_type;
   void *obj, *dst;
   unsigned long src, tmp;
 
   if (argc != 5)
     return -1;
 
   obj = get_obj_adr(argv[2]);
   if (!obj)
     return -3;
 
   obj_type = *(int *)obj;
   if (obj_type != DRVMGR_OBJ_DEV) {
     puts(" ID is not a device\n");
     return 0;
   }
 
   tmp = strtoul(argv[3], NULL, 0);
   if (tmp > 3) {
     puts(" Not a valid option OPT, only [0..3] is valid");
     return 0;
   }
   rev = tmp & DRVMGR_TR_REVERSE;
   up = tmp & DRVMGR_TR_PATH;
 
   src = strtoul(argv[4], NULL, 0);
   if (src == ULONG_MAX && errno == ERANGE) {
     puts(" Not a valid source address");
     return 0;
   }
 
   rc = drvmgr_translate((struct drvmgr_dev *)obj, up | rev, (void *)src, &dst);
   if (rc == 0)
     printf(" Address %p could not be translated\n", (void *)src);
   else if (rc == 0xffffffff)
     printf(" %p => %p  (no translation required)\n", (void *)src, dst);
   else
     printf(" %p => %p  (map size 0x%x)\n", (void *)src, dst, rc);
 
   return 0;
 }
 
 static const char drvmgr_usage_str[] =
  " usage:\n"
  "  drvmgr buses         List bus specfic information on all buses\n"
  "  drvmgr devs          List general and driver specfic information\n"
  "                       about all devices\n"
  "  drvmgr drvs          List driver specfic information on all drivers\n"
  "  drvmgr info [ID]     List general and driver specfic information\n"
  "                       about all devices or one device, bus or driver\n"
  "  drvmgr mem           Dynamically memory usage\n"
  "  drvmgr parent ID     Short info about parent bus of a device\n"
  "  drvmgr remove ID     Remove a device or a bus\n"
  "  drvmgr res ID        List Resources of a device or bus\n"
  "  drvmgr short [ID]    Short info about all devices/buses or one\n"
  "                       device/bus\n"
  "  drvmgr topo          Show bus topology with all devices\n"
  "  drvmgr tr ID OPT ADR Translate ADR down(0)/up(1) -streams (OPT bit 1) in\n"
  "                       std(0)/reverse(1) (OPT bit 0) direction for device\n"
  "  drvmgr --help\n";
 
 static void usage(void)
 {
   puts(drvmgr_usage_str);
 }
 
 static int shell_drvmgr_usage(int argc, char *argv[])
 {
   usage();
   return 0;
 }
 
 struct shell_drvmgr_modifier {
   char *name;
   int (*func)(int argc, char *argv[]);
 };
 
 #define MODIFIER_NUM 12
 static struct shell_drvmgr_modifier shell_drvmgr_modifiers[MODIFIER_NUM] =
 {
   {"buses", shell_drvmgr_buses},
   {"devs", shell_drvmgr_devs},
   {"drvs", shell_drvmgr_drvs},
   {"info", shell_drvmgr_info},
   {"mem", shell_drvmgr_mem},
   {"parent", shell_drvmgr_parent},
   {"remove", shell_drvmgr_remove},
   {"res", shell_drvmgr_res},
   {"short", shell_drvmgr_short},
   {"topo", shell_drvmgr_topo},
   {"tr", shell_drvmgr_translate},
   {"--help", shell_drvmgr_usage},
 };
 
 static struct shell_drvmgr_modifier *shell_drvmgr_find_modifier(char *name)
 {
   struct shell_drvmgr_modifier *mod;
   int i;
 
   if (name == NULL)
     return NULL;
 
   for (i=0, mod=&shell_drvmgr_modifiers[0]; i<MODIFIER_NUM; i++, mod++) {
     if (strcmp(name, mod->name) == 0)
       return mod;
   }
 
   return NULL;
 }
 
 static int rtems_shell_main_drvmgr(
   int   argc,
   char *argv[]
 )
 {
   struct shell_drvmgr_modifier *mod;
   int rc;
 
   if (argc < 2) {
     show_drvmgr_info();
     rc = 0;
   } else if ((mod=shell_drvmgr_find_modifier(argv[1])) != NULL) {
     rc = mod->func(argc, argv);
   } else {
     rc = -1;
   }
 
   if (rc < 0) {
     printf(" invalid argument\n");
     usage();
   }
 
   return rc;
 }
 
 rtems_shell_cmd_t rtems_shell_DRVMGR_Command = {
   "drvmgr",                      /* name */
   drvmgr_usage_str,              /* usage */
   "system",                      /* topic */
   rtems_shell_main_drvmgr,       /* command */
   NULL,                          /* alias */
   NULL                           /* next */
 };

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