static int amdm37x_dispc_dev_add(ddf_dev_t *dev) { assert(dev); /* Visualizer part */ ddf_fun_t *fun = ddf_fun_create(dev, fun_exposed, "viz"); if (!fun) { ddf_log_error("Failed to create visualizer function\n"); return ENOMEM; } visualizer_t *vis = ddf_fun_data_alloc(fun, sizeof(visualizer_t)); if (!vis) { ddf_log_error("Failed to allocate visualizer structure\n"); ddf_fun_destroy(fun); return ENOMEM; } graph_init_visualizer(vis); vis->reg_svc_handle = ddf_fun_get_handle(fun); ddf_fun_set_ops(fun, &graph_fun_ops); /* Hw part */ amdm37x_dispc_t *dispc = ddf_dev_data_alloc(dev, sizeof(amdm37x_dispc_t)); if (!dispc) { ddf_log_error("Failed to allocate dispc structure\n"); ddf_fun_destroy(fun); return ENOMEM; } int ret = amdm37x_dispc_init(dispc, vis); if (ret != EOK) { ddf_log_error("Failed to init dispc: %s\n", str_error(ret)); ddf_fun_destroy(fun); return ret; } /* Report to devman */ ret = ddf_fun_bind(fun); if (ret != EOK) { ddf_log_error("Failed to bind function: %s\n", str_error(ret)); amdm37x_dispc_fini(dispc); ddf_fun_destroy(fun); return ret; } ddf_fun_add_to_category(fun, "visualizer"); ddf_log_note("Added device `%s'\n", ddf_dev_get_name(dev)); return EOK; }
static bool mac_add_fun(ddf_dev_t *dev, const char *name, const char *str_match_id, mac_fun_t *fun_proto) { ddf_msg(LVL_DEBUG, "Adding new function '%s'.", name); ddf_fun_t *fnode = NULL; int rc; /* Create new device. */ fnode = ddf_fun_create(dev, fun_inner, name); if (fnode == NULL) goto failure; mac_fun_t *fun = ddf_fun_data_alloc(fnode, sizeof(mac_fun_t)); *fun = *fun_proto; /* Add match ID */ rc = ddf_fun_add_match_id(fnode, str_match_id, 100); if (rc != EOK) goto failure; /* Set provided operations to the device. */ ddf_fun_set_ops(fnode, &mac_fun_ops); /* Register function. */ if (ddf_fun_bind(fnode) != EOK) { ddf_msg(LVL_ERROR, "Failed binding function %s.", name); goto failure; } return true; failure: if (fnode != NULL) ddf_fun_destroy(fnode); ddf_msg(LVL_ERROR, "Failed adding function '%s'.", name); return false; }
static int rootamdm37x_add_fun(ddf_dev_t *dev, const char *name, const char *str_match_id, const rootamdm37x_fun_t *fun) { ddf_msg(LVL_DEBUG, "Adding new function '%s'.", name); /* Create new device function. */ ddf_fun_t *fnode = ddf_fun_create(dev, fun_inner, name); if (fnode == NULL) return ENOMEM; /* Add match id */ int ret = ddf_fun_add_match_id(fnode, str_match_id, 100); if (ret != EOK) { ddf_fun_destroy(fnode); return ret; } /* Alloc needed data */ rootamdm37x_fun_t *rf = ddf_fun_data_alloc(fnode, sizeof(rootamdm37x_fun_t)); if (!rf) { ddf_fun_destroy(fnode); return ENOMEM; } *rf = *fun; /* Set provided operations to the device. */ ddf_fun_set_ops(fnode, &rootamdm37x_fun_ops); /* Register function. */ ret = ddf_fun_bind(fnode); if (ret != EOK) { ddf_msg(LVL_ERROR, "Failed binding function %s.", name); ddf_fun_destroy(fnode); return ret; } return EOK; }
/** * Processes key events. * * @note This function was copied from AT keyboard driver and modified to suit * USB keyboard. * * @note Lock keys are not sent to the console, as they are completely handled * in the driver. It may, however, be required later that the driver * sends also these keys to application (otherwise it cannot use those * keys at all). * * @param hid_dev * @param multim_dev * @param type Type of the event (press / release). Recognized values: * KEY_PRESS, KEY_RELEASE * @param key Key code of the key according to HID Usage Tables. */ static void usb_multimedia_push_ev( usb_multimedia_t *multim_dev, int type, unsigned int key) { assert(multim_dev != NULL); const kbd_event_t ev = { .type = type, .key = key, .mods = 0, .c = 0, }; usb_log_debug2(NAME " Sending key %d to the console\n", ev.key); if (multim_dev->console_sess == NULL) { usb_log_warning( "Connection to console not ready, key discarded.\n"); return; } async_exch_t *exch = async_exchange_begin(multim_dev->console_sess); if (exch != NULL) { async_msg_4(exch, KBDEV_EVENT, ev.type, ev.key, ev.mods, ev.c); async_exchange_end(exch); } else { usb_log_warning("Failed to send multimedia key.\n"); } } int usb_multimedia_init(struct usb_hid_dev *hid_dev, void **data) { if (hid_dev == NULL || hid_dev->usb_dev == NULL) { return EINVAL; } usb_log_debug(NAME " Initializing HID/multimedia structure...\n"); /* Create the exposed function. */ ddf_fun_t *fun = ddf_fun_create( hid_dev->usb_dev->ddf_dev, fun_exposed, NAME); if (fun == NULL) { usb_log_error("Could not create DDF function node.\n"); return ENOMEM; } ddf_fun_set_ops(fun, &multimedia_ops); usb_multimedia_t *multim_dev = ddf_fun_data_alloc(fun, sizeof(usb_multimedia_t)); if (multim_dev == NULL) { ddf_fun_destroy(fun); return ENOMEM; } multim_dev->console_sess = NULL; //todo Autorepeat? int rc = ddf_fun_bind(fun); if (rc != EOK) { usb_log_error("Could not bind DDF function: %s.\n", str_error(rc)); ddf_fun_destroy(fun); return rc; } usb_log_debug(NAME " function created (handle: %" PRIun ").\n", ddf_fun_get_handle(fun)); rc = ddf_fun_add_to_category(fun, "keyboard"); if (rc != EOK) { usb_log_error( "Could not add DDF function to category 'keyboard': %s.\n", str_error(rc)); if (ddf_fun_unbind(fun) != EOK) { usb_log_error("Failed to unbind %s, won't destroy.\n", ddf_fun_get_name(fun)); } else { ddf_fun_destroy(fun); } return rc; } /* Save the KBD device structure into the HID device structure. */ *data = fun; usb_log_debug(NAME " HID/multimedia structure initialized.\n"); return EOK; } void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data) { ddf_fun_t *fun = data; usb_multimedia_t *multim_dev = ddf_fun_data_get(fun); /* Hangup session to the console */ if (multim_dev->console_sess) async_hangup(multim_dev->console_sess); if (ddf_fun_unbind(fun) != EOK) { usb_log_error("Failed to unbind %s, won't destroy.\n", ddf_fun_get_name(fun)); } else { usb_log_debug2("%s unbound.\n", ddf_fun_get_name(fun)); /* This frees multim_dev too as it was stored in * fun->data */ ddf_fun_destroy(fun); } }