1d5ace945SErwin T Tsaur /*
2d5ace945SErwin T Tsaur * CDDL HEADER START
3d5ace945SErwin T Tsaur *
4d5ace945SErwin T Tsaur * The contents of this file are subject to the terms of the
5d5ace945SErwin T Tsaur * Common Development and Distribution License (the "License").
6d5ace945SErwin T Tsaur * You may not use this file except in compliance with the License.
7d5ace945SErwin T Tsaur *
8d5ace945SErwin T Tsaur * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9d5ace945SErwin T Tsaur * or http://www.opensolaris.org/os/licensing.
10d5ace945SErwin T Tsaur * See the License for the specific language governing permissions
11d5ace945SErwin T Tsaur * and limitations under the License.
12d5ace945SErwin T Tsaur *
13d5ace945SErwin T Tsaur * When distributing Covered Code, include this CDDL HEADER in each
14d5ace945SErwin T Tsaur * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15d5ace945SErwin T Tsaur * If applicable, add the following below this CDDL HEADER, with the
16d5ace945SErwin T Tsaur * fields enclosed by brackets "[]" replaced with your own identifying
17d5ace945SErwin T Tsaur * information: Portions Copyright [yyyy] [name of copyright owner]
18d5ace945SErwin T Tsaur *
19d5ace945SErwin T Tsaur * CDDL HEADER END
20d5ace945SErwin T Tsaur */
21d5ace945SErwin T Tsaur /*
225cd376e8SJimmy Vetayases * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
2333f5ff17SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
24*bc54f855SJohn Levon * Copyright (c) 2018, Joyent, Inc.
25d5ace945SErwin T Tsaur */
26d5ace945SErwin T Tsaur
27d5ace945SErwin T Tsaur /*
28d5ace945SErwin T Tsaur * This is the user interface module for the pcitool. It checks commandline
29d5ace945SErwin T Tsaur * arguments and options and stores them in a pcitool_uiargs_t structure passed
30d5ace945SErwin T Tsaur * back to the rest of the program for processing.
31d5ace945SErwin T Tsaur *
32d5ace945SErwin T Tsaur * Please see pcitool_usage.c for a complete commandline description.
33d5ace945SErwin T Tsaur */
34d5ace945SErwin T Tsaur
35d5ace945SErwin T Tsaur #include <stdio.h>
36d5ace945SErwin T Tsaur #include <stdlib.h>
37d5ace945SErwin T Tsaur #include <unistd.h>
38d5ace945SErwin T Tsaur #include <sys/inttypes.h>
39d5ace945SErwin T Tsaur #include <sys/types.h>
40d5ace945SErwin T Tsaur #include <sys/param.h>
41d5ace945SErwin T Tsaur #include <strings.h>
42d5ace945SErwin T Tsaur #include <errno.h>
43d5ace945SErwin T Tsaur #include <sys/pci.h>
44d5ace945SErwin T Tsaur
45d5ace945SErwin T Tsaur #include <sys/pci_tools.h>
46d5ace945SErwin T Tsaur
47d5ace945SErwin T Tsaur #include "pcitool_ui.h"
48d5ace945SErwin T Tsaur
49d5ace945SErwin T Tsaur /*
50d5ace945SErwin T Tsaur * Uncomment the following for useful debugging / development options for this
51d5ace945SErwin T Tsaur * module only.
52d5ace945SErwin T Tsaur */
53d5ace945SErwin T Tsaur
54d5ace945SErwin T Tsaur /* #define DEBUG 1 */
55d5ace945SErwin T Tsaur /* #define STANDALONE 1 */
56d5ace945SErwin T Tsaur
57500b1e78SAlan Adamson, SD OSSD #define DEVNAME_START_PCI "/pci"
58500b1e78SAlan Adamson, SD OSSD #define DEVNAME_START_NIU "/niu"
59d5ace945SErwin T Tsaur
60d5ace945SErwin T Tsaur /* Default read/write size when -s not specified. */
61d5ace945SErwin T Tsaur #define DEFAULT_SIZE 4
62d5ace945SErwin T Tsaur
63d5ace945SErwin T Tsaur /* For get_value64 */
64d5ace945SErwin T Tsaur #define HEX_ONLY B_TRUE
65d5ace945SErwin T Tsaur #define BASE_BY_PREFIX B_FALSE
66d5ace945SErwin T Tsaur
67d5ace945SErwin T Tsaur #define BITS_PER_BYTE 8
68d5ace945SErwin T Tsaur
69d5ace945SErwin T Tsaur /*
70d5ace945SErwin T Tsaur * This defines which main options can be specified by the user.
71d5ace945SErwin T Tsaur * Options with colons after them require arguments.
72d5ace945SErwin T Tsaur */
7309b1eac2SEvan Yan static char *opt_string = ":n:d:i:m:p:rw:o:s:e:b:vaqlcxgy";
74d5ace945SErwin T Tsaur
75d5ace945SErwin T Tsaur /* This defines options used singly and only by themselves (no nexus). */
76d5ace945SErwin T Tsaur static char *no_dev_opt_string = "ahpqv";
77d5ace945SErwin T Tsaur
78d5ace945SErwin T Tsaur static void print_bad_option(char *argv[], int optopt, char *optarg);
79d5ace945SErwin T Tsaur static boolean_t get_confirmation(void);
80d5ace945SErwin T Tsaur static int get_value64(char *value_str, uint64_t *value, boolean_t hex_only);
81d5ace945SErwin T Tsaur static int parse_nexus_opts(char *input, uint64_t *flags_arg, uint8_t *bank_arg,
82d5ace945SErwin T Tsaur uint64_t *base_addr_arg);
83d5ace945SErwin T Tsaur static int extract_bdf_arg(char *cvalue, char *fld, uint64_t fld_flag,
84d5ace945SErwin T Tsaur uint64_t *all_flags, uint8_t *ivalue);
85d5ace945SErwin T Tsaur static int extract_bdf(char *value, char **bvalue_p, char **dvalue_p,
86d5ace945SErwin T Tsaur char **fvalue_p);
87d5ace945SErwin T Tsaur static int parse_device_opts(char *input, uint64_t *flags_arg,
88d5ace945SErwin T Tsaur uint8_t *bus_arg, uint8_t *device_arg, uint8_t *func_arg,
89d5ace945SErwin T Tsaur uint8_t *bank_arg);
907ff178cdSJimmy Vetayases static int parse_ino_opts(char *input, uint64_t *flags_arg,
917ff178cdSJimmy Vetayases uint32_t *cpu_arg, uint8_t *ino_arg);
9209b1eac2SEvan Yan static int parse_msi_opts(char *input, uint64_t *flags_arg, uint16_t *msi_arg);
93d5ace945SErwin T Tsaur static int parse_intr_set_opts(char *input, uint64_t *flags_arg,
94d5ace945SErwin T Tsaur uint32_t *cpu_arg);
95d5ace945SErwin T Tsaur static int parse_probeone_opts(char *input, uint64_t *flags_arg,
96d5ace945SErwin T Tsaur uint8_t *bus_arg, uint8_t *device_arg, uint8_t *func_arg);
97d5ace945SErwin T Tsaur
98d5ace945SErwin T Tsaur #ifdef DEBUG
99d5ace945SErwin T Tsaur void dump_struct(pcitool_uiargs_t *dump_this);
100d5ace945SErwin T Tsaur #endif
101d5ace945SErwin T Tsaur
102d5ace945SErwin T Tsaur /* Exported functions. */
103d5ace945SErwin T Tsaur
104d5ace945SErwin T Tsaur /*
105d5ace945SErwin T Tsaur * Main commandline argument parsing routine.
106d5ace945SErwin T Tsaur *
107d5ace945SErwin T Tsaur * Takes argc and argv straight from the commandline.
108d5ace945SErwin T Tsaur * Returns a pcitool_uiargs_t with flags of options specified, and values
109d5ace945SErwin T Tsaur * associated with them.
110d5ace945SErwin T Tsaur */
111d5ace945SErwin T Tsaur int
get_commandline_args(int argc,char * argv[],pcitool_uiargs_t * parsed_args)112d5ace945SErwin T Tsaur get_commandline_args(int argc, char *argv[], pcitool_uiargs_t *parsed_args)
113d5ace945SErwin T Tsaur {
114d5ace945SErwin T Tsaur int c; /* Current option being processed. */
115d5ace945SErwin T Tsaur boolean_t error = B_FALSE;
116d5ace945SErwin T Tsaur boolean_t confirm = B_FALSE;
117d5ace945SErwin T Tsaur uint64_t recv64;
118d5ace945SErwin T Tsaur
119d5ace945SErwin T Tsaur /* Needed for getopt(3C) */
120d5ace945SErwin T Tsaur extern char *optarg; /* Current commandline string. */
121d5ace945SErwin T Tsaur extern int optind; /* Index of current commandline string. */
122d5ace945SErwin T Tsaur extern int optopt; /* Option (char) which is missing an operand. */
123d5ace945SErwin T Tsaur extern int opterr; /* Set to 0 to disable getopt err reporting. */
124d5ace945SErwin T Tsaur
125d5ace945SErwin T Tsaur opterr = 0;
126d5ace945SErwin T Tsaur
127d5ace945SErwin T Tsaur bzero(parsed_args, sizeof (pcitool_uiargs_t));
128d5ace945SErwin T Tsaur
129d5ace945SErwin T Tsaur /* No args. probe mode accounting for bus ranges, nonverbose. */
130d5ace945SErwin T Tsaur if (argc == 1) {
131d5ace945SErwin T Tsaur usage(argv[0]);
132d5ace945SErwin T Tsaur parsed_args->flags = 0;
133d5ace945SErwin T Tsaur return (SUCCESS);
134d5ace945SErwin T Tsaur }
135d5ace945SErwin T Tsaur
136d5ace945SErwin T Tsaur /* 1st arg is not a device name. */
137500b1e78SAlan Adamson, SD OSSD if ((strstr(argv[1], DEVNAME_START_PCI) != argv[1]) &&
138500b1e78SAlan Adamson, SD OSSD (strstr(argv[1], DEVNAME_START_NIU) != argv[1])) {
139d5ace945SErwin T Tsaur
140d5ace945SErwin T Tsaur /* Default is to probe all trees accounting for bus ranges. */
141d5ace945SErwin T Tsaur parsed_args->flags = PROBEALL_FLAG | PROBERNG_FLAG;
142d5ace945SErwin T Tsaur
143d5ace945SErwin T Tsaur /* Loop thru the options until complete or an error is found. */
144d5ace945SErwin T Tsaur while (((c = getopt(argc, argv, no_dev_opt_string)) != -1) &&
145d5ace945SErwin T Tsaur (error == B_FALSE)) {
146d5ace945SErwin T Tsaur
147d5ace945SErwin T Tsaur switch (c) {
148d5ace945SErwin T Tsaur
149d5ace945SErwin T Tsaur /* Help requested. */
150d5ace945SErwin T Tsaur case 'h':
151d5ace945SErwin T Tsaur usage(argv[0]);
152d5ace945SErwin T Tsaur parsed_args->flags = 0;
153d5ace945SErwin T Tsaur return (SUCCESS);
154d5ace945SErwin T Tsaur
155d5ace945SErwin T Tsaur case 'p':
156d5ace945SErwin T Tsaur /* Take default probe mode */
157d5ace945SErwin T Tsaur break;
158d5ace945SErwin T Tsaur
159d5ace945SErwin T Tsaur case 'a':
160d5ace945SErwin T Tsaur /*
161d5ace945SErwin T Tsaur * Enable display of ALL bus numbers.
162d5ace945SErwin T Tsaur *
163d5ace945SErwin T Tsaur * This takes precidence over PROBERNG as -a
164d5ace945SErwin T Tsaur * is explicitly specified.
165d5ace945SErwin T Tsaur */
166d5ace945SErwin T Tsaur parsed_args->flags &= ~PROBERNG_FLAG;
167d5ace945SErwin T Tsaur break;
168d5ace945SErwin T Tsaur
169d5ace945SErwin T Tsaur case 'q':
170d5ace945SErwin T Tsaur parsed_args->flags |= QUIET_FLAG;
171d5ace945SErwin T Tsaur break;
172d5ace945SErwin T Tsaur
173d5ace945SErwin T Tsaur /* Verbose mode for full probe. */
174d5ace945SErwin T Tsaur case 'v':
175d5ace945SErwin T Tsaur parsed_args->flags |= VERBOSE_FLAG;
176d5ace945SErwin T Tsaur break;
177d5ace945SErwin T Tsaur
178d5ace945SErwin T Tsaur default:
179d5ace945SErwin T Tsaur error = B_TRUE;
180d5ace945SErwin T Tsaur break;
181d5ace945SErwin T Tsaur }
182d5ace945SErwin T Tsaur }
183d5ace945SErwin T Tsaur
184d5ace945SErwin T Tsaur /* Check for values straggling at the end of the command. */
185d5ace945SErwin T Tsaur if (optind != argc) {
186d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Unrecognized parameter "
187d5ace945SErwin T Tsaur "at the end of the command.\n", argv[0]);
188d5ace945SErwin T Tsaur error = B_TRUE;
189d5ace945SErwin T Tsaur }
190d5ace945SErwin T Tsaur
191d5ace945SErwin T Tsaur if (error) {
192d5ace945SErwin T Tsaur print_bad_option(argv, optopt, optarg);
193d5ace945SErwin T Tsaur return (FAILURE);
194d5ace945SErwin T Tsaur }
195d5ace945SErwin T Tsaur
196d5ace945SErwin T Tsaur return (SUCCESS);
197d5ace945SErwin T Tsaur }
198d5ace945SErwin T Tsaur
199d5ace945SErwin T Tsaur /* Device node specified on commandline. */
200d5ace945SErwin T Tsaur
201d5ace945SErwin T Tsaur /* Skip argv[1] before continuing below. */
202d5ace945SErwin T Tsaur optind++;
203d5ace945SErwin T Tsaur
204d5ace945SErwin T Tsaur /* Loop through the options until complete or an error is found. */
205d5ace945SErwin T Tsaur while (((c = getopt(argc, argv, opt_string)) != -1) &&
206d5ace945SErwin T Tsaur (error == B_FALSE)) {
207d5ace945SErwin T Tsaur
208d5ace945SErwin T Tsaur switch (c) {
209d5ace945SErwin T Tsaur
210d5ace945SErwin T Tsaur /* Nexus */
211d5ace945SErwin T Tsaur case 'n':
212d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG |
213d5ace945SErwin T Tsaur NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) {
214d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -n set with "
215d5ace945SErwin T Tsaur "-d, -p or -i or is set twice\n", argv[0]);
216d5ace945SErwin T Tsaur error = B_TRUE;
217d5ace945SErwin T Tsaur break;
218d5ace945SErwin T Tsaur }
219d5ace945SErwin T Tsaur parsed_args->flags |= NEXUS_FLAG;
220d5ace945SErwin T Tsaur if (parse_nexus_opts(optarg, &parsed_args->flags,
221d5ace945SErwin T Tsaur &parsed_args->bank, &parsed_args->base_address) !=
222d5ace945SErwin T Tsaur SUCCESS) {
223d5ace945SErwin T Tsaur (void) fprintf(stderr,
224d5ace945SErwin T Tsaur "%s: Error parsing -n options\n", argv[0]);
225d5ace945SErwin T Tsaur error = B_TRUE;
226d5ace945SErwin T Tsaur break;
227d5ace945SErwin T Tsaur }
228d5ace945SErwin T Tsaur break;
229d5ace945SErwin T Tsaur
230d5ace945SErwin T Tsaur /* Device (leaf node) */
231d5ace945SErwin T Tsaur case 'd':
232d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG |
233d5ace945SErwin T Tsaur NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) {
234d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -d set with "
235d5ace945SErwin T Tsaur "-n, -p or -i or is set twice\n", argv[0]);
236d5ace945SErwin T Tsaur error = B_TRUE;
237d5ace945SErwin T Tsaur break;
238d5ace945SErwin T Tsaur }
239d5ace945SErwin T Tsaur parsed_args->flags |= LEAF_FLAG;
240d5ace945SErwin T Tsaur if (parse_device_opts(optarg, &parsed_args->flags,
241d5ace945SErwin T Tsaur &parsed_args->bus, &parsed_args->device,
242d5ace945SErwin T Tsaur &parsed_args->function,
243d5ace945SErwin T Tsaur &parsed_args->bank) != SUCCESS) {
244d5ace945SErwin T Tsaur (void) fprintf(stderr,
245d5ace945SErwin T Tsaur "%s: Error parsing -d options\n", argv[0]);
246d5ace945SErwin T Tsaur error = B_TRUE;
247d5ace945SErwin T Tsaur break;
248d5ace945SErwin T Tsaur }
249d5ace945SErwin T Tsaur break;
250d5ace945SErwin T Tsaur
251d5ace945SErwin T Tsaur /* Interrupt */
252d5ace945SErwin T Tsaur case 'i':
253d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG |
254d5ace945SErwin T Tsaur NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) {
25509b1eac2SEvan Yan (void) fprintf(stderr, "%s: -i set with -m, "
256d5ace945SErwin T Tsaur "-n, -d or -p or is set twice\n", argv[0]);
257d5ace945SErwin T Tsaur error = B_TRUE;
258d5ace945SErwin T Tsaur break;
259d5ace945SErwin T Tsaur }
260d5ace945SErwin T Tsaur parsed_args->flags |= INTR_FLAG;
261d5ace945SErwin T Tsaur
262d5ace945SErwin T Tsaur /* parse input to get ino value. */
26309b1eac2SEvan Yan if (parse_ino_opts(optarg, &parsed_args->flags,
2647ff178cdSJimmy Vetayases &parsed_args->old_cpu,
265d5ace945SErwin T Tsaur &parsed_args->intr_ino) != SUCCESS) {
266d5ace945SErwin T Tsaur (void) fprintf(stderr,
267d5ace945SErwin T Tsaur "%s: Error parsing interrupt options\n",
268d5ace945SErwin T Tsaur argv[0]);
269d5ace945SErwin T Tsaur error = B_TRUE;
270d5ace945SErwin T Tsaur }
271d5ace945SErwin T Tsaur break;
27209b1eac2SEvan Yan /* Interrupt */
27309b1eac2SEvan Yan case 'm':
27409b1eac2SEvan Yan if (parsed_args->flags & (LEAF_FLAG |
27509b1eac2SEvan Yan NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) {
27609b1eac2SEvan Yan (void) fprintf(stderr, "%s: -m set with -i, "
27709b1eac2SEvan Yan "-n, -d or -p or is set twice\n", argv[0]);
27809b1eac2SEvan Yan error = B_TRUE;
27909b1eac2SEvan Yan break;
28009b1eac2SEvan Yan }
28109b1eac2SEvan Yan parsed_args->flags |= INTR_FLAG;
282d5ace945SErwin T Tsaur
28309b1eac2SEvan Yan /* parse input to get msi value. */
28409b1eac2SEvan Yan if (parse_msi_opts(optarg, &parsed_args->flags,
28509b1eac2SEvan Yan &parsed_args->intr_msi) != SUCCESS) {
28609b1eac2SEvan Yan (void) fprintf(stderr,
28709b1eac2SEvan Yan "%s: Error parsing interrupt options\n",
28809b1eac2SEvan Yan argv[0]);
28909b1eac2SEvan Yan error = B_TRUE;
29009b1eac2SEvan Yan }
29109b1eac2SEvan Yan break;
292d5ace945SErwin T Tsaur /* Probe */
293d5ace945SErwin T Tsaur case 'p':
294d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG |
295d5ace945SErwin T Tsaur NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) {
296d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -p set with "
297d5ace945SErwin T Tsaur "-n, -d or -i or is set twice\n", argv[0]);
298d5ace945SErwin T Tsaur error = B_TRUE;
299d5ace945SErwin T Tsaur break;
300d5ace945SErwin T Tsaur }
301d5ace945SErwin T Tsaur
302d5ace945SErwin T Tsaur /* Process -p with no dedicated options to it. */
303d5ace945SErwin T Tsaur if (optarg[0] == '-') {
304d5ace945SErwin T Tsaur optind--;
305d5ace945SErwin T Tsaur
306d5ace945SErwin T Tsaur /* Probe given tree observing ranges */
307d5ace945SErwin T Tsaur parsed_args->flags |=
308d5ace945SErwin T Tsaur (PROBETREE_FLAG | PROBERNG_FLAG);
309d5ace945SErwin T Tsaur continue;
310d5ace945SErwin T Tsaur }
311d5ace945SErwin T Tsaur
312d5ace945SErwin T Tsaur /* parse input to get ino value. */
313d5ace945SErwin T Tsaur if (parse_probeone_opts(optarg, &parsed_args->flags,
314d5ace945SErwin T Tsaur &parsed_args->bus, &parsed_args->device,
315d5ace945SErwin T Tsaur &parsed_args->function) != SUCCESS) {
316d5ace945SErwin T Tsaur (void) fprintf(stderr,
317d5ace945SErwin T Tsaur "%s: Error parsing probe options\n",
318d5ace945SErwin T Tsaur argv[0]);
319d5ace945SErwin T Tsaur error = B_TRUE;
320d5ace945SErwin T Tsaur } else {
321d5ace945SErwin T Tsaur /*
322d5ace945SErwin T Tsaur * parse_probeone_opts found options to
323d5ace945SErwin T Tsaur * set up bdf.
324d5ace945SErwin T Tsaur */
325d5ace945SErwin T Tsaur parsed_args->flags |= PROBEDEV_FLAG;
326d5ace945SErwin T Tsaur }
327d5ace945SErwin T Tsaur break;
328d5ace945SErwin T Tsaur
329d5ace945SErwin T Tsaur /* Probe all busses */
330d5ace945SErwin T Tsaur case 'a':
331d5ace945SErwin T Tsaur /* Must follow -p, and -p must have no bdf. */
332d5ace945SErwin T Tsaur if (!(parsed_args->flags & PROBETREE_FLAG)) {
333d5ace945SErwin T Tsaur error = B_TRUE;
334d5ace945SErwin T Tsaur break;
335d5ace945SErwin T Tsaur }
336d5ace945SErwin T Tsaur
337d5ace945SErwin T Tsaur parsed_args->flags &= ~PROBERNG_FLAG;
338d5ace945SErwin T Tsaur break;
339d5ace945SErwin T Tsaur
340d5ace945SErwin T Tsaur /* Read */
341d5ace945SErwin T Tsaur case 'r':
342d5ace945SErwin T Tsaur if (!(parsed_args->flags &
343d5ace945SErwin T Tsaur (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG))) {
344d5ace945SErwin T Tsaur error = B_TRUE;
345d5ace945SErwin T Tsaur break;
346d5ace945SErwin T Tsaur }
347d5ace945SErwin T Tsaur
348d5ace945SErwin T Tsaur /*
349d5ace945SErwin T Tsaur * Allow read and write to be set together for now,
350d5ace945SErwin T Tsaur * since this means write then read back for device and
351d5ace945SErwin T Tsaur * nexus accesses. Check for this and disallow with
352d5ace945SErwin T Tsaur * interrupt command later.
353d5ace945SErwin T Tsaur */
354d5ace945SErwin T Tsaur parsed_args->flags |= READ_FLAG;
355d5ace945SErwin T Tsaur break;
356d5ace945SErwin T Tsaur
357d5ace945SErwin T Tsaur /* Write */
358d5ace945SErwin T Tsaur case 'w':
359d5ace945SErwin T Tsaur if (!(parsed_args->flags &
360d5ace945SErwin T Tsaur (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG))) {
361d5ace945SErwin T Tsaur error = B_TRUE;
362d5ace945SErwin T Tsaur break;
363d5ace945SErwin T Tsaur }
364d5ace945SErwin T Tsaur if (parsed_args->flags & WRITE_FLAG) {
365d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -w set twice\n",
366d5ace945SErwin T Tsaur argv[0]);
367d5ace945SErwin T Tsaur error = B_TRUE;
368d5ace945SErwin T Tsaur break;
369d5ace945SErwin T Tsaur }
370d5ace945SErwin T Tsaur
371d5ace945SErwin T Tsaur /*
372d5ace945SErwin T Tsaur * For device and nexus, get a single register value
373d5ace945SErwin T Tsaur * to write.
374d5ace945SErwin T Tsaur */
375d5ace945SErwin T Tsaur if (parsed_args->flags & (NEXUS_FLAG | LEAF_FLAG)) {
376d5ace945SErwin T Tsaur parsed_args->flags |= WRITE_FLAG;
377d5ace945SErwin T Tsaur if (get_value64(optarg,
378d5ace945SErwin T Tsaur &parsed_args->write_value, HEX_ONLY) !=
379d5ace945SErwin T Tsaur SUCCESS) {
380d5ace945SErwin T Tsaur (void) fprintf(stderr,
381d5ace945SErwin T Tsaur "%s: Error reading value to "
382d5ace945SErwin T Tsaur "write.\n", argv[0]);
383d5ace945SErwin T Tsaur error = B_TRUE;
384d5ace945SErwin T Tsaur break;
385d5ace945SErwin T Tsaur }
386d5ace945SErwin T Tsaur
387d5ace945SErwin T Tsaur /* For interrupt, parse input to get cpu value. */
388d5ace945SErwin T Tsaur } else if (parsed_args->flags & INTR_FLAG) {
389d5ace945SErwin T Tsaur parsed_args->flags |= WRITE_FLAG;
390d5ace945SErwin T Tsaur if (parse_intr_set_opts(optarg,
391d5ace945SErwin T Tsaur &parsed_args->flags,
392d5ace945SErwin T Tsaur &parsed_args->intr_cpu) != SUCCESS) {
393d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Error "
394d5ace945SErwin T Tsaur "parsing interrupt options.\n",
395d5ace945SErwin T Tsaur argv[0]);
396d5ace945SErwin T Tsaur error = B_TRUE;
397d5ace945SErwin T Tsaur break;
398d5ace945SErwin T Tsaur }
399d5ace945SErwin T Tsaur
400d5ace945SErwin T Tsaur } else {
401d5ace945SErwin T Tsaur error = B_TRUE;
402d5ace945SErwin T Tsaur break;
403d5ace945SErwin T Tsaur }
404d5ace945SErwin T Tsaur break;
405d5ace945SErwin T Tsaur
406d5ace945SErwin T Tsaur /* Offset */
407d5ace945SErwin T Tsaur case 'o':
408d5ace945SErwin T Tsaur if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) {
409d5ace945SErwin T Tsaur error = B_TRUE;
410d5ace945SErwin T Tsaur break;
411d5ace945SErwin T Tsaur }
412d5ace945SErwin T Tsaur if (parsed_args->flags & OFFSET_FLAG) {
413d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -o set twice\n",
414d5ace945SErwin T Tsaur argv[0]);
415d5ace945SErwin T Tsaur error = B_TRUE;
416d5ace945SErwin T Tsaur break;
417d5ace945SErwin T Tsaur }
418d5ace945SErwin T Tsaur parsed_args->flags |= OFFSET_FLAG;
419d5ace945SErwin T Tsaur if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) {
420d5ace945SErwin T Tsaur (void) fprintf(stderr,
421d5ace945SErwin T Tsaur "%s: Error in offset argument\n", argv[0]);
422d5ace945SErwin T Tsaur error = B_TRUE;
423d5ace945SErwin T Tsaur break;
424d5ace945SErwin T Tsaur }
425d5ace945SErwin T Tsaur parsed_args->offset = (uint32_t)recv64;
426d5ace945SErwin T Tsaur if (parsed_args->offset != recv64) {
427d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Offset argument "
428d5ace945SErwin T Tsaur "too large for 32 bits\n", argv[0]);
429d5ace945SErwin T Tsaur error = B_TRUE;
430d5ace945SErwin T Tsaur break;
431d5ace945SErwin T Tsaur }
432d5ace945SErwin T Tsaur break;
433d5ace945SErwin T Tsaur
434d5ace945SErwin T Tsaur /* Size */
435d5ace945SErwin T Tsaur case 's':
436d5ace945SErwin T Tsaur if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) {
437d5ace945SErwin T Tsaur error = B_TRUE;
438d5ace945SErwin T Tsaur break;
439d5ace945SErwin T Tsaur }
440d5ace945SErwin T Tsaur if (parsed_args->flags & SIZE_FLAG) {
441d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -s set twice\n",
442d5ace945SErwin T Tsaur argv[0]);
443d5ace945SErwin T Tsaur error = B_TRUE;
444d5ace945SErwin T Tsaur break;
445d5ace945SErwin T Tsaur }
446d5ace945SErwin T Tsaur parsed_args->flags |= SIZE_FLAG;
447d5ace945SErwin T Tsaur if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) {
448d5ace945SErwin T Tsaur (void) fprintf(stderr,
449d5ace945SErwin T Tsaur "%s: Error in size argument\n", argv[0]);
450d5ace945SErwin T Tsaur error = B_TRUE;
451d5ace945SErwin T Tsaur break;
452d5ace945SErwin T Tsaur }
453d5ace945SErwin T Tsaur switch (recv64) {
454d5ace945SErwin T Tsaur case 1:
455d5ace945SErwin T Tsaur case 2:
456d5ace945SErwin T Tsaur case 4:
457d5ace945SErwin T Tsaur case 8:
458d5ace945SErwin T Tsaur break;
459d5ace945SErwin T Tsaur default:
460d5ace945SErwin T Tsaur error = B_TRUE;
461d5ace945SErwin T Tsaur (void) fprintf(stderr,
462d5ace945SErwin T Tsaur "%s: Error in size argument\n", argv[0]);
463d5ace945SErwin T Tsaur break;
464d5ace945SErwin T Tsaur }
465d5ace945SErwin T Tsaur parsed_args->size |= (uint8_t)recv64;
466d5ace945SErwin T Tsaur break;
467d5ace945SErwin T Tsaur
468d5ace945SErwin T Tsaur /* Endian. */
469d5ace945SErwin T Tsaur case 'e':
470d5ace945SErwin T Tsaur if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) {
471d5ace945SErwin T Tsaur error = B_TRUE;
472d5ace945SErwin T Tsaur break;
473d5ace945SErwin T Tsaur }
474d5ace945SErwin T Tsaur if (parsed_args->flags & ENDIAN_FLAG) {
475d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -e set twice\n",
476d5ace945SErwin T Tsaur argv[0]);
477d5ace945SErwin T Tsaur error = B_TRUE;
478d5ace945SErwin T Tsaur break;
479d5ace945SErwin T Tsaur }
480d5ace945SErwin T Tsaur parsed_args->flags |= ENDIAN_FLAG;
481d5ace945SErwin T Tsaur
482d5ace945SErwin T Tsaur /* Only a single character allowed. */
483d5ace945SErwin T Tsaur if (optarg[1] != '\0') {
484d5ace945SErwin T Tsaur (void) fprintf(stderr,
485d5ace945SErwin T Tsaur "%s: Error in endian argument\n", argv[0]);
486d5ace945SErwin T Tsaur error = B_TRUE;
487d5ace945SErwin T Tsaur break;
488d5ace945SErwin T Tsaur }
489d5ace945SErwin T Tsaur
490d5ace945SErwin T Tsaur switch (optarg[0]) {
491d5ace945SErwin T Tsaur case 'b':
492d5ace945SErwin T Tsaur parsed_args->big_endian = B_TRUE;
493d5ace945SErwin T Tsaur break;
494d5ace945SErwin T Tsaur case 'l':
495d5ace945SErwin T Tsaur break;
496d5ace945SErwin T Tsaur default:
497d5ace945SErwin T Tsaur (void) fprintf(stderr,
498d5ace945SErwin T Tsaur "%s: Error in endian argument\n", argv[0]);
499d5ace945SErwin T Tsaur error = B_TRUE;
500d5ace945SErwin T Tsaur break;
501d5ace945SErwin T Tsaur }
502d5ace945SErwin T Tsaur break;
503d5ace945SErwin T Tsaur
504d5ace945SErwin T Tsaur /* (Byte)dump */
505d5ace945SErwin T Tsaur case 'b':
506d5ace945SErwin T Tsaur if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) {
507d5ace945SErwin T Tsaur error = B_TRUE;
508d5ace945SErwin T Tsaur break;
509d5ace945SErwin T Tsaur }
510d5ace945SErwin T Tsaur if (parsed_args->flags & BYTEDUMP_FLAG) {
511d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -b set twice\n",
512d5ace945SErwin T Tsaur argv[0]);
513d5ace945SErwin T Tsaur error = B_TRUE;
514d5ace945SErwin T Tsaur break;
515d5ace945SErwin T Tsaur }
516d5ace945SErwin T Tsaur parsed_args->flags |= BYTEDUMP_FLAG;
517d5ace945SErwin T Tsaur if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) {
518d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Error in "
519d5ace945SErwin T Tsaur "bytedump argument\n", argv[0]);
520d5ace945SErwin T Tsaur error = B_TRUE;
521d5ace945SErwin T Tsaur break;
522d5ace945SErwin T Tsaur }
523d5ace945SErwin T Tsaur parsed_args->bytedump_amt = (uint32_t)recv64;
524d5ace945SErwin T Tsaur if (parsed_args->bytedump_amt != recv64) {
525d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Bytedump amount "
526d5ace945SErwin T Tsaur "too large for 32 bits\n", argv[0]);
527d5ace945SErwin T Tsaur error = B_TRUE;
528d5ace945SErwin T Tsaur break;
529d5ace945SErwin T Tsaur }
530d5ace945SErwin T Tsaur break;
531d5ace945SErwin T Tsaur
532d5ace945SErwin T Tsaur /* Verbose. */
533d5ace945SErwin T Tsaur case 'v':
534d5ace945SErwin T Tsaur parsed_args->flags |= VERBOSE_FLAG;
535d5ace945SErwin T Tsaur break;
536d5ace945SErwin T Tsaur
537d5ace945SErwin T Tsaur /*
538d5ace945SErwin T Tsaur * Quiet - no errors reported as messages.
539d5ace945SErwin T Tsaur * (Status still returned by program, however.)
540d5ace945SErwin T Tsaur */
541d5ace945SErwin T Tsaur case 'q':
542d5ace945SErwin T Tsaur parsed_args->flags |= QUIET_FLAG;
543d5ace945SErwin T Tsaur break;
544d5ace945SErwin T Tsaur
545d5ace945SErwin T Tsaur /* Loop. */
546d5ace945SErwin T Tsaur case 'l':
547d5ace945SErwin T Tsaur parsed_args->flags |= LOOP_FLAG;
548d5ace945SErwin T Tsaur break;
549d5ace945SErwin T Tsaur
550d5ace945SErwin T Tsaur /*
551d5ace945SErwin T Tsaur * Dump characters with bytedump (-b).
552d5ace945SErwin T Tsaur * Show controller info with -i.
553d5ace945SErwin T Tsaur */
554d5ace945SErwin T Tsaur case 'c':
555d5ace945SErwin T Tsaur if (parsed_args->flags & BYTEDUMP_FLAG) {
556d5ace945SErwin T Tsaur parsed_args->flags |= CHARDUMP_FLAG;
557d5ace945SErwin T Tsaur
558d5ace945SErwin T Tsaur } else if (parsed_args->flags & INTR_FLAG) {
559d5ace945SErwin T Tsaur parsed_args->flags |= SHOWCTLR_FLAG;
560d5ace945SErwin T Tsaur
561d5ace945SErwin T Tsaur } else {
562d5ace945SErwin T Tsaur error = B_TRUE;
563d5ace945SErwin T Tsaur }
564d5ace945SErwin T Tsaur break;
565d5ace945SErwin T Tsaur
566d5ace945SErwin T Tsaur /* Continue on errors with bytedump (-b). */
567d5ace945SErwin T Tsaur case 'x':
568d5ace945SErwin T Tsaur if (!(parsed_args->flags & BYTEDUMP_FLAG)) {
569d5ace945SErwin T Tsaur error = B_TRUE;
570d5ace945SErwin T Tsaur break;
571d5ace945SErwin T Tsaur }
572d5ace945SErwin T Tsaur parsed_args->flags |= ERRCONT_FLAG;
573d5ace945SErwin T Tsaur break;
574d5ace945SErwin T Tsaur
575d5ace945SErwin T Tsaur case 'g':
576d5ace945SErwin T Tsaur if (!(parsed_args->flags & INTR_FLAG)) {
577d5ace945SErwin T Tsaur error = B_TRUE;
578d5ace945SErwin T Tsaur break;
579d5ace945SErwin T Tsaur }
580d5ace945SErwin T Tsaur parsed_args->flags |= SETGRP_FLAG;
581d5ace945SErwin T Tsaur break;
582d5ace945SErwin T Tsaur
583d5ace945SErwin T Tsaur /* Take -y as confirmation and don't ask (where applicable). */
584d5ace945SErwin T Tsaur case 'y':
585d5ace945SErwin T Tsaur confirm = B_TRUE;
586d5ace945SErwin T Tsaur break;
587d5ace945SErwin T Tsaur
588d5ace945SErwin T Tsaur /* Option without operand. */
589d5ace945SErwin T Tsaur case ':':
590d5ace945SErwin T Tsaur switch (optopt) {
591d5ace945SErwin T Tsaur case 'p':
592d5ace945SErwin T Tsaur /* Allow -p without bdf spec. */
593d5ace945SErwin T Tsaur parsed_args->flags |=
594d5ace945SErwin T Tsaur (PROBETREE_FLAG | PROBERNG_FLAG);
595d5ace945SErwin T Tsaur break;
596d5ace945SErwin T Tsaur default:
597d5ace945SErwin T Tsaur error = B_TRUE;
598d5ace945SErwin T Tsaur break;
599d5ace945SErwin T Tsaur }
600d5ace945SErwin T Tsaur break;
601d5ace945SErwin T Tsaur
602d5ace945SErwin T Tsaur /* Unrecognized option. */
603d5ace945SErwin T Tsaur case '?':
604d5ace945SErwin T Tsaur error = B_TRUE;
605d5ace945SErwin T Tsaur break;
606d5ace945SErwin T Tsaur }
607d5ace945SErwin T Tsaur }
608d5ace945SErwin T Tsaur
609d5ace945SErwin T Tsaur /*
610d5ace945SErwin T Tsaur * Commandline has been parsed. Check for errors which can be checked
611d5ace945SErwin T Tsaur * only after commandline parsing is complete.
612d5ace945SErwin T Tsaur */
613d5ace945SErwin T Tsaur
614d5ace945SErwin T Tsaur if (!error) {
615d5ace945SErwin T Tsaur
616d5ace945SErwin T Tsaur /* Check for values straggling at the end of the command. */
617d5ace945SErwin T Tsaur if (optind != argc) {
618d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Unrecognized parameter "
619d5ace945SErwin T Tsaur "at the end of the command.\n", argv[0]);
620d5ace945SErwin T Tsaur print_bad_option(argv, optopt, optarg);
621d5ace945SErwin T Tsaur return (FAILURE);
622d5ace945SErwin T Tsaur }
623d5ace945SErwin T Tsaur
624d5ace945SErwin T Tsaur /* No args other than nexus. Default to probing that nexus */
625d5ace945SErwin T Tsaur if (!(parsed_args->flags &
626d5ace945SErwin T Tsaur (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS))) {
627d5ace945SErwin T Tsaur usage(argv[0]);
628d5ace945SErwin T Tsaur parsed_args->flags = 0;
629d5ace945SErwin T Tsaur return (SUCCESS);
630d5ace945SErwin T Tsaur }
631d5ace945SErwin T Tsaur
632d5ace945SErwin T Tsaur /*
633d5ace945SErwin T Tsaur * Don't allow any options other than all-bus, verbose or
634d5ace945SErwin T Tsaur * quiet with probe command. Set default probe flags if nexus
635d5ace945SErwin T Tsaur * or leaf options are not specified.
636d5ace945SErwin T Tsaur */
637d5ace945SErwin T Tsaur if (parsed_args->flags & (PROBETREE_FLAG | PROBEALL_FLAG)) {
638d5ace945SErwin T Tsaur if (parsed_args->flags &
639d5ace945SErwin T Tsaur ~(PROBE_FLAGS | QUIET_FLAG | VERBOSE_FLAG))
640d5ace945SErwin T Tsaur error = B_TRUE;
641d5ace945SErwin T Tsaur }
642d5ace945SErwin T Tsaur
643d5ace945SErwin T Tsaur /*
644d5ace945SErwin T Tsaur * Allow only read, write, quiet and verbose flags for
645d5ace945SErwin T Tsaur * interrupt command. Note that INO_SPEC_FLAG and CPU_SPEC_FLAG
646d5ace945SErwin T Tsaur * get set for interrupt command.
647d5ace945SErwin T Tsaur */
648d5ace945SErwin T Tsaur if (parsed_args->flags & INTR_FLAG) {
649d5ace945SErwin T Tsaur if (parsed_args->flags &
650d5ace945SErwin T Tsaur ~(INTR_FLAG | VERBOSE_FLAG | QUIET_FLAG |
651d5ace945SErwin T Tsaur READ_FLAG | WRITE_FLAG | SHOWCTLR_FLAG |
65209b1eac2SEvan Yan SETGRP_FLAG | INO_ALL_FLAG | INO_SPEC_FLAG |
65309b1eac2SEvan Yan MSI_ALL_FLAG | MSI_SPEC_FLAG | CPU_SPEC_FLAG)) {
654d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -v, -q, -r, -w, -c "
65509b1eac2SEvan Yan "-g are only options allowed with "
65609b1eac2SEvan Yan "interrupt command.\n", argv[0]);
657d5ace945SErwin T Tsaur error = B_TRUE;
658d5ace945SErwin T Tsaur }
659d5ace945SErwin T Tsaur
660d5ace945SErwin T Tsaur /* Need cpu and ino values for interrupt set command. */
661d5ace945SErwin T Tsaur if ((parsed_args->flags & WRITE_FLAG) &&
66209b1eac2SEvan Yan !(parsed_args->flags & CPU_SPEC_FLAG) &&
66309b1eac2SEvan Yan !((parsed_args->flags & INO_SPEC_FLAG) ||
66409b1eac2SEvan Yan (parsed_args->flags & MSI_SPEC_FLAG))) {
665d5ace945SErwin T Tsaur (void) fprintf(stderr,
66609b1eac2SEvan Yan "%s: Both cpu and ino/msi must be "
66709b1eac2SEvan Yan "specified explicitly for interrupt "
66809b1eac2SEvan Yan "set command.\n", argv[0]);
669d5ace945SErwin T Tsaur error = B_TRUE;
670d5ace945SErwin T Tsaur }
671d5ace945SErwin T Tsaur
672d5ace945SErwin T Tsaur /* Intr write and show ctlr flags are incompatible. */
673d5ace945SErwin T Tsaur if ((parsed_args->flags &
674d5ace945SErwin T Tsaur (WRITE_FLAG + SHOWCTLR_FLAG)) ==
675d5ace945SErwin T Tsaur (WRITE_FLAG + SHOWCTLR_FLAG)) {
676d5ace945SErwin T Tsaur (void) fprintf(stderr,
677d5ace945SErwin T Tsaur "%s: -w and -c are incompatible for "
678d5ace945SErwin T Tsaur "interrupt command.\n", argv[0]);
679d5ace945SErwin T Tsaur error = B_TRUE;
680d5ace945SErwin T Tsaur }
681d5ace945SErwin T Tsaur
682d5ace945SErwin T Tsaur /* Intr setgrp flag valid only for intr writes. */
683d5ace945SErwin T Tsaur if ((parsed_args->flags & (WRITE_FLAG + SETGRP_FLAG)) ==
684d5ace945SErwin T Tsaur SETGRP_FLAG) {
685d5ace945SErwin T Tsaur (void) fprintf(stderr,
686d5ace945SErwin T Tsaur "%s: -g is incompatible with -r "
687d5ace945SErwin T Tsaur "for interrupt command.\n", argv[0]);
688d5ace945SErwin T Tsaur error = B_TRUE;
689d5ace945SErwin T Tsaur }
690d5ace945SErwin T Tsaur
691d5ace945SErwin T Tsaur /*
692d5ace945SErwin T Tsaur * Disallow read & write together in interrupt command.
693d5ace945SErwin T Tsaur */
694d5ace945SErwin T Tsaur if ((parsed_args->flags & (WRITE_FLAG | READ_FLAG)) ==
695d5ace945SErwin T Tsaur (WRITE_FLAG | READ_FLAG)) {
696d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: Only one of -r and "
697d5ace945SErwin T Tsaur "-w can be specified in "
698d5ace945SErwin T Tsaur "interrupt command.\n", argv[0]);
699d5ace945SErwin T Tsaur error = B_TRUE;
700d5ace945SErwin T Tsaur }
701d5ace945SErwin T Tsaur }
702d5ace945SErwin T Tsaur
703d5ace945SErwin T Tsaur /* Bytedump incompatible with some other options. */
704d5ace945SErwin T Tsaur if ((parsed_args->flags & BYTEDUMP_FLAG) &&
705d5ace945SErwin T Tsaur (parsed_args->flags &
706d5ace945SErwin T Tsaur (WRITE_FLAG | PROBE_FLAGS | INTR_FLAG))) {
707d5ace945SErwin T Tsaur (void) fprintf(stderr,
708d5ace945SErwin T Tsaur "%s: -b is incompatible with "
709d5ace945SErwin T Tsaur "another specified option.\n", argv[0]);
710d5ace945SErwin T Tsaur error = B_TRUE;
711d5ace945SErwin T Tsaur }
712d5ace945SErwin T Tsaur
713d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG)) {
714d5ace945SErwin T Tsaur
715d5ace945SErwin T Tsaur if (!(parsed_args->flags & SIZE_FLAG)) {
716d5ace945SErwin T Tsaur parsed_args->size = DEFAULT_SIZE;
717d5ace945SErwin T Tsaur }
718d5ace945SErwin T Tsaur if ((parsed_args->flags & WRITE_FLAG) &&
719d5ace945SErwin T Tsaur parsed_args->size < sizeof (uint64_t) &&
720d5ace945SErwin T Tsaur (parsed_args->write_value >>
721d5ace945SErwin T Tsaur (parsed_args->size * BITS_PER_BYTE))) {
722d5ace945SErwin T Tsaur (void) fprintf(stderr,
723d5ace945SErwin T Tsaur "%s: Data to write is larger than "
724d5ace945SErwin T Tsaur "specified size.\n", argv[0]);
725d5ace945SErwin T Tsaur error = B_TRUE;
726d5ace945SErwin T Tsaur }
727d5ace945SErwin T Tsaur
728d5ace945SErwin T Tsaur } else { /* Looping is compatible only with register cmds. */
729d5ace945SErwin T Tsaur
730d5ace945SErwin T Tsaur if (parsed_args->flags & LOOP_FLAG) {
731d5ace945SErwin T Tsaur (void) fprintf(stderr, "%s: -l is incompatible "
732d5ace945SErwin T Tsaur "with given command.\n", argv[0]);
733d5ace945SErwin T Tsaur error = B_TRUE;
734d5ace945SErwin T Tsaur }
735d5ace945SErwin T Tsaur }
736d5ace945SErwin T Tsaur
737d5ace945SErwin T Tsaur /* Call out an erroneous -y and then ignore it. */
738d5ace945SErwin T Tsaur if ((confirm) && (!(parsed_args->flags & BASE_SPEC_FLAG))) {
739d5ace945SErwin T Tsaur (void) fprintf(stderr,
740d5ace945SErwin T Tsaur "%s: -y is incompatible with given command."
741d5ace945SErwin T Tsaur " Ignoring.\n", argv[0]);
742d5ace945SErwin T Tsaur }
743d5ace945SErwin T Tsaur }
744d5ace945SErwin T Tsaur
745d5ace945SErwin T Tsaur /* Now fill in the defaults and other holes. */
746d5ace945SErwin T Tsaur if (!(error)) {
747d5ace945SErwin T Tsaur if (!(parsed_args->flags & (READ_FLAG | WRITE_FLAG))) {
748d5ace945SErwin T Tsaur parsed_args->flags |= READ_FLAG;
749d5ace945SErwin T Tsaur }
750d5ace945SErwin T Tsaur
751d5ace945SErwin T Tsaur if (parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG)) {
752d5ace945SErwin T Tsaur if (!(parsed_args->flags & ENDIAN_FLAG)) {
753d5ace945SErwin T Tsaur parsed_args->big_endian = B_FALSE;
754d5ace945SErwin T Tsaur }
755d5ace945SErwin T Tsaur }
756d5ace945SErwin T Tsaur
757d5ace945SErwin T Tsaur if (parsed_args->flags & BASE_SPEC_FLAG) {
758d5ace945SErwin T Tsaur if (!confirm) {
759d5ace945SErwin T Tsaur confirm = get_confirmation();
760d5ace945SErwin T Tsaur }
761d5ace945SErwin T Tsaur if (!confirm) {
762d5ace945SErwin T Tsaur parsed_args->flags &= ~ALL_COMMANDS;
763d5ace945SErwin T Tsaur }
764d5ace945SErwin T Tsaur }
765d5ace945SErwin T Tsaur
766d5ace945SErwin T Tsaur /*
767d5ace945SErwin T Tsaur * As far as other defaults are concerned:
768d5ace945SErwin T Tsaur * Other fields: bus, device, function, offset, default to
769d5ace945SErwin T Tsaur * zero.
770d5ace945SErwin T Tsaur */
771d5ace945SErwin T Tsaur
772d5ace945SErwin T Tsaur } else { /* An error occurred. */
773d5ace945SErwin T Tsaur
774d5ace945SErwin T Tsaur print_bad_option(argv, optopt, optarg);
775d5ace945SErwin T Tsaur }
776d5ace945SErwin T Tsaur return (error);
777d5ace945SErwin T Tsaur }
778d5ace945SErwin T Tsaur
779d5ace945SErwin T Tsaur
780d5ace945SErwin T Tsaur /* Module-private functions. */
781d5ace945SErwin T Tsaur
782d5ace945SErwin T Tsaur static void
print_bad_option(char * argv[],int optopt,char * optarg)783d5ace945SErwin T Tsaur print_bad_option(char *argv[], int optopt, char *optarg)
784d5ace945SErwin T Tsaur {
785d5ace945SErwin T Tsaur /* Illegal option operand */
786d5ace945SErwin T Tsaur if (optarg != NULL) {
787d5ace945SErwin T Tsaur (void) fprintf(stderr,
788d5ace945SErwin T Tsaur "%s: illegal operand %s specified for option %c\n",
789d5ace945SErwin T Tsaur argv[0], optarg, optopt);
790d5ace945SErwin T Tsaur
791d5ace945SErwin T Tsaur /* Illegal option */
792d5ace945SErwin T Tsaur } else if (optopt != 0) {
793d5ace945SErwin T Tsaur (void) fprintf(stderr,
794d5ace945SErwin T Tsaur "%s: option %c is illegal or is missing an operand\n",
795d5ace945SErwin T Tsaur argv[0], optopt);
796d5ace945SErwin T Tsaur
797d5ace945SErwin T Tsaur /* getopt wasn't even called. Bad device spec. */
798d5ace945SErwin T Tsaur } else {
799d5ace945SErwin T Tsaur (void) fprintf(stderr,
800500b1e78SAlan Adamson, SD OSSD "%s: device spec must start with %s or %s...\n", argv[0],
801500b1e78SAlan Adamson, SD OSSD DEVNAME_START_PCI, DEVNAME_START_NIU);
802d5ace945SErwin T Tsaur }
803d5ace945SErwin T Tsaur
804d5ace945SErwin T Tsaur (void) fprintf(stderr,
805d5ace945SErwin T Tsaur "%s: Type \"%s -h\" to get help on running this program.\n",
806d5ace945SErwin T Tsaur argv[0], argv[0]);
807d5ace945SErwin T Tsaur }
808d5ace945SErwin T Tsaur
809d5ace945SErwin T Tsaur /*
810d5ace945SErwin T Tsaur * Warn the user and ask for confirmation.
811d5ace945SErwin T Tsaur */
812d5ace945SErwin T Tsaur static boolean_t
get_confirmation()813d5ace945SErwin T Tsaur get_confirmation()
814d5ace945SErwin T Tsaur {
815d5ace945SErwin T Tsaur int i, b;
816d5ace945SErwin T Tsaur
817d5ace945SErwin T Tsaur (void) printf("WARNING: This cmd with a bad addr can panic "
818d5ace945SErwin T Tsaur "the system. Continue [y/n] (n)? ");
819d5ace945SErwin T Tsaur for (i = 0; ; i++) {
820d5ace945SErwin T Tsaur b = getchar();
821d5ace945SErwin T Tsaur switch (b) {
822d5ace945SErwin T Tsaur case ' ':
823d5ace945SErwin T Tsaur case '\t':
824d5ace945SErwin T Tsaur break;
825d5ace945SErwin T Tsaur case 'y':
826d5ace945SErwin T Tsaur case 'Y':
827d5ace945SErwin T Tsaur return (B_TRUE);
828d5ace945SErwin T Tsaur default:
829d5ace945SErwin T Tsaur return (B_FALSE);
830d5ace945SErwin T Tsaur }
831d5ace945SErwin T Tsaur }
832d5ace945SErwin T Tsaur }
833d5ace945SErwin T Tsaur
834d5ace945SErwin T Tsaur
835d5ace945SErwin T Tsaur /*
836d5ace945SErwin T Tsaur * Given a digit string, return a 64 bit value.
837d5ace945SErwin T Tsaur *
838d5ace945SErwin T Tsaur * If the hex_only arg is true, interpret all strings as hex.
839d5ace945SErwin T Tsaur * Otherwise, interpret as strtoull(3C) does with base=0.
840d5ace945SErwin T Tsaur */
841d5ace945SErwin T Tsaur static int
get_value64(char * value_str,uint64_t * value,boolean_t hex_only)842d5ace945SErwin T Tsaur get_value64(char *value_str, uint64_t *value, boolean_t hex_only)
843d5ace945SErwin T Tsaur {
844d5ace945SErwin T Tsaur
845d5ace945SErwin T Tsaur /* This is overkill for now, as everything is in hex. */
846d5ace945SErwin T Tsaur static char dec_digits[] = "0123456789";
847d5ace945SErwin T Tsaur static char hex_digits[] = "01234567890abcdefABCDEF";
848d5ace945SErwin T Tsaur static char oct_digits[] = "01234567";
849d5ace945SErwin T Tsaur
850d5ace945SErwin T Tsaur char *digit_string;
851d5ace945SErwin T Tsaur char *string_to_check;
852d5ace945SErwin T Tsaur
853d5ace945SErwin T Tsaur if ((value_str == NULL) || (strlen(value_str) == 0)) {
854d5ace945SErwin T Tsaur (void) fprintf(stderr, "Missing value argument.\n");
855d5ace945SErwin T Tsaur return (FAILURE);
856d5ace945SErwin T Tsaur }
857d5ace945SErwin T Tsaur
858d5ace945SErwin T Tsaur if (!hex_only && (value_str[0] != '0')) {
859d5ace945SErwin T Tsaur digit_string = dec_digits;
860d5ace945SErwin T Tsaur string_to_check = value_str;
861d5ace945SErwin T Tsaur } else if ((value_str[1] == 'X') || (value_str[1] == 'x')) {
862d5ace945SErwin T Tsaur digit_string = hex_digits;
863d5ace945SErwin T Tsaur string_to_check = &value_str[2]; /* Ignore 0x of hex */
864d5ace945SErwin T Tsaur } else if (hex_only) {
865d5ace945SErwin T Tsaur digit_string = hex_digits;
866d5ace945SErwin T Tsaur string_to_check = value_str; /* Hex number, no 0x prefix */
867d5ace945SErwin T Tsaur } else {
868d5ace945SErwin T Tsaur digit_string = oct_digits;
869d5ace945SErwin T Tsaur string_to_check = value_str;
870d5ace945SErwin T Tsaur }
871d5ace945SErwin T Tsaur
872d5ace945SErwin T Tsaur /*
873d5ace945SErwin T Tsaur * Verify value is all proper digits.
874d5ace945SErwin T Tsaur *
875d5ace945SErwin T Tsaur * For some reason, strtoull doesn't return an error when it cannot
876d5ace945SErwin T Tsaur * interpret the value. This is why we do the checking ourselves.
877d5ace945SErwin T Tsaur */
878d5ace945SErwin T Tsaur if (strspn(string_to_check, digit_string) != strlen(string_to_check)) {
879d5ace945SErwin T Tsaur (void) fprintf(stderr,
880d5ace945SErwin T Tsaur "Value must contain only valid digits.\n");
881d5ace945SErwin T Tsaur return (FAILURE);
882d5ace945SErwin T Tsaur }
883d5ace945SErwin T Tsaur
884d5ace945SErwin T Tsaur *value = strtoull(value_str, NULL, (hex_only ? 16 : 0));
885d5ace945SErwin T Tsaur
886d5ace945SErwin T Tsaur return (SUCCESS);
887d5ace945SErwin T Tsaur }
888d5ace945SErwin T Tsaur
889d5ace945SErwin T Tsaur
890d5ace945SErwin T Tsaur /*
891d5ace945SErwin T Tsaur * Parse nexus options. This includes:
892d5ace945SErwin T Tsaur * bank=number
893d5ace945SErwin T Tsaur *
894d5ace945SErwin T Tsaur * input is what the user specified for the options on the commandline,
895d5ace945SErwin T Tsaur * flags_arg is modified with the option set, and bank_arg returns the value
896d5ace945SErwin T Tsaur * specified for bank.
897d5ace945SErwin T Tsaur */
898d5ace945SErwin T Tsaur static int
parse_nexus_opts(char * input,uint64_t * flags_arg,uint8_t * bank_arg,uint64_t * base_addr_arg)899d5ace945SErwin T Tsaur parse_nexus_opts(char *input, uint64_t *flags_arg, uint8_t *bank_arg,
900d5ace945SErwin T Tsaur uint64_t *base_addr_arg)
901d5ace945SErwin T Tsaur {
9020803869aSToomas Soome enum nexus_opts_index {
903d5ace945SErwin T Tsaur bank = 0,
904d5ace945SErwin T Tsaur base
9050803869aSToomas Soome };
906d5ace945SErwin T Tsaur
907d5ace945SErwin T Tsaur static char *nexus_opts[] = {
908d5ace945SErwin T Tsaur "bank",
909d5ace945SErwin T Tsaur "base",
910d5ace945SErwin T Tsaur NULL
911d5ace945SErwin T Tsaur };
912d5ace945SErwin T Tsaur
913d5ace945SErwin T Tsaur char *value;
914d5ace945SErwin T Tsaur uint64_t recv64;
915d5ace945SErwin T Tsaur
916d5ace945SErwin T Tsaur int rval = SUCCESS;
917d5ace945SErwin T Tsaur
918d5ace945SErwin T Tsaur if (input == NULL) {
919d5ace945SErwin T Tsaur (void) fprintf(stderr, "Missing argument.\n");
920d5ace945SErwin T Tsaur return (FAILURE);
921d5ace945SErwin T Tsaur }
922d5ace945SErwin T Tsaur
923d5ace945SErwin T Tsaur while ((*input != '\0') && (rval == SUCCESS)) {
924d5ace945SErwin T Tsaur switch (getsubopt(&input, nexus_opts, &value)) {
925d5ace945SErwin T Tsaur case bank:
926d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
927d5ace945SErwin T Tsaur (void) fprintf(stderr, "The bank or bar arg is "
928d5ace945SErwin T Tsaur "specified more than once.\n");
929d5ace945SErwin T Tsaur rval = FAILURE;
930d5ace945SErwin T Tsaur break;
931d5ace945SErwin T Tsaur }
932d5ace945SErwin T Tsaur if (*flags_arg & BASE_SPEC_FLAG) {
933d5ace945SErwin T Tsaur (void) fprintf(stderr, "Bank and base address "
934d5ace945SErwin T Tsaur "cannot both be specified.\n");
935d5ace945SErwin T Tsaur rval = FAILURE;
936d5ace945SErwin T Tsaur break;
937d5ace945SErwin T Tsaur }
938d5ace945SErwin T Tsaur if (value == NULL) {
939d5ace945SErwin T Tsaur (void) fprintf(stderr, "Missing bank value.\n");
940d5ace945SErwin T Tsaur rval = FAILURE;
941d5ace945SErwin T Tsaur break;
942d5ace945SErwin T Tsaur }
943d5ace945SErwin T Tsaur if ((rval = get_value64(value, &recv64, HEX_ONLY)) !=
944d5ace945SErwin T Tsaur SUCCESS) {
945d5ace945SErwin T Tsaur break;
946d5ace945SErwin T Tsaur }
947d5ace945SErwin T Tsaur *bank_arg = (uint8_t)recv64;
948d5ace945SErwin T Tsaur if (*bank_arg != recv64) {
949d5ace945SErwin T Tsaur (void) fprintf(stderr,
950d5ace945SErwin T Tsaur "Bank argument must fit into 8 bits.\n");
951d5ace945SErwin T Tsaur rval = FAILURE;
952d5ace945SErwin T Tsaur break;
953d5ace945SErwin T Tsaur }
954d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
955d5ace945SErwin T Tsaur break;
956d5ace945SErwin T Tsaur
957d5ace945SErwin T Tsaur case base:
958d5ace945SErwin T Tsaur if (*flags_arg & BASE_SPEC_FLAG) {
959d5ace945SErwin T Tsaur (void) fprintf(stderr, "The base address "
960d5ace945SErwin T Tsaur "is specified more than once.\n");
961d5ace945SErwin T Tsaur rval = FAILURE;
962d5ace945SErwin T Tsaur break;
963d5ace945SErwin T Tsaur }
964d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
965d5ace945SErwin T Tsaur (void) fprintf(stderr, "Bank and base address "
966d5ace945SErwin T Tsaur "cannot both be specified.\n");
967d5ace945SErwin T Tsaur rval = FAILURE;
968d5ace945SErwin T Tsaur break;
969d5ace945SErwin T Tsaur }
970d5ace945SErwin T Tsaur if (value == NULL) {
971d5ace945SErwin T Tsaur (void) fprintf(stderr,
972d5ace945SErwin T Tsaur "Missing base addr value.\n");
973d5ace945SErwin T Tsaur rval = FAILURE;
974d5ace945SErwin T Tsaur break;
975d5ace945SErwin T Tsaur }
976d5ace945SErwin T Tsaur if ((rval = get_value64(value, base_addr_arg,
977d5ace945SErwin T Tsaur HEX_ONLY)) != SUCCESS) {
978d5ace945SErwin T Tsaur break;
979d5ace945SErwin T Tsaur }
980d5ace945SErwin T Tsaur *flags_arg |= BASE_SPEC_FLAG;
981d5ace945SErwin T Tsaur break;
982d5ace945SErwin T Tsaur
983d5ace945SErwin T Tsaur default:
984d5ace945SErwin T Tsaur (void) fprintf(stderr, "Unrecognized option for -n\n");
985d5ace945SErwin T Tsaur rval = FAILURE;
986d5ace945SErwin T Tsaur break;
987d5ace945SErwin T Tsaur }
988d5ace945SErwin T Tsaur }
989d5ace945SErwin T Tsaur
990d5ace945SErwin T Tsaur return (rval);
991d5ace945SErwin T Tsaur }
992d5ace945SErwin T Tsaur
993d5ace945SErwin T Tsaur
994d5ace945SErwin T Tsaur static int
extract_bdf_arg(char * cvalue,char * fld,uint64_t fld_flag,uint64_t * all_flags,uint8_t * ivalue)995d5ace945SErwin T Tsaur extract_bdf_arg(char *cvalue, char *fld, uint64_t fld_flag, uint64_t *all_flags,
996d5ace945SErwin T Tsaur uint8_t *ivalue)
997d5ace945SErwin T Tsaur {
998d5ace945SErwin T Tsaur uint64_t recv64;
999d5ace945SErwin T Tsaur
1000d5ace945SErwin T Tsaur if (*all_flags & fld_flag) {
1001d5ace945SErwin T Tsaur (void) fprintf(stderr,
1002d5ace945SErwin T Tsaur "The %s is specified more than once.\n", fld);
1003d5ace945SErwin T Tsaur return (FAILURE);
1004d5ace945SErwin T Tsaur }
1005d5ace945SErwin T Tsaur if (get_value64(cvalue, &recv64, HEX_ONLY) != SUCCESS)
1006d5ace945SErwin T Tsaur return (FAILURE);
1007d5ace945SErwin T Tsaur
1008d5ace945SErwin T Tsaur *ivalue = (uint8_t)recv64;
1009d5ace945SErwin T Tsaur if (recv64 != *ivalue) {
1010d5ace945SErwin T Tsaur (void) fprintf(stderr,
1011d5ace945SErwin T Tsaur "This program limits the %s argument to 8 bits.\n", fld);
1012d5ace945SErwin T Tsaur (void) fprintf(stderr, "The actual maximum may be "
1013d5ace945SErwin T Tsaur "smaller but cannot be enforced by this program.\n");
1014d5ace945SErwin T Tsaur return (FAILURE);
1015d5ace945SErwin T Tsaur }
1016d5ace945SErwin T Tsaur
1017d5ace945SErwin T Tsaur *all_flags |= fld_flag;
1018d5ace945SErwin T Tsaur return (SUCCESS);
1019d5ace945SErwin T Tsaur }
1020d5ace945SErwin T Tsaur
1021d5ace945SErwin T Tsaur
extract_bdf(char * value,char ** bvalue_p,char ** dvalue_p,char ** fvalue_p)1022d5ace945SErwin T Tsaur static int extract_bdf(char *value, char **bvalue_p, char **dvalue_p,
1023d5ace945SErwin T Tsaur char **fvalue_p)
1024d5ace945SErwin T Tsaur {
1025d5ace945SErwin T Tsaur char *strtok_state;
1026d5ace945SErwin T Tsaur char *dummy;
1027d5ace945SErwin T Tsaur static char *separator = ".";
1028d5ace945SErwin T Tsaur
1029d5ace945SErwin T Tsaur *bvalue_p = strtok_r(value, separator, &strtok_state);
1030d5ace945SErwin T Tsaur *dvalue_p = strtok_r(NULL, separator, &strtok_state);
1031d5ace945SErwin T Tsaur *fvalue_p = strtok_r(NULL, separator, &strtok_state);
1032d5ace945SErwin T Tsaur dummy = strtok_r(NULL, separator, &strtok_state);
1033d5ace945SErwin T Tsaur
1034d5ace945SErwin T Tsaur /* Return failure only if too many values specified. */
1035d5ace945SErwin T Tsaur return ((dummy) ? FAILURE : SUCCESS);
1036d5ace945SErwin T Tsaur }
1037d5ace945SErwin T Tsaur
1038d5ace945SErwin T Tsaur /*
1039d5ace945SErwin T Tsaur * Parse device options. This includes:
1040d5ace945SErwin T Tsaur * bus=number
1041d5ace945SErwin T Tsaur * dev=number
1042d5ace945SErwin T Tsaur * func=number
1043d5ace945SErwin T Tsaur * bank=number
1044d5ace945SErwin T Tsaur * config
1045d5ace945SErwin T Tsaur * bar0
1046d5ace945SErwin T Tsaur * bar1
1047d5ace945SErwin T Tsaur * bar2
1048d5ace945SErwin T Tsaur * bar3
1049d5ace945SErwin T Tsaur * bar4
1050d5ace945SErwin T Tsaur * bar5
1051d5ace945SErwin T Tsaur * rom
1052d5ace945SErwin T Tsaur *
1053d5ace945SErwin T Tsaur * input is what the user specified for the options on the commandline,
1054d5ace945SErwin T Tsaur * flags_arg is modified with the options set, and the rest of the args return
1055d5ace945SErwin T Tsaur * their respective values.
1056d5ace945SErwin T Tsaur */
1057d5ace945SErwin T Tsaur static int
parse_device_opts(char * input,uint64_t * flags_arg,uint8_t * bus_arg,uint8_t * device_arg,uint8_t * func_arg,uint8_t * bank_arg)1058d5ace945SErwin T Tsaur parse_device_opts(
1059d5ace945SErwin T Tsaur char *input, uint64_t *flags_arg, uint8_t *bus_arg, uint8_t *device_arg,
1060d5ace945SErwin T Tsaur uint8_t *func_arg, uint8_t *bank_arg)
1061d5ace945SErwin T Tsaur {
1062d5ace945SErwin T Tsaur /* Needed by getsubopt(3C) */
10630803869aSToomas Soome enum bdf_opts_index {
1064d5ace945SErwin T Tsaur bus = 0,
1065d5ace945SErwin T Tsaur dev = 1,
1066d5ace945SErwin T Tsaur func = 2,
1067d5ace945SErwin T Tsaur bdf = 3,
1068d5ace945SErwin T Tsaur bank = 4,
1069d5ace945SErwin T Tsaur config = 5,
1070d5ace945SErwin T Tsaur bar0 = 6,
1071d5ace945SErwin T Tsaur bar1 = 7,
1072d5ace945SErwin T Tsaur bar2 = 8,
1073d5ace945SErwin T Tsaur bar3 = 9,
1074d5ace945SErwin T Tsaur bar4 = 10,
1075d5ace945SErwin T Tsaur bar5 = 11,
1076d5ace945SErwin T Tsaur rom = 12
10770803869aSToomas Soome };
1078d5ace945SErwin T Tsaur
1079d5ace945SErwin T Tsaur /* Needed by getsubopt(3C) */
1080d5ace945SErwin T Tsaur static char *bdf_opts[] = {
1081d5ace945SErwin T Tsaur "bus",
1082d5ace945SErwin T Tsaur "dev",
1083d5ace945SErwin T Tsaur "func",
1084d5ace945SErwin T Tsaur "bdf",
1085d5ace945SErwin T Tsaur "bank",
1086d5ace945SErwin T Tsaur "config",
1087d5ace945SErwin T Tsaur "bar0",
1088d5ace945SErwin T Tsaur "bar1",
1089d5ace945SErwin T Tsaur "bar2",
1090d5ace945SErwin T Tsaur "bar3",
1091d5ace945SErwin T Tsaur "bar4",
1092d5ace945SErwin T Tsaur "bar5",
1093d5ace945SErwin T Tsaur "rom",
1094d5ace945SErwin T Tsaur NULL };
1095d5ace945SErwin T Tsaur
1096d5ace945SErwin T Tsaur char *value; /* Current suboption being processed. */
1097d5ace945SErwin T Tsaur uint64_t recv64; /* Temporary value. */
1098d5ace945SErwin T Tsaur
1099d5ace945SErwin T Tsaur /* This error message is used in many places. */
1100d5ace945SErwin T Tsaur static char bank_err[] =
1101d5ace945SErwin T Tsaur {"The bank or bar arg is specified more than once.\n"};
1102d5ace945SErwin T Tsaur
1103d5ace945SErwin T Tsaur int rval = SUCCESS;
1104d5ace945SErwin T Tsaur
1105d5ace945SErwin T Tsaur while ((*input != '\0') && (rval == SUCCESS)) {
1106d5ace945SErwin T Tsaur switch (getsubopt(&input, bdf_opts, &value)) {
1107d5ace945SErwin T Tsaur
1108d5ace945SErwin T Tsaur /* bus=number */
1109d5ace945SErwin T Tsaur case bdf: {
1110d5ace945SErwin T Tsaur char *bvalue, *dvalue, *fvalue;
1111d5ace945SErwin T Tsaur
1112d5ace945SErwin T Tsaur if ((rval = extract_bdf(value, &bvalue, &dvalue,
1113d5ace945SErwin T Tsaur &fvalue)) != SUCCESS) {
1114d5ace945SErwin T Tsaur break;
1115d5ace945SErwin T Tsaur }
1116d5ace945SErwin T Tsaur
1117d5ace945SErwin T Tsaur if (!bvalue | !dvalue | !fvalue) {
1118d5ace945SErwin T Tsaur break;
1119d5ace945SErwin T Tsaur }
1120d5ace945SErwin T Tsaur
1121d5ace945SErwin T Tsaur if ((rval = extract_bdf_arg(bvalue, "bus",
1122d5ace945SErwin T Tsaur BUS_SPEC_FLAG, flags_arg, bus_arg)) != SUCCESS) {
1123d5ace945SErwin T Tsaur break;
1124d5ace945SErwin T Tsaur }
1125d5ace945SErwin T Tsaur if ((rval = extract_bdf_arg(dvalue, "dev",
1126d5ace945SErwin T Tsaur DEV_SPEC_FLAG, flags_arg, device_arg)) != SUCCESS) {
1127d5ace945SErwin T Tsaur break;
1128d5ace945SErwin T Tsaur }
1129d5ace945SErwin T Tsaur rval = extract_bdf_arg(fvalue, "func",
1130d5ace945SErwin T Tsaur FUNC_SPEC_FLAG, flags_arg, func_arg);
1131d5ace945SErwin T Tsaur break;
1132d5ace945SErwin T Tsaur }
1133d5ace945SErwin T Tsaur
1134d5ace945SErwin T Tsaur case bus:
1135d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "bus", BUS_SPEC_FLAG,
1136d5ace945SErwin T Tsaur flags_arg, bus_arg);
1137d5ace945SErwin T Tsaur break;
1138d5ace945SErwin T Tsaur
1139d5ace945SErwin T Tsaur /* dev=number */
1140d5ace945SErwin T Tsaur case dev:
1141d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "dev", DEV_SPEC_FLAG,
1142d5ace945SErwin T Tsaur flags_arg, device_arg);
1143d5ace945SErwin T Tsaur break;
1144d5ace945SErwin T Tsaur
1145d5ace945SErwin T Tsaur /* func=number */
1146d5ace945SErwin T Tsaur case func:
1147d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "func", FUNC_SPEC_FLAG,
1148d5ace945SErwin T Tsaur flags_arg, func_arg);
1149d5ace945SErwin T Tsaur break;
1150d5ace945SErwin T Tsaur
1151d5ace945SErwin T Tsaur /* bank=number */
1152d5ace945SErwin T Tsaur case bank:
1153d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1154d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1155d5ace945SErwin T Tsaur rval = FAILURE;
1156d5ace945SErwin T Tsaur break;
1157d5ace945SErwin T Tsaur }
1158d5ace945SErwin T Tsaur if ((rval = get_value64(value, &recv64, HEX_ONLY)) !=
1159d5ace945SErwin T Tsaur SUCCESS) {
1160d5ace945SErwin T Tsaur break;
1161d5ace945SErwin T Tsaur }
1162d5ace945SErwin T Tsaur *bank_arg = (uint8_t)recv64;
1163d5ace945SErwin T Tsaur if (rval || (*bank_arg != recv64)) {
1164d5ace945SErwin T Tsaur (void) fprintf(stderr, "Bank argument must"
1165d5ace945SErwin T Tsaur " fit into 8 bits.\n");
1166d5ace945SErwin T Tsaur rval = FAILURE;
1167d5ace945SErwin T Tsaur break;
1168d5ace945SErwin T Tsaur }
1169d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1170d5ace945SErwin T Tsaur break;
1171d5ace945SErwin T Tsaur
1172d5ace945SErwin T Tsaur /* config */
1173d5ace945SErwin T Tsaur case config:
1174d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1175d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1176d5ace945SErwin T Tsaur rval = FAILURE;
1177d5ace945SErwin T Tsaur break;
1178d5ace945SErwin T Tsaur }
1179d5ace945SErwin T Tsaur *bank_arg = PCITOOL_CONFIG;
1180d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1181d5ace945SErwin T Tsaur break;
1182d5ace945SErwin T Tsaur
1183d5ace945SErwin T Tsaur /* bar0 */
1184d5ace945SErwin T Tsaur case bar0:
1185d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1186d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1187d5ace945SErwin T Tsaur rval = FAILURE;
1188d5ace945SErwin T Tsaur break;
1189d5ace945SErwin T Tsaur }
1190d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR0;
1191d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1192d5ace945SErwin T Tsaur break;
1193d5ace945SErwin T Tsaur
1194d5ace945SErwin T Tsaur /* bar1 */
1195d5ace945SErwin T Tsaur case bar1:
1196d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1197d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1198d5ace945SErwin T Tsaur rval = FAILURE;
1199d5ace945SErwin T Tsaur break;
1200d5ace945SErwin T Tsaur }
1201d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR1;
1202d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1203d5ace945SErwin T Tsaur break;
1204d5ace945SErwin T Tsaur
1205d5ace945SErwin T Tsaur /* bar2 */
1206d5ace945SErwin T Tsaur case bar2:
1207d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1208d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1209d5ace945SErwin T Tsaur rval = FAILURE;
1210d5ace945SErwin T Tsaur break;
1211d5ace945SErwin T Tsaur }
1212d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR2;
1213d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1214d5ace945SErwin T Tsaur break;
1215d5ace945SErwin T Tsaur
1216d5ace945SErwin T Tsaur /* bar3 */
1217d5ace945SErwin T Tsaur case bar3:
1218d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1219d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1220d5ace945SErwin T Tsaur rval = FAILURE;
1221d5ace945SErwin T Tsaur break;
1222d5ace945SErwin T Tsaur }
1223d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR3;
1224d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1225d5ace945SErwin T Tsaur break;
1226d5ace945SErwin T Tsaur
1227d5ace945SErwin T Tsaur /* bar4 */
1228d5ace945SErwin T Tsaur case bar4:
1229d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1230d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1231d5ace945SErwin T Tsaur rval = FAILURE;
1232d5ace945SErwin T Tsaur break;
1233d5ace945SErwin T Tsaur }
1234d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR4;
1235d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1236d5ace945SErwin T Tsaur break;
1237d5ace945SErwin T Tsaur
1238d5ace945SErwin T Tsaur /* bar5 */
1239d5ace945SErwin T Tsaur case bar5:
1240d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1241d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1242d5ace945SErwin T Tsaur rval = FAILURE;
1243d5ace945SErwin T Tsaur break;
1244d5ace945SErwin T Tsaur }
1245d5ace945SErwin T Tsaur *bank_arg = PCITOOL_BAR5;
1246d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1247d5ace945SErwin T Tsaur break;
1248d5ace945SErwin T Tsaur
1249d5ace945SErwin T Tsaur /* rom */
1250d5ace945SErwin T Tsaur case rom:
1251d5ace945SErwin T Tsaur if (*flags_arg & BANK_SPEC_FLAG) {
1252d5ace945SErwin T Tsaur (void) fprintf(stderr, bank_err);
1253d5ace945SErwin T Tsaur rval = FAILURE;
1254d5ace945SErwin T Tsaur break;
1255d5ace945SErwin T Tsaur }
1256d5ace945SErwin T Tsaur *bank_arg = PCITOOL_ROM;
1257d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1258d5ace945SErwin T Tsaur break;
1259d5ace945SErwin T Tsaur
1260d5ace945SErwin T Tsaur default:
1261d5ace945SErwin T Tsaur (void) fprintf(stderr, "Unrecognized option for -d\n");
1262d5ace945SErwin T Tsaur rval = FAILURE;
1263d5ace945SErwin T Tsaur break;
1264d5ace945SErwin T Tsaur }
1265d5ace945SErwin T Tsaur }
1266d5ace945SErwin T Tsaur
1267d5ace945SErwin T Tsaur /* Bus, dev and func must all be specified. */
1268d5ace945SErwin T Tsaur if ((*flags_arg & (BUS_SPEC_FLAG | DEV_SPEC_FLAG | FUNC_SPEC_FLAG)) !=
1269d5ace945SErwin T Tsaur (BUS_SPEC_FLAG | DEV_SPEC_FLAG | FUNC_SPEC_FLAG)) {
1270d5ace945SErwin T Tsaur rval = FAILURE;
1271d5ace945SErwin T Tsaur
1272d5ace945SErwin T Tsaur /* No bank specified in any way. Default to config space */
1273d5ace945SErwin T Tsaur } else if ((*flags_arg & BANK_SPEC_FLAG) == 0) {
1274d5ace945SErwin T Tsaur *flags_arg |= BANK_SPEC_FLAG;
1275d5ace945SErwin T Tsaur *bank_arg = PCITOOL_CONFIG;
1276d5ace945SErwin T Tsaur }
1277d5ace945SErwin T Tsaur
1278d5ace945SErwin T Tsaur return (rval);
1279d5ace945SErwin T Tsaur }
1280d5ace945SErwin T Tsaur
1281d5ace945SErwin T Tsaur
1282d5ace945SErwin T Tsaur /*
128309b1eac2SEvan Yan * Parse INO options. This includes:
128409b1eac2SEvan Yan * ino# | all
1285d5ace945SErwin T Tsaur *
1286d5ace945SErwin T Tsaur * input is the string of options to parse. flags_arg returns modified with
1287d5ace945SErwin T Tsaur * specified options set. Other args return their respective values.
1288d5ace945SErwin T Tsaur */
1289d5ace945SErwin T Tsaur static int
parse_ino_opts(char * input,uint64_t * flags_arg,uint32_t * cpu_arg,uint8_t * ino_arg)12907ff178cdSJimmy Vetayases parse_ino_opts(char *input, uint64_t *flags_arg, uint32_t *cpu_arg,
12917ff178cdSJimmy Vetayases uint8_t *ino_arg)
1292d5ace945SErwin T Tsaur {
129309b1eac2SEvan Yan uint64_t value;
12947ff178cdSJimmy Vetayases char *charvalue;
129509b1eac2SEvan Yan int rval = SUCCESS;
1296d5ace945SErwin T Tsaur
129709b1eac2SEvan Yan if (strcmp(input, "all") == 0) {
129809b1eac2SEvan Yan *flags_arg |= INO_ALL_FLAG;
12997ff178cdSJimmy Vetayases #ifdef __x86
13007ff178cdSJimmy Vetayases } else if (strstr(input, ",") == NULL) {
13017ff178cdSJimmy Vetayases (void) fprintf(stderr,
13027ff178cdSJimmy Vetayases "Interrupt format should be <cpu#,ino#>.\n");
13037ff178cdSJimmy Vetayases rval = FAILURE;
13047ff178cdSJimmy Vetayases #else
13057ff178cdSJimmy Vetayases } else if (strstr(input, ",") == NULL) {
13067ff178cdSJimmy Vetayases if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS)
13077ff178cdSJimmy Vetayases *ino_arg = (uint8_t)value;
13087ff178cdSJimmy Vetayases
13097ff178cdSJimmy Vetayases if (*ino_arg != value) {
13107ff178cdSJimmy Vetayases (void) fprintf(stderr,
13117ff178cdSJimmy Vetayases "ino argument must fit into 8 bits.\n");
13127ff178cdSJimmy Vetayases rval = FAILURE;
13137ff178cdSJimmy Vetayases } else {
13147ff178cdSJimmy Vetayases *flags_arg |= INO_SPEC_FLAG;
13157ff178cdSJimmy Vetayases }
13167ff178cdSJimmy Vetayases #endif
13177ff178cdSJimmy Vetayases } else if (charvalue = strtok(input, ",")) {
13187ff178cdSJimmy Vetayases if ((rval =
13197ff178cdSJimmy Vetayases get_value64(charvalue, &value, HEX_ONLY)) == SUCCESS) {
13207ff178cdSJimmy Vetayases *cpu_arg = (int)value;
13217ff178cdSJimmy Vetayases }
13227ff178cdSJimmy Vetayases
13237ff178cdSJimmy Vetayases input = strtok(NULL, ",");
13247ff178cdSJimmy Vetayases if (input == NULL) {
13257ff178cdSJimmy Vetayases (void) fprintf(stderr, "ino argument is need.\n");
13267ff178cdSJimmy Vetayases return (FAILURE);
13277ff178cdSJimmy Vetayases }
13287ff178cdSJimmy Vetayases
13297ff178cdSJimmy Vetayases if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS)
13307ff178cdSJimmy Vetayases *ino_arg = (uint8_t)value;
1331d5ace945SErwin T Tsaur
133209b1eac2SEvan Yan if (*ino_arg != value) {
133309b1eac2SEvan Yan (void) fprintf(stderr,
133409b1eac2SEvan Yan "ino argument must fit into 8 bits.\n");
133509b1eac2SEvan Yan rval = FAILURE;
133609b1eac2SEvan Yan } else {
133709b1eac2SEvan Yan *flags_arg |= INO_SPEC_FLAG;
133809b1eac2SEvan Yan }
133909b1eac2SEvan Yan } else {
134009b1eac2SEvan Yan (void) fprintf(stderr,
134109b1eac2SEvan Yan "Unrecognized option for -i\n");
134209b1eac2SEvan Yan rval = FAILURE;
134309b1eac2SEvan Yan }
1344d5ace945SErwin T Tsaur
134509b1eac2SEvan Yan return (rval);
134609b1eac2SEvan Yan }
1347d5ace945SErwin T Tsaur
1348d5ace945SErwin T Tsaur
134909b1eac2SEvan Yan /*
135009b1eac2SEvan Yan * Parse MSI options. This includes:
135109b1eac2SEvan Yan * msi# | all
135209b1eac2SEvan Yan *
135309b1eac2SEvan Yan * input is the string of options to parse. flags_arg returns modified with
135409b1eac2SEvan Yan * specified options set. Other args return their respective values.
135509b1eac2SEvan Yan */
135609b1eac2SEvan Yan static int
parse_msi_opts(char * input,uint64_t * flags_arg,uint16_t * msi_arg)135709b1eac2SEvan Yan parse_msi_opts(char *input, uint64_t *flags_arg, uint16_t *msi_arg)
135809b1eac2SEvan Yan {
135909b1eac2SEvan Yan uint64_t value;
136009b1eac2SEvan Yan int rval = SUCCESS;
1361d5ace945SErwin T Tsaur
136209b1eac2SEvan Yan if (strcmp(input, "all") == 0) {
136309b1eac2SEvan Yan *flags_arg |= MSI_ALL_FLAG;
13647ff178cdSJimmy Vetayases } else if (strstr(input, ",") == NULL) {
13657ff178cdSJimmy Vetayases if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS)
13667ff178cdSJimmy Vetayases *msi_arg = (uint16_t)value;
13677ff178cdSJimmy Vetayases
13687ff178cdSJimmy Vetayases if (*msi_arg != value) {
13697ff178cdSJimmy Vetayases (void) fprintf(stderr,
13707ff178cdSJimmy Vetayases "msi argument must fit into 16 bits.\n");
13717ff178cdSJimmy Vetayases rval = FAILURE;
13727ff178cdSJimmy Vetayases } else {
13737ff178cdSJimmy Vetayases *flags_arg |= MSI_SPEC_FLAG;
13747ff178cdSJimmy Vetayases }
13757ff178cdSJimmy Vetayases } else if (strtok(input, ",")) {
13767ff178cdSJimmy Vetayases input = strtok(NULL, ",");
13777ff178cdSJimmy Vetayases if (input == NULL) {
13787ff178cdSJimmy Vetayases (void) fprintf(stderr, "msi argument is need.\n");
13797ff178cdSJimmy Vetayases return (FAILURE);
13807ff178cdSJimmy Vetayases }
13817ff178cdSJimmy Vetayases
13827ff178cdSJimmy Vetayases if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS)
13837ff178cdSJimmy Vetayases *msi_arg = (uint16_t)value;
138409b1eac2SEvan Yan
138509b1eac2SEvan Yan if (*msi_arg != value) {
1386d5ace945SErwin T Tsaur (void) fprintf(stderr,
138709b1eac2SEvan Yan "msi argument must fit into 16 bits.\n");
1388d5ace945SErwin T Tsaur rval = FAILURE;
138909b1eac2SEvan Yan } else {
139009b1eac2SEvan Yan *flags_arg |= MSI_SPEC_FLAG;
1391d5ace945SErwin T Tsaur }
139209b1eac2SEvan Yan } else {
139309b1eac2SEvan Yan (void) fprintf(stderr,
139409b1eac2SEvan Yan "Unrecognized option for -m\n");
139509b1eac2SEvan Yan rval = FAILURE;
1396d5ace945SErwin T Tsaur }
1397d5ace945SErwin T Tsaur
1398d5ace945SErwin T Tsaur return (rval);
1399d5ace945SErwin T Tsaur }
1400d5ace945SErwin T Tsaur
1401d5ace945SErwin T Tsaur
1402d5ace945SErwin T Tsaur /*
1403d5ace945SErwin T Tsaur * Parse interrupt set options. This includes:
1404d5ace945SErwin T Tsaur * cpu=number
1405d5ace945SErwin T Tsaur *
1406d5ace945SErwin T Tsaur * input is the string of options to parse. flags_arg returns modified with
1407d5ace945SErwin T Tsaur * specified options set. Other args return their respective values.
1408d5ace945SErwin T Tsaur */
1409d5ace945SErwin T Tsaur static int
parse_intr_set_opts(char * input,uint64_t * flags_arg,uint32_t * cpu_arg)1410d5ace945SErwin T Tsaur parse_intr_set_opts(char *input, uint64_t *flags_arg, uint32_t *cpu_arg)
1411d5ace945SErwin T Tsaur {
141209b1eac2SEvan Yan uint64_t value;
141309b1eac2SEvan Yan int rval = SUCCESS;
1414d5ace945SErwin T Tsaur
141509b1eac2SEvan Yan if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) {
1416d5ace945SErwin T Tsaur
141709b1eac2SEvan Yan if ((long)value > sysconf(_SC_CPUID_MAX)) {
141809b1eac2SEvan Yan (void) fprintf(stderr, "Cpu argument "
141909b1eac2SEvan Yan "exceeds maximum for this system type.\n");
1420d5ace945SErwin T Tsaur rval = FAILURE;
142109b1eac2SEvan Yan } else {
142209b1eac2SEvan Yan *cpu_arg = (uint32_t)value;
142309b1eac2SEvan Yan *flags_arg |= CPU_SPEC_FLAG;
1424d5ace945SErwin T Tsaur }
142509b1eac2SEvan Yan } else {
142609b1eac2SEvan Yan (void) fprintf(stderr,
142709b1eac2SEvan Yan "Unrecognized option for -i -m -w\n");
1428*bc54f855SJohn Levon rval = FAILURE;
1429d5ace945SErwin T Tsaur }
1430d5ace945SErwin T Tsaur
1431d5ace945SErwin T Tsaur return (rval);
1432d5ace945SErwin T Tsaur }
1433d5ace945SErwin T Tsaur
1434d5ace945SErwin T Tsaur
1435d5ace945SErwin T Tsaur static int
parse_probeone_opts(char * input,uint64_t * flags_arg,uint8_t * bus_arg,uint8_t * device_arg,uint8_t * func_arg)1436d5ace945SErwin T Tsaur parse_probeone_opts(
1437d5ace945SErwin T Tsaur char *input, uint64_t *flags_arg, uint8_t *bus_arg, uint8_t *device_arg,
1438d5ace945SErwin T Tsaur uint8_t *func_arg)
1439d5ace945SErwin T Tsaur {
14400803869aSToomas Soome enum p1_bdf_opts_index {
1441d5ace945SErwin T Tsaur bus = 0,
1442d5ace945SErwin T Tsaur dev = 1,
1443d5ace945SErwin T Tsaur func = 2,
1444d5ace945SErwin T Tsaur bdf = 3
14450803869aSToomas Soome };
1446d5ace945SErwin T Tsaur
1447d5ace945SErwin T Tsaur /* Needed by getsubopt(3C) */
1448d5ace945SErwin T Tsaur static char *p1_bdf_opts[] = {
1449d5ace945SErwin T Tsaur "bus",
1450d5ace945SErwin T Tsaur "dev",
1451d5ace945SErwin T Tsaur "func",
1452d5ace945SErwin T Tsaur "bdf",
1453d5ace945SErwin T Tsaur NULL };
1454d5ace945SErwin T Tsaur
1455d5ace945SErwin T Tsaur char *value; /* Current suboption being processed. */
1456d5ace945SErwin T Tsaur
1457d5ace945SErwin T Tsaur int rval = SUCCESS;
1458d5ace945SErwin T Tsaur
1459d5ace945SErwin T Tsaur while ((*input != '\0') && (rval == SUCCESS)) {
1460d5ace945SErwin T Tsaur switch (getsubopt(&input, p1_bdf_opts, &value)) {
1461d5ace945SErwin T Tsaur
1462d5ace945SErwin T Tsaur /* bus=number */
1463d5ace945SErwin T Tsaur case bdf: {
1464d5ace945SErwin T Tsaur char *bvalue, *dvalue, *fvalue;
1465d5ace945SErwin T Tsaur
1466d5ace945SErwin T Tsaur if ((rval = extract_bdf(value, &bvalue, &dvalue,
1467d5ace945SErwin T Tsaur &fvalue)) != SUCCESS) {
1468d5ace945SErwin T Tsaur break;
1469d5ace945SErwin T Tsaur }
1470d5ace945SErwin T Tsaur if (bvalue)
1471d5ace945SErwin T Tsaur if ((rval = extract_bdf_arg(bvalue, "bus",
1472d5ace945SErwin T Tsaur BUS_SPEC_FLAG, flags_arg, bus_arg)) !=
1473d5ace945SErwin T Tsaur SUCCESS) {
1474d5ace945SErwin T Tsaur break;
1475d5ace945SErwin T Tsaur }
1476d5ace945SErwin T Tsaur if (dvalue)
1477d5ace945SErwin T Tsaur if ((rval = extract_bdf_arg(dvalue, "dev",
1478d5ace945SErwin T Tsaur DEV_SPEC_FLAG, flags_arg, device_arg)) !=
1479d5ace945SErwin T Tsaur SUCCESS) {
1480d5ace945SErwin T Tsaur break;
1481d5ace945SErwin T Tsaur }
1482d5ace945SErwin T Tsaur if (fvalue)
1483d5ace945SErwin T Tsaur rval = extract_bdf_arg(fvalue, "func",
1484d5ace945SErwin T Tsaur FUNC_SPEC_FLAG, flags_arg, func_arg);
1485d5ace945SErwin T Tsaur break;
1486d5ace945SErwin T Tsaur }
1487d5ace945SErwin T Tsaur
1488d5ace945SErwin T Tsaur case bus:
1489d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "bus", BUS_SPEC_FLAG,
1490d5ace945SErwin T Tsaur flags_arg, bus_arg);
1491d5ace945SErwin T Tsaur break;
1492d5ace945SErwin T Tsaur
1493d5ace945SErwin T Tsaur /* dev=number */
1494d5ace945SErwin T Tsaur case dev:
1495d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "dev", DEV_SPEC_FLAG,
1496d5ace945SErwin T Tsaur flags_arg, device_arg);
1497d5ace945SErwin T Tsaur break;
1498d5ace945SErwin T Tsaur
1499d5ace945SErwin T Tsaur /* func=number */
1500d5ace945SErwin T Tsaur case func:
1501d5ace945SErwin T Tsaur rval = extract_bdf_arg(value, "func", FUNC_SPEC_FLAG,
1502d5ace945SErwin T Tsaur flags_arg, func_arg);
1503d5ace945SErwin T Tsaur break;
1504d5ace945SErwin T Tsaur
1505d5ace945SErwin T Tsaur default:
1506d5ace945SErwin T Tsaur (void) fprintf(stderr, "Unrecognized option for -p\n");
1507d5ace945SErwin T Tsaur rval = FAILURE;
1508d5ace945SErwin T Tsaur break;
1509d5ace945SErwin T Tsaur }
1510d5ace945SErwin T Tsaur }
1511d5ace945SErwin T Tsaur
1512d5ace945SErwin T Tsaur return (rval);
1513d5ace945SErwin T Tsaur }
1514d5ace945SErwin T Tsaur
1515d5ace945SErwin T Tsaur
1516d5ace945SErwin T Tsaur #ifdef DEBUG
1517d5ace945SErwin T Tsaur
1518d5ace945SErwin T Tsaur static void
dump_struct(pcitool_uiargs_t * dumpthis)15190803869aSToomas Soome dump_struct(pcitool_uiargs_t *dumpthis)
15200803869aSToomas Soome {
1521d5ace945SErwin T Tsaur (void) printf("flags:0x%x\n", dumpthis->flags);
1522d5ace945SErwin T Tsaur (void) printf("bus:%d (0x%x)\n",
1523d5ace945SErwin T Tsaur dumpthis->bus, dumpthis->bus);
1524d5ace945SErwin T Tsaur (void) printf("device:%d (0x%x)\n", dumpthis->device,
1525d5ace945SErwin T Tsaur dumpthis->device);
1526d5ace945SErwin T Tsaur (void) printf("function:%d (0x%x)\n", dumpthis->function,
1527d5ace945SErwin T Tsaur dumpthis->function);
1528d5ace945SErwin T Tsaur (void) printf("write_value:%" PRIu64 " (0x%" PRIx64 ")\n",
1529d5ace945SErwin T Tsaur dumpthis->write_value, dumpthis->write_value);
1530d5ace945SErwin T Tsaur (void) printf("bank:%d (0x%x)\n",
1531d5ace945SErwin T Tsaur dumpthis->bank, dumpthis->bank);
1532d5ace945SErwin T Tsaur (void) printf("offset:%d (0x%x)\n", dumpthis->offset, dumpthis->offset);
1533d5ace945SErwin T Tsaur (void) printf("size:%d, endian:%s\n", dumpthis->size,
1534d5ace945SErwin T Tsaur dumpthis->big_endian ? "BIG" : "little");
1535d5ace945SErwin T Tsaur (void) printf("ino:%d, cpu:%d\n",
1536d5ace945SErwin T Tsaur dumpthis->intr_ino, dumpthis->intr_cpu);
1537d5ace945SErwin T Tsaur }
1538d5ace945SErwin T Tsaur
1539d5ace945SErwin T Tsaur #ifdef STANDALONE
1540d5ace945SErwin T Tsaur
1541d5ace945SErwin T Tsaur /* Test program for this module. Useful when implementing new options. */
1542d5ace945SErwin T Tsaur int
main(int argc,char * argv[])1543d5ace945SErwin T Tsaur main(int argc, char *argv[])
1544d5ace945SErwin T Tsaur {
1545d5ace945SErwin T Tsaur int status;
1546d5ace945SErwin T Tsaur pcitool_uiargs_t parsed_args;
1547d5ace945SErwin T Tsaur
1548d5ace945SErwin T Tsaur status = get_commandline_args(argc, argv, &parsed_args);
1549d5ace945SErwin T Tsaur if (status) {
1550d5ace945SErwin T Tsaur (void) printf("Error getting command.\n");
1551d5ace945SErwin T Tsaur }
1552d5ace945SErwin T Tsaur dump_struct(&parsed_args);
1553d5ace945SErwin T Tsaur
1554d5ace945SErwin T Tsaur return (SUCCESS);
1555d5ace945SErwin T Tsaur }
1556d5ace945SErwin T Tsaur
1557d5ace945SErwin T Tsaur #endif /* STANDALONE */
1558d5ace945SErwin T Tsaur #endif /* DEBUG */
1559