#include <err.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <sys/sysmacros.h>
#include <ofmt.h>
#include "i2cadm.h"
static bool
i2cadm_device_filt(const i2c_dev_info_t *info, int nfilts, char **filts,
bool *used)
{
bool match = false;
char inst[128] = { '\0' }, addr[64] = { '\0' };
const char *name, *path, *driver;
size_t pathlen;
if (nfilts == 0) {
return (true);
}
name = i2c_device_info_name(info);
path = i2c_device_info_path(info);
pathlen = strlen(path);
driver = i2c_device_info_driver(info);
if (i2c_device_info_instance(info) != -1 && driver != NULL) {
(void) snprintf(inst, sizeof (inst), "%s%d", driver,
i2c_device_info_instance(info));
}
const i2c_addr_t *ia = i2c_device_info_addr_primary(info);
if (!i2c_addr_to_string(i2cadm.i2c_hdl, ia, addr, sizeof (addr))) {
addr[0] = '\0';
}
for (int i = 0; i < nfilts; i++) {
if (strcmp(filts[i], name) == 0) {
used[i] = true;
match = true;
continue;
}
if (addr[0] != '\0' && strcmp(filts[i], addr) == 0) {
used[i] = true;
match = true;
continue;
}
if (driver != NULL && strcmp(filts[i], driver) == 0) {
used[i] = true;
match = true;
continue;
}
if (inst[0] != '\0' && strcmp(filts[i], inst) == 0) {
used[i] = true;
match = true;
continue;
}
if (strcmp(path, filts[i]) == 0) {
used[i] = true;
match = true;
continue;
}
size_t len = strlen(filts[i]);
if (len < pathlen && strncmp(path, filts[i], len) == 0) {
used[i] = true;
match = true;
continue;
}
}
return (match);
}
static int
i2cadm_device_iter(ofmt_handle_t ofmt, int argc, char *argv[], bool *filts,
void (*func)(ofmt_handle_t, const i2c_dev_info_t *))
{
int ret = EXIT_SUCCESS;
bool print = false;
const i2c_dev_disc_t *disc;
i2c_dev_iter_t *iter;
i2c_iter_t iret;
if (!i2c_device_discover_init(i2cadm.i2c_hdl, &iter)) {
i2cadm_fatal("failed to initialize device discovery");
}
while ((iret = i2c_device_discover_step(iter, &disc)) ==
I2C_ITER_VALID) {
i2c_dev_info_t *info;
if (!i2c_device_info_snap(i2cadm.i2c_hdl,
i2c_device_disc_devi(disc), &info)) {
i2cadm_warn("failed to get device information for "
"%s", i2c_device_disc_path(disc));
ret = EXIT_FAILURE;
continue;
}
if (!i2cadm_device_filt(info, argc, argv, filts)) {
i2c_device_info_free(info);
continue;
}
func(ofmt, info);
i2c_device_info_free(info);
print = true;
}
if (iret == I2C_ITER_ERROR) {
i2cadm_warn("failed to discover devices");
ret = EXIT_FAILURE;
}
for (int i = 0; i < argc; i++) {
if (!filts[i]) {
warnx("filter '%s' did not match any devices",
argv[i]);
ret = EXIT_FAILURE;
}
}
if (!print && argc == 0) {
warnx("no I2C devices found");
ret = EXIT_FAILURE;
}
free(filts);
ofmt_close(ofmt);
i2c_device_discover_fini(iter);
return (ret);
}
static void
i2cadm_device_addrs_usage(FILE *f)
{
(void) fprintf(f, "\ti2cadm device addrs [-H] [-o field,[...] [-p]] "
"[filter]\n");
}
static void
i2cadm_device_addrs_help(const char *fmt, ...)
{
if (fmt != NULL) {
va_list ap;
va_start(ap, fmt);
vwarnx(fmt, ap);
va_end(ap);
}
(void) fprintf(stderr, "Usage: i2cadm device addrs [-H] "
"[-o field[,...] [-p]] [filters]\n\n");
(void) fprintf(stderr, "List addresses assigned to devices and their "
"source. Each <filter> selects\ndevices based upon its address, "
"the device's name, the driver's name, the\ndriver's instance, or "
"the I2C path. Multiple filters are treated as an OR. It\n is an "
"error if a filter isn't used.\n\n"
"\t-H\t\tomit the column header\n"
"\t-o field\toutput fields to print\n"
"\t-p\t\tparseable output (requires -o)\n");
(void) fprintf(stderr, "\nThe following fields are supported:\n"
"\tpath\t\tthe device path\n"
"\ttype\t\tthe address's type\n"
"\taddr\t\tthe specific address\n"
"\tsource\tindicates where the address came from\n");
}
typedef enum {
I2CADM_DEVICE_ADDRS_PATH,
I2CADM_DEVICE_ADDRS_TYPE,
I2CADM_DEVICE_ADDRS_ADDR,
I2CADM_DEVICE_ADDRS_SOURCE
} i2cadm_device_addrs_otype_t;
typedef struct i2cadm_device_addrs_ofmt {
const i2c_dev_info_t *idoa_info;
const i2c_addr_t *idoa_addr;
i2c_addr_source_t idoa_source;
} i2cadm_device_addrs_ofmt_t;
static boolean_t
i2cadm_device_addrs_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
const i2cadm_device_addrs_ofmt_t *arg = ofarg->ofmt_cbarg;
size_t len;
switch (ofarg->ofmt_id) {
case I2CADM_DEVICE_ADDRS_PATH:
len = strlcpy(buf, i2c_device_info_path(arg->idoa_info),
buflen);
break;
case I2CADM_DEVICE_ADDRS_TYPE:
if (arg->idoa_addr->ia_type == I2C_ADDR_7BIT) {
len = strlcpy(buf, "7-bit", buflen);
} else if (arg->idoa_addr->ia_type == I2C_ADDR_10BIT) {
len = strlcpy(buf, "10-bit", buflen);
} else {
len = snprintf(buf, buflen, "unknown (0x%x)",
arg->idoa_addr->ia_type);
}
break;
case I2CADM_DEVICE_ADDRS_ADDR:
len = snprintf(buf, buflen, "0x%02x", arg->idoa_addr->ia_addr);
break;
case I2CADM_DEVICE_ADDRS_SOURCE:
switch (arg->idoa_source) {
case I2C_ADDR_SOURCE_REG:
len = strlcpy(buf, "platform", buflen);
break;
case I2C_ADDR_SOURCE_CLAIMED:
len = strlcpy(buf, "claimed", buflen);
break;
case I2C_ADDR_SOURCE_SHARED:
len = strlcpy(buf, "shared", buflen);
break;
default:
len = snprintf(buf, buflen, "unknown (0x%x)",
arg->idoa_source);
}
break;
default:
return (B_FALSE);
}
return (len < buflen);
}
static const char *i2cadm_device_addrs_fields = "path,type,addr,source";
static const ofmt_field_t i2cadm_device_addrs_ofmt[] = {
{ "PATH", 40, I2CADM_DEVICE_ADDRS_PATH, i2cadm_device_addrs_ofmt_cb },
{ "TYPE", 10, I2CADM_DEVICE_ADDRS_TYPE, i2cadm_device_addrs_ofmt_cb },
{ "ADDR", 10, I2CADM_DEVICE_ADDRS_ADDR, i2cadm_device_addrs_ofmt_cb },
{ "SOURCE", 16, I2CADM_DEVICE_ADDRS_SOURCE,
i2cadm_device_addrs_ofmt_cb },
{ NULL, 0, 0, NULL }
};
static void
i2cadm_device_addrs_cb(ofmt_handle_t ofmt, const i2c_dev_info_t *info)
{
for (uint32_t i = 0; i < i2c_device_info_naddrs(info); i++) {
i2cadm_device_addrs_ofmt_t arg;
arg.idoa_info = info;
arg.idoa_addr = i2c_device_info_addr(info, i);
arg.idoa_source = i2c_device_info_addr_source(info, i);
ofmt_print(ofmt, &arg);
}
}
static int
i2cadm_device_addrs(int argc, char *argv[])
{
int c;
uint_t flags = 0;
boolean_t parse = B_FALSE;
const char *fields = NULL;
bool *filts = NULL;
ofmt_status_t oferr;
ofmt_handle_t ofmt;
while ((c = getopt(argc, argv, ":Ho:p")) != -1) {
switch (c) {
case 'H':
flags |= OFMT_NOHEADER;
break;
case 'o':
fields = optarg;
break;
case 'p':
parse = B_TRUE;
flags |= OFMT_PARSABLE;
break;
case ':':
i2cadm_device_addrs_help("option -%c requires an "
"argument", optopt);
exit(EXIT_USAGE);
case '?':
i2cadm_device_addrs_help("unknown option: -%c",
optopt);
exit(EXIT_USAGE);
}
}
if (parse && fields == NULL) {
errx(EXIT_USAGE, "-p requires fields specified with -o");
}
if (!parse) {
flags |= OFMT_WRAP;
}
if (fields == NULL) {
fields = i2cadm_device_addrs_fields;
}
argc -= optind;
argv += optind;
if (argc > 0) {
filts = calloc(argc, sizeof (bool));
if (filts == NULL) {
err(EXIT_FAILURE, "failed to allocate memory for "
"filter tracking");
}
}
oferr = ofmt_open(fields, i2cadm_device_addrs_ofmt, flags, 0, &ofmt);
ofmt_check(oferr, parse, ofmt, i2cadm_ofmt_errx, warnx);
return (i2cadm_device_iter(ofmt, argc, argv, filts,
i2cadm_device_addrs_cb));
}
static void
i2cadm_device_list_usage(FILE *f)
{
(void) fprintf(f, "\ti2cadm device list [-H] [-o field,[...] [-p]] "
"[filter]\n");
}
static void
i2cadm_device_list_help(const char *fmt, ...)
{
if (fmt != NULL) {
va_list ap;
va_start(ap, fmt);
vwarnx(fmt, ap);
va_end(ap);
}
(void) fprintf(stderr, "Usage: i2cadm device list [-H] "
"[-o field[,...] [-p]] [filter...]\n\n");
(void) fprintf(stderr, "List I2C devices in the system. Each <filter> "
"selects devices based upon its\naddress, the device's name, the "
"driver's name, the driver's instance, or the\nI2C path. Multiple "
"filters are treated as an OR. It is an error if a filter\nisn't "
"used.\n\n"
"\t-H\t\tomit the column header\n"
"\t-o field\toutput fields to print\n"
"\t-p\t\tparseable output (requires -o)\n");
(void) fprintf(stderr, "\nThe following fields are supported:\n"
"\tname\t\tthe name of the device\n"
"\taddr\t\tthe primary address of the device\n"
"\tinstance\tthe driver instance of the device\n"
"\tpath\t\tthe I2C path of the device\n");
}
typedef enum {
I2CADM_DEVICE_LIST_NAME,
I2CADM_DEVICE_LIST_ADDR,
I2CADM_DEVICE_LIST_INSTANCE,
I2CADM_DEVICE_LIST_PATH
} i2cadm_device_list_otype_t;
static boolean_t
i2cadm_device_list_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
const i2c_dev_info_t *info = ofarg->ofmt_cbarg;
size_t len;
const i2c_addr_t *addr;
switch (ofarg->ofmt_id) {
case I2CADM_DEVICE_LIST_NAME:
len = strlcpy(buf, i2c_device_info_name(info), buflen);
break;
case I2CADM_DEVICE_LIST_ADDR:
addr = i2c_device_info_addr_primary(info);
if (!i2c_addr_to_string(i2cadm.i2c_hdl, addr, buf, buflen)) {
return (B_FALSE);
}
return (B_TRUE);
case I2CADM_DEVICE_LIST_INSTANCE:
if (i2c_device_info_driver(info) != NULL &&
i2c_device_info_instance(info) != -1) {
len = snprintf(buf, buflen, "%s%d",
i2c_device_info_driver(info),
i2c_device_info_instance(info));
} else {
len = strlcpy(buf, "--", buflen);
}
break;
case I2CADM_DEVICE_LIST_PATH:
len = strlcpy(buf, i2c_device_info_path(info), buflen);
break;
default:
return (B_FALSE);
}
return (len < buflen);
}
static const char *i2cadm_device_list_fields = "name,addr,instance,path";
static const ofmt_field_t i2cadm_device_list_ofmt[] = {
{ "NAME", 12, I2CADM_DEVICE_LIST_NAME, i2cadm_device_list_ofmt_cb },
{ "ADDR", 12, I2CADM_DEVICE_LIST_ADDR, i2cadm_device_list_ofmt_cb },
{ "INSTANCE", 16, I2CADM_DEVICE_LIST_INSTANCE,
i2cadm_device_list_ofmt_cb },
{ "PATH", 40, I2CADM_DEVICE_LIST_PATH, i2cadm_device_list_ofmt_cb },
{ NULL, 0, 0, NULL }
};
static void
i2cadm_device_list_cb(ofmt_handle_t ofmt, const i2c_dev_info_t *info)
{
ofmt_print(ofmt, (void *)info);
}
static int
i2cadm_device_list(int argc, char *argv[])
{
int c;
uint_t flags = 0;
boolean_t parse = B_FALSE;
const char *fields = NULL;
bool *filts = NULL;
ofmt_status_t oferr;
ofmt_handle_t ofmt;
while ((c = getopt(argc, argv, ":Ho:p")) != -1) {
switch (c) {
case 'H':
flags |= OFMT_NOHEADER;
break;
case 'o':
fields = optarg;
break;
case 'p':
parse = B_TRUE;
flags |= OFMT_PARSABLE;
break;
case ':':
i2cadm_device_list_help("option -%c requires an "
"argument", optopt);
exit(EXIT_USAGE);
case '?':
i2cadm_device_list_help("unknown option: -%c",
optopt);
exit(EXIT_USAGE);
}
}
if (parse && fields == NULL) {
errx(EXIT_USAGE, "-p requires fields specified with -o");
}
if (!parse) {
flags |= OFMT_WRAP;
}
if (fields == NULL) {
fields = i2cadm_device_list_fields;
}
argc -= optind;
argv += optind;
if (argc > 0) {
filts = calloc(argc, sizeof (bool));
if (filts == NULL) {
err(EXIT_FAILURE, "failed to allocate memory for "
"filter tracking");
}
}
oferr = ofmt_open(fields, i2cadm_device_list_ofmt, flags, 0, &ofmt);
ofmt_check(oferr, parse, ofmt, i2cadm_ofmt_errx, warnx);
return (i2cadm_device_iter(ofmt, argc, argv, filts,
i2cadm_device_list_cb));
}
static void
i2cadm_device_add_usage(FILE *f)
{
(void) fprintf(f, "\ti2cadm device add [-c compat] port name addr\n");
}
static void
i2cadm_device_add_help(const char *fmt, ...)
{
if (fmt != NULL) {
va_list ap;
va_start(ap, fmt);
vwarnx(fmt, ap);
va_end(ap);
}
(void) fprintf(stderr, "Usage: i2cadm device add [-c comapt] "
"port name addr\n\n");
(void) fprintf(stderr, "Inform the system of a new I2C device with the "
"specified address. The device\nwill be inserted under the given "
"bus (or multiplexer port if specified). The\naddress must be "
"unique on its multiplexor (if applicable) and bus.\n\n"
"\t-c compat\tAdd the driver compatible entry to the device. This "
"may\n\t\t\tbe specified multiple times. They will be added to "
"the\n\t\t\tdevice in the order specified.\n");
}
static int
i2cadm_device_add(int argc, char *argv[])
{
int c;
char **compat = NULL;
size_t ncompat = 0, nalloc = 0;
i2c_port_t *port;
i2c_addr_t addr;
i2c_dev_add_req_t *req;
while ((c = getopt(argc, argv, ":c")) != -1) {
switch (c) {
case 'c':
if (ncompat == nalloc) {
nalloc += 8;
compat = recallocarray(compat, ncompat, nalloc,
sizeof (char *));
if (compat == NULL) {
err(EXIT_FAILURE, "failed to allocate "
"memory for %zu compatible array "
"entries", nalloc);
}
}
compat[ncompat] = optarg;
ncompat++;
break;
case ':':
i2cadm_device_add_help("option -%c requires an "
"argument", optopt);
exit(EXIT_USAGE);
case '?':
i2cadm_device_add_help("unknown option: -%c", optopt);
exit(EXIT_USAGE);
}
}
argv += optind;
argc -= optind;
if (argc > 3) {
errx(EXIT_USAGE, "encountered extraneous arguments starting "
"with %s", argv[3]);
} else if (argc == 0) {
errx(EXIT_FAILURE, "missing required port path, device name, "
"and device address");
} else if (argc == 1) {
errx(EXIT_FAILURE, "missing required device name and device "
"address");
} else if (argc == 2) {
errx(EXIT_FAILURE, "missing required device address");
}
if (!i2c_port_init_by_path(i2cadm.i2c_hdl, argv[0], &port)) {
i2cadm_fatal("failed to parse port path %s", argv[0]);
}
if (!i2c_addr_parse(i2cadm.i2c_hdl, argv[2], &addr)) {
i2cadm_fatal("failed to parse address %s", argv[2]);
}
if (!i2c_device_add_req_init(port, &req)) {
i2cadm_fatal("failed to initialize device add request");
}
if (!i2c_device_add_req_set_addr(req, &addr)) {
i2cadm_fatal("failed to set device address");
}
if (!i2c_device_add_req_set_name(req, argv[1])) {
i2cadm_fatal("failed to set device name");
}
if (ncompat > 0 && !i2c_device_add_req_set_compatible(req, compat,
ncompat)) {
i2cadm_fatal("failed to set device compatible[]");
}
if (!i2c_device_add_req_exec(req)) {
i2cadm_fatal("failed to add device");
}
i2c_device_add_req_fini(req);
i2c_port_fini(port);
free(compat);
return (EXIT_SUCCESS);
}
static void
i2cadm_device_remove_usage(FILE *f)
{
(void) fprintf(f, "\ti2cadm device remove <path>\n");
}
static void
i2cadm_device_remove_help(const char *fmt, ...)
{
if (fmt != NULL) {
va_list ap;
va_start(ap, fmt);
vwarnx(fmt, ap);
va_end(ap);
}
(void) fprintf(stderr, "Usage: i2cadm device remove <path>\n\n");
(void) fprintf(stderr, "Remove the I2C device identified by the "
"specified path. If the device is in use,\nthis may "
"fail.\n");
}
static int
i2cadm_device_remove(int argc, char *argv[])
{
int c;
i2c_port_t *port;
i2c_dev_info_t *info;
while ((c = getopt(argc, argv, "")) != -1) {
switch (c) {
case ':':
i2cadm_device_remove_help("option -%c requires an "
"argument", optopt);
exit(EXIT_USAGE);
case '?':
i2cadm_device_remove_help("unknown option: -%c",
optopt);
exit(EXIT_USAGE);
}
}
argv += optind;
argc -= optind;
if (argc > 1) {
errx(EXIT_USAGE, "encountered extraneous arguments starting "
"with %s", argv[1]);
} else if (argc == 0) {
errx(EXIT_FAILURE, "missing required device path");
}
if (!i2c_port_dev_init_by_path(i2cadm.i2c_hdl, argv[0], false, &port,
&info)) {
i2cadm_fatal("failed to parse device path %s", argv[0]);
}
if (!i2c_device_rem(port, i2c_device_info_addr_primary(info))) {
i2cadm_fatal("failed to remove device %s", argv[0]);
}
i2c_device_info_free(info);
i2c_port_fini(port);
return (EXIT_SUCCESS);
}
static i2cadm_cmdtab_t i2cadm_device_cmds[] = {
{ "list", i2cadm_device_list, i2cadm_device_list_usage },
{ "addrs", i2cadm_device_addrs, i2cadm_device_addrs_usage },
{ "add", i2cadm_device_add, i2cadm_device_add_usage },
{ "remove", i2cadm_device_remove, i2cadm_device_remove_usage }
};
int
i2cadm_device(int argc, char *argv[])
{
return (i2cadm_walk_tab(i2cadm_device_cmds,
ARRAY_SIZE(i2cadm_device_cmds), argc, argv));
}
void
i2cadm_device_usage(FILE *f)
{
i2cadm_walk_usage(i2cadm_device_cmds, ARRAY_SIZE(i2cadm_device_cmds),
f);
}
