/** Initialize keyboard driver structure.
*
* @param kbd Keyboard driver structure to initialize.
* @param dev DDF device structure.
*
* Connects to parent, creates keyboard function, starts polling fibril.
*
*/
int at_kbd_init(at_kbd_t *kbd, ddf_dev_t *dev)
{
assert(kbd);
assert(dev);
kbd->client_sess = NULL;
kbd->parent_sess = ddf_dev_parent_sess_create(dev);
if (!kbd->parent_sess) {
ddf_msg(LVL_ERROR, "Failed creating parent session.");
return EIO;
}
kbd->kbd_fun = ddf_fun_create(dev, fun_exposed, "kbd");
if (!kbd->kbd_fun) {
ddf_msg(LVL_ERROR, "Failed creating function 'kbd'.");
return ENOMEM;
}
ddf_fun_set_ops(kbd->kbd_fun, &kbd_ops);
int ret = ddf_fun_bind(kbd->kbd_fun);
if (ret != EOK) {
ddf_msg(LVL_ERROR, "Failed binding function 'kbd'.");
ddf_fun_destroy(kbd->kbd_fun);
return EEXIST;
}
ret = ddf_fun_add_to_category(kbd->kbd_fun, "keyboard");
if (ret != EOK) {
ddf_msg(LVL_ERROR, "Failed adding function 'kbd' to category "
"'keyboard'.");
ddf_fun_unbind(kbd->kbd_fun);
ddf_fun_destroy(kbd->kbd_fun);
return ENOMEM;
}
kbd->polling_fibril = fibril_create(polling, kbd);
if (!kbd->polling_fibril) {
ddf_msg(LVL_ERROR, "Failed creating polling fibril.");
ddf_fun_unbind(kbd->kbd_fun);
ddf_fun_destroy(kbd->kbd_fun);
return ENOMEM;
}
fibril_add_ready(kbd->polling_fibril);
return EOK;
}
/** Simulate plugging and surprise unplugging.
*
* @param arg Parent device structure (ddf_dev_t *).
* @return Always EOK.
*/
static int plug_unplug(void *arg)
{
test2_t *test2 = (test2_t *) arg;
ddf_fun_t *fun_a;
int rc;
async_usleep(1000);
(void) register_fun_verbose(test2->dev, "child driven by the same task",
"child", "virtual&test2", 10, &test2->child);
(void) register_fun_verbose(test2->dev, "child driven by test1",
"test1", "virtual&test1", 10, &test2->test1);
fun_a = ddf_fun_create(test2->dev, fun_exposed, "a");
if (fun_a == NULL) {
ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
return ENOMEM;
}
rc = ddf_fun_bind(fun_a);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
return rc;
}
ddf_fun_add_to_category(fun_a, "virtual");
test2->fun_a = fun_a;
async_usleep(10000000);
ddf_msg(LVL_NOTE, "Unbinding function test1.");
ddf_fun_unbind(test2->test1);
async_usleep(1000000);
ddf_msg(LVL_NOTE, "Unbinding function child.");
ddf_fun_unbind(test2->child);
return EOK;
}
static int fun_unbind(ddf_fun_t *fun, const char *name)
{
int rc;
ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
rc = ddf_fun_unbind(fun);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
return rc;
}
ddf_fun_destroy(fun);
return EOK;
}
/** Initialize keyboard driver structure.
* @param kbd Keyboard driver structure to initialize.
* @param dev DDF device structure.
*
* Connects to parent, creates mouse function, starts polling fibril.
*/
int xt_kbd_init(xt_kbd_t *kbd, ddf_dev_t *dev)
{
assert(kbd);
assert(dev);
kbd->client_sess = NULL;
kbd->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
if (!kbd->parent_sess)
return ENOMEM;
kbd->kbd_fun = ddf_fun_create(dev, fun_exposed, "kbd");
if (!kbd->kbd_fun) {
return ENOMEM;
}
ddf_fun_set_ops(kbd->kbd_fun, &kbd_ops);
int ret = ddf_fun_bind(kbd->kbd_fun);
if (ret != EOK) {
ddf_fun_destroy(kbd->kbd_fun);
return ENOMEM;
}
ret = ddf_fun_add_to_category(kbd->kbd_fun, "keyboard");
if (ret != EOK) {
ddf_fun_unbind(kbd->kbd_fun);
ddf_fun_destroy(kbd->kbd_fun);
return ENOMEM;
}
kbd->polling_fibril = fibril_create(polling, kbd);
if (!kbd->polling_fibril) {
ddf_fun_unbind(kbd->kbd_fun);
ddf_fun_destroy(kbd->kbd_fun);
return ENOMEM;
}
fibril_add_ready(kbd->polling_fibril);
return EOK;
}
void usb_generic_hid_deinit(usb_hid_dev_t *hid_dev, void *data)
{
ddf_fun_t *fun = data;
if (fun == NULL)
return;
if (ddf_fun_unbind(fun) != EOK) {
usb_log_error("Failed to unbind generic hid fun.\n");
return;
}
usb_log_debug2("%s unbound.\n", fun->name);
/* We did not allocate this, so leave this alone
* the device would take care of it */
fun->driver_data = NULL;
ddf_fun_destroy(fun);
}
/**
* Remove all attached devices
* @param usb_dev generic usb device information
* @return error code
*/
int usb_hub_device_gone(usb_device_t *usb_dev)
{
assert(usb_dev);
usb_hub_dev_t *hub = usb_dev->driver_data;
assert(hub);
unsigned tries = 10;
while (hub->running) {
async_usleep(100000);
if (!tries--) {
usb_log_error("Can't remove hub, still running.\n");
return EINPROGRESS;
}
}
assert(!hub->running);
for (size_t port = 0; port < hub->port_count; ++port) {
if (hub->ports[port].attached_device.fun) {
const int ret =
usb_hub_port_fini(&hub->ports[port], hub);
if (ret != EOK)
return ret;
}
}
free(hub->ports);
const int ret = ddf_fun_unbind(hub->hub_fun);
if (ret != EOK) {
usb_log_error("Failed to unbind '%s' function: %s.\n",
HUB_FNC_NAME, str_error(ret));
return ret;
}
ddf_fun_destroy(hub->hub_fun);
usb_log_info("USB hub driver, stopped and cleaned.\n");
return EOK;
}
/**
* Initialize hub device driver structure.
*
* Creates hub representation and fibril that periodically checks hub's status.
* Hub representation is passed to the fibril.
* @param usb_dev generic usb device information
* @return error code
*/
int usb_hub_device_add(usb_device_t *usb_dev)
{
assert(usb_dev);
/* Create driver soft-state structure */
usb_hub_dev_t *hub_dev =
usb_device_data_alloc(usb_dev, sizeof(usb_hub_dev_t));
if (hub_dev == NULL) {
usb_log_error("Failed to create hub driver structure.\n");
return ENOMEM;
}
hub_dev->usb_device = usb_dev;
hub_dev->pending_ops_count = 0;
hub_dev->running = false;
fibril_mutex_initialize(&hub_dev->pending_ops_mutex);
fibril_condvar_initialize(&hub_dev->pending_ops_cv);
int opResult = usb_pipe_start_long_transfer(&usb_dev->ctrl_pipe);
if (opResult != EOK) {
usb_log_error("Failed to start long ctrl pipe transfer: %s\n",
str_error(opResult));
return opResult;
}
/* Set hub's first configuration. (There should be only one) */
opResult = usb_set_first_configuration(usb_dev);
if (opResult != EOK) {
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
usb_log_error("Could not set hub configuration: %s\n",
str_error(opResult));
return opResult;
}
/* Get port count and create attached_devices. */
opResult = usb_hub_process_hub_specific_info(hub_dev);
if (opResult != EOK) {
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
usb_log_error("Could process hub specific info, %s\n",
str_error(opResult));
return opResult;
}
/* Create hub control function. */
usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.\n");
hub_dev->hub_fun = ddf_fun_create(hub_dev->usb_device->ddf_dev,
fun_exposed, HUB_FNC_NAME);
if (hub_dev->hub_fun == NULL) {
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
usb_log_error("Failed to create hub function.\n");
return ENOMEM;
}
/* Bind hub control function. */
opResult = ddf_fun_bind(hub_dev->hub_fun);
if (opResult != EOK) {
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
usb_log_error("Failed to bind hub function: %s.\n",
str_error(opResult));
ddf_fun_destroy(hub_dev->hub_fun);
return opResult;
}
/* Start hub operation. */
opResult = usb_device_auto_poll(hub_dev->usb_device, 0,
hub_port_changes_callback, ((hub_dev->port_count + 1 + 8) / 8),
usb_hub_polling_terminated_callback, hub_dev);
if (opResult != EOK) {
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
/* Function is already bound */
ddf_fun_unbind(hub_dev->hub_fun);
ddf_fun_destroy(hub_dev->hub_fun);
usb_log_error("Failed to create polling fibril: %s.\n",
str_error(opResult));
return opResult;
}
hub_dev->running = true;
usb_log_info("Controlling hub '%s' (%zu ports).\n",
hub_dev->usb_device->ddf_dev->name, hub_dev->port_count);
usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
return EOK;
}
static int ne2k_dev_add(ddf_dev_t *dev)
{
ddf_fun_t *fun;
/* Allocate driver data for the device. */
nic_t *nic_data = nic_create_and_bind(dev);
if (nic_data == NULL)
return ENOMEM;
nic_set_send_frame_handler(nic_data, ne2k_send);
nic_set_state_change_handlers(nic_data,
ne2k_on_activating, NULL, ne2k_on_stopping);
nic_set_filtering_change_handlers(nic_data,
ne2k_on_unicast_mode_change, ne2k_on_multicast_mode_change,
ne2k_on_broadcast_mode_change, NULL, NULL);
ne2k_t *ne2k = malloc(sizeof(ne2k_t));
if (NULL != ne2k) {
memset(ne2k, 0, sizeof(ne2k_t));
nic_set_specific(nic_data, ne2k);
} else {
nic_unbind_and_destroy(dev);
return ENOMEM;
}
int rc = ne2k_dev_init(nic_data);
if (rc != EOK) {
ne2k_dev_cleanup(dev);
return rc;
}
rc = nic_report_address(nic_data, &ne2k->mac);
if (rc != EOK) {
ne2k_dev_cleanup(dev);
return rc;
}
rc = nic_connect_to_services(nic_data);
if (rc != EOK) {
ne2k_dev_cleanup(dev);
return rc;
}
fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
if (fun == NULL) {
ne2k_dev_cleanup(dev);
return ENOMEM;
}
nic_set_ddf_fun(nic_data, fun);
ddf_fun_set_ops(fun, &ne2k_dev_ops);
ddf_fun_data_implant(fun, nic_data);
rc = ddf_fun_bind(fun);
if (rc != EOK) {
ddf_fun_destroy(fun);
ne2k_dev_cleanup(dev);
return rc;
}
rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
if (rc != EOK) {
ddf_fun_unbind(fun);
ddf_fun_destroy(fun);
return rc;
}
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);
}
}
/** Initialize i8042 driver structure.
*
* @param dev Driver structure to initialize.
* @param regs I/O address of registers.
* @param reg_size size of the reserved I/O address space.
* @param irq_kbd IRQ for primary port.
* @param irq_mouse IRQ for aux port.
* @param ddf_dev DDF device structure of the device.
*
* @return Error code.
*
*/
int i8042_init(i8042_t *dev, void *regs, size_t reg_size, int irq_kbd,
int irq_mouse, ddf_dev_t *ddf_dev)
{
const size_t range_count = sizeof(i8042_ranges) /
sizeof(irq_pio_range_t);
irq_pio_range_t ranges[range_count];
const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
irq_cmd_t cmds[cmd_count];
int rc;
bool kbd_bound = false;
bool aux_bound = false;
dev->kbd_fun = NULL;
dev->aux_fun = NULL;
if (reg_size < sizeof(i8042_regs_t)) {
rc = EINVAL;
goto error;
}
if (pio_enable(regs, sizeof(i8042_regs_t), (void **) &dev->regs) != 0) {
rc = EIO;
goto error;
}
dev->kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
if (dev->kbd_fun == NULL) {
rc = ENOMEM;
goto error;
};
rc = ddf_fun_add_match_id(dev->kbd_fun, "char/xtkbd", 90);
if (rc != EOK)
goto error;
dev->aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
if (dev->aux_fun == NULL) {
rc = ENOMEM;
goto error;
}
rc = ddf_fun_add_match_id(dev->aux_fun, "char/ps2mouse", 90);
if (rc != EOK)
goto error;
ddf_fun_set_ops(dev->kbd_fun, &ops);
ddf_fun_set_ops(dev->aux_fun, &ops);
buffer_init(&dev->kbd_buffer, dev->kbd_data, BUFFER_SIZE);
buffer_init(&dev->aux_buffer, dev->aux_data, BUFFER_SIZE);
fibril_mutex_initialize(&dev->write_guard);
rc = ddf_fun_bind(dev->kbd_fun);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed to bind keyboard function: %s.",
ddf_fun_get_name(dev->kbd_fun));
goto error;
}
kbd_bound = true;
rc = ddf_fun_bind(dev->aux_fun);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed to bind aux function: %s.",
ddf_fun_get_name(dev->aux_fun));
goto error;
}
aux_bound = true;
/* Disable kbd and aux */
wait_ready(dev);
pio_write_8(&dev->regs->status, i8042_CMD_WRITE_CMDB);
wait_ready(dev);
pio_write_8(&dev->regs->data, i8042_KBD_DISABLE | i8042_AUX_DISABLE);
/* Flush all current IO */
while (pio_read_8(&dev->regs->status) & i8042_OUTPUT_FULL)
(void) pio_read_8(&dev->regs->data);
memcpy(ranges, i8042_ranges, sizeof(i8042_ranges));
ranges[0].base = (uintptr_t) regs;
memcpy(cmds, i8042_cmds, sizeof(i8042_cmds));
cmds[0].addr = (void *) &(((i8042_regs_t *) regs)->status);
cmds[3].addr = (void *) &(((i8042_regs_t *) regs)->data);
irq_code_t irq_code = {
.rangecount = range_count,
.ranges = ranges,
.cmdcount = cmd_count,
.cmds = cmds
};
rc = register_interrupt_handler(ddf_dev, irq_kbd, i8042_irq_handler,
&irq_code);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.",
ddf_dev_get_name(ddf_dev));
goto error;
}
rc = register_interrupt_handler(ddf_dev, irq_mouse, i8042_irq_handler,
&irq_code);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.",
ddf_dev_get_name(ddf_dev));
goto error;
}
/* Enable interrupts */
async_sess_t *parent_sess = ddf_dev_parent_sess_get(ddf_dev);
assert(parent_sess != NULL);
const bool enabled = hw_res_enable_interrupt(parent_sess);
if (!enabled) {
log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to enable interrupts: %s.",
ddf_dev_get_name(ddf_dev));
rc = EIO;
goto error;
}
/* Enable port interrupts. */
wait_ready(dev);
pio_write_8(&dev->regs->status, i8042_CMD_WRITE_CMDB);
wait_ready(dev);
pio_write_8(&dev->regs->data, i8042_KBD_IE | i8042_KBD_TRANSLATE |
i8042_AUX_IE);
return EOK;
error:
if (kbd_bound)
ddf_fun_unbind(dev->kbd_fun);
if (aux_bound)
ddf_fun_unbind(dev->aux_fun);
if (dev->kbd_fun != NULL)
ddf_fun_destroy(dev->kbd_fun);
if (dev->aux_fun != NULL)
ddf_fun_destroy(dev->aux_fun);
return rc;
}