tree bea4f461c6a3c2ff01a70d3c52644b93619ac37d
parent d3d5fa829a19ba48646e2317064af7ad299d1559
author George Liu <liuxiwei@inspur.com> 1573119759 +0800
committer Deepak Kodihalli <dkodihal@in.ibm.com> 1573824306 +0000

Fixup command line options

pldmtool BASE/BIOS/OEM -c/--command [GetPLDMTypes/GetPLDMVersion]
base/bios/fru/oem works
pldmtool -r/--raw 0x00 ... works

Tested:
pldmtool -h
PLDM requester tool for OpenBMC
Usage: pldmtool [SUBCOMMAND] [OPTIONS]
Options:
  -h,--help                   Print this help message and exit
  -r,--raw TEXT ...           Send a RAW PLDM request and print response
Subcommands:
  BASE                        PLDM Command Type = BASE
  BIOS                        PLDM Command Type = BIOS
  OEM                         PLDM Command Type = OEM

pldmtool BASE -h
PLDM Command Type = BASE
Usage: pldmtool BASE [OPTIONS]

Options:
  -h,--help                   Print this help message and exit
  -c,--command TEXT ...       PLDM request command
                              [GetPLDMTypes] Get PLDM Type
                              [GetPLDMVersion] Get PLDM Version

Signed-off-by: George Liu <liuxiwei@inspur.com>
Change-Id: Idb3a09bbaefec54546e9fba8aaa82541862e7bb1
