static void read_index_list_complete(int sk, void *buf, size_t len)
{
struct mgmt_rp_read_index_list *rp = buf;
uint16_t num;
int i;
if (len < sizeof(*rp)) {
error("Too small read index list complete event");
return;
}
num = btohs(bt_get_unaligned(&rp->num_controllers));
if (num * sizeof(uint16_t) + sizeof(*rp) != len) {
error("Incorrect packet size for index list event");
return;
}
for (i = 0; i < num; i++) {
uint16_t index;
index = btohs(bt_get_unaligned(&rp->index[i]));
add_controller(index);
get_connections(sk, index);
clear_uuids(index);
}
}
int main(int argc, char* argv[]) {
init();
if (argc > 1) load_mappings(argv[1]);
printf("Listening for gamepads...\n");
while (1) {
SDL_WaitEvent(NULL);
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
quit();
}
else if (event.type == SDL_CONTROLLERDEVICEADDED) {
printf("Gamepad connected (index: %d)\n", event.cdevice.which);
add_controller(event.cdevice.which);
}
else if (event.type == SDL_CONTROLLERDEVICEREMOVED) {
printf("Gamepad disconnected (instance id: %d)\n",
event.cdevice.which);
// Close the controller and free its slot in our array (if it
// is currently in our array)
remove_controller(event.cdevice.which);
}
else if (event.type == SDL_CONTROLLERBUTTONDOWN) {
process_button(event.cbutton.which, event.cbutton.button);
}
}
}
return 0;
}
static void mgmt_index_added(int sk, void *buf, size_t len)
{
struct mgmt_ev_index_added *ev = buf;
uint16_t index;
if (len < sizeof(*ev)) {
error("Too small index added event");
return;
}
index = btohs(bt_get_unaligned(&ev->index));
add_controller(index);
read_info(sk, index);
}
static void mgmt_index_added(int sk, uint16_t index)
{
add_controller(index);
read_info(sk, index);
}
static int
add_disk2controller(disk_t *diskp, struct search_args *args)
{
di_node_t pnode;
controller_t *cp;
di_minor_t minor;
di_node_t node;
int i;
node = args->node;
pnode = di_parent_node(node);
if (pnode == DI_NODE_NIL) {
return (0);
}
minor = di_minor_next(pnode, NULL);
if (minor == NULL) {
return (0);
}
if ((cp = add_controller(args, pnode, minor)) == NULL) {
return (ENOMEM);
}
/* check if the disk <-> ctrl assoc is already there */
for (i = 0; diskp->controllers[i]; i++) {
if (cp == diskp->controllers[i]) {
return (0);
}
}
/* this is a new controller for this disk */
/* add the disk to the controller */
if (add_ptr2array(diskp, (void ***)&cp->disks) != 0) {
return (ENOMEM);
}
/* add the controller to the disk */
if (add_ptr2array(cp, (void ***)&diskp->controllers) != 0) {
return (ENOMEM);
}
/*
* Set up paths for mpxio controlled drives.
*/
if (libdiskmgt_str_eq(di_node_name(pnode), "scsi_vhci")) {
/* note: mpxio di_path stuff is all consolidation private */
di_path_t pi = DI_PATH_NIL;
while (
(pi = di_path_client_next_path(node, pi)) != DI_PATH_NIL) {
int cnt;
uchar_t *bytes;
char str[MAXPATHLEN];
char *wwn;
di_node_t phci_node = di_path_phci_node(pi);
/* get the node wwn */
cnt = di_path_prop_lookup_bytes(pi, WWN_PROP, &bytes);
wwn = NULL;
if (cnt > 0) {
int i;
str[0] = 0;
for (i = 0; i < cnt; i++) {
/*
* A byte is only 2 hex chars + null.
*/
char bstr[8];
(void) snprintf(bstr,
sizeof (bstr), "%.2x", bytes[i]);
(void) strlcat(str, bstr, sizeof (str));
}
wwn = str;
}
if (new_path(cp, diskp, phci_node,
di_path_state(pi), wwn) == NULL) {
return (ENOMEM);
}
}
}
return (0);
}
static int
add_devs(di_node_t node, di_minor_t minor, void *arg)
{
struct search_args *args;
int result = DI_WALK_CONTINUE;
args = (struct search_args *)arg;
if (dm_debug > 1) {
/* This is all just debugging code */
char *devpath;
char dev_name[MAXPATHLEN];
devpath = di_devfs_path(node);
(void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
di_minor_name(minor));
di_devfs_path_free((void *) devpath);
(void) fprintf(stderr,
"INFO: dev: %s, node: %s%d, minor: 0x%x, type: %s\n",
dev_name, di_node_name(node), di_instance(node),
di_minor_spectype(minor),
(di_minor_nodetype(minor) != NULL ?
di_minor_nodetype(minor) : "NULL"));
}
if (bus_type(node, minor, args->ph) != NULL) {
if (add_bus(args, node, minor, NULL) == NULL) {
args->dev_walk_status = ENOMEM;
result = DI_WALK_TERMINATE;
}
} else if (is_ctrl(node, minor)) {
if (add_controller(args, node, minor) == NULL) {
args->dev_walk_status = ENOMEM;
result = DI_WALK_TERMINATE;
}
} else if (di_minor_spectype(minor) == S_IFCHR &&
(is_drive(minor) || is_zvol(node, minor))) {
char *devidstr;
char kernel_name[MAXPATHLEN];
disk_t *diskp;
(void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
di_node_name(node), di_instance(node));
devidstr = get_str_prop(DEVICE_ID_PROP, node);
args->node = node;
args->minor = minor;
/*
* Check if we already got this disk and
* this is another slice.
*/
if (!have_disk(args, devidstr, kernel_name, &diskp)) {
args->dev_walk_status = 0;
/*
* This is a newly found disk, create the
* disk structure.
*/
diskp = create_disk(devidstr, kernel_name, args);
if (diskp == NULL) {
args->dev_walk_status = ENOMEM;
}
if (diskp->drv_type != DM_DT_FLOPPY) {
/* add the controller relationship */
if (args->dev_walk_status == 0) {
if (add_disk2controller(diskp,
args) != 0) {
args->dev_walk_status = ENOMEM;
}
}
}
}
if (is_zvol(node, minor)) {
char zvdsk[MAXNAMELEN];
char *str;
alias_t *ap;
if (di_prop_lookup_strings(di_minor_devt(minor),
node, "name", &str) == -1)
return (DI_WALK_CONTINUE);
(void) snprintf(zvdsk, MAXNAMELEN, "/dev/zvol/rdsk/%s",
str);
if ((ap = find_alias(diskp, kernel_name)) == NULL) {
if (new_alias(diskp, kernel_name,
zvdsk, args) != 0) {
args->dev_walk_status = ENOMEM;
}
} else {
/*
* It is possible that we have already added
* this devpath.
* Do not add it again. new_devpath will
* return a 0 if found, and not add the path.
*/
if (new_devpath(ap, zvdsk) != 0) {
args->dev_walk_status = ENOMEM;
}
}
}
/* Add the devpaths for the drive. */
if (args->dev_walk_status == 0) {
char *devpath;
char slice_path[MAXPATHLEN];
char *pattern;
/*
* We will come through here once for each of
* the raw slice device names.
*/
devpath = di_devfs_path(node);
(void) snprintf(slice_path,
sizeof (slice_path), "%s:%s",
devpath, di_minor_name(minor));
di_devfs_path_free((void *) devpath);
if (libdiskmgt_str_eq(di_minor_nodetype(minor),
DDI_NT_FD)) {
pattern = DEVLINK_FLOPPY_REGEX;
} else {
pattern = DEVLINK_REGEX;
}
/* Walk the /dev tree to get the devlinks. */
(void) di_devlink_walk(args->handle, pattern,
slice_path, DI_PRIMARY_LINK, arg, add_devpath);
}
if (args->dev_walk_status != 0) {
result = DI_WALK_TERMINATE;
}
}
return (result);
}
