static int test2_dev_add(ddf_dev_t *dev)
{
test2_t *test2;
ddf_msg(LVL_DEBUG, "test2_dev_add(name=\"%s\", handle=%d)",
dev->name, (int) dev->handle);
test2 = ddf_dev_data_alloc(dev, sizeof(test2_t));
if (test2 == NULL) {
ddf_msg(LVL_ERROR, "Failed allocating soft state.");
return ENOMEM;
}
test2->dev = dev;
if (str_cmp(dev->name, "child") != 0) {
fid_t postpone = fibril_create(plug_unplug, test2);
if (postpone == 0) {
ddf_msg(LVL_ERROR, "fibril_create() failed.");
return ENOMEM;
}
fibril_add_ready(postpone);
} else {
(void) register_fun_verbose(dev, "child without available driver",
"ERROR", "non-existent.match.id", 10, &test2->fun_err);
}
return EOK;
}
/** Initialize a new ddf driver instance of i8042 driver
*
* @param[in] device DDF instance of the device to initialize.
*
* @return Error code.
*
*/
static int i8042_dev_add(ddf_dev_t *device)
{
if (!device)
return EINVAL;
uintptr_t io_regs = 0;
size_t io_size = 0;
int kbd = 0;
int mouse = 0;
int ret = get_my_registers(device, &io_regs, &io_size, &kbd, &mouse);
CHECK_RET_RETURN(ret, "Failed to get registers: %s.",
str_error(ret));
ddf_msg(LVL_DEBUG, "I/O regs at %p (size %zuB), IRQ kbd %d, IRQ mouse %d.",
(void *) io_regs, io_size, kbd, mouse);
i8042_t *i8042 = ddf_dev_data_alloc(device, sizeof(i8042_t));
ret = (i8042 == NULL) ? ENOMEM : EOK;
CHECK_RET_RETURN(ret, "Failed to allocate i8042 driver instance.");
ret = i8042_init(i8042, (void *) io_regs, io_size, kbd, mouse, device);
CHECK_RET_RETURN(ret, "Failed to initialize i8042 driver: %s.",
str_error(ret));
ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
ddf_dev_get_name(device), ddf_dev_get_handle(device));
return EOK;
}
int usb_device_create_ddf(ddf_dev_t *ddf_dev,
const usb_endpoint_description_t **desc, const char **err)
{
assert(ddf_dev);
assert(err);
devman_handle_t h = 0;
int iface_no = -1;
async_sess_t *sess = devman_parent_device_connect(
ddf_dev_get_handle(ddf_dev), IPC_FLAG_BLOCKING);
if (sess == NULL)
return ENOMEM;
const int ret = usb_device_get_info(sess, &h, &iface_no);
async_hangup(sess);
if (ret != EOK)
return ret;
usb_device_t *usb_dev =
ddf_dev_data_alloc(ddf_dev, sizeof(usb_device_t));
if (usb_dev == NULL) {
*err = "DDF data alloc";
return ENOMEM;
}
return usb_device_init(usb_dev, ddf_dev, desc, err, h, iface_no);
}
static int test3_dev_add(ddf_dev_t *dev)
{
int rc = EOK;
test3_t *test3;
ddf_msg(LVL_DEBUG, "dev_add(name=\"%s\", handle=%d)",
dev->name, (int) dev->handle);
test3 = ddf_dev_data_alloc(dev, sizeof(test3_t));
if (test3 == NULL) {
ddf_msg(LVL_ERROR, "Failed allocating soft state.");
return ENOMEM;
}
size_t i;
for (i = 0; i < NUM_FUNCS; i++) {
rc = register_fun_and_add_to_category(dev,
"test3_", i, "test3", &test3->fun[i]);
if (rc != EOK) {
break;
}
}
return rc;
}
/** Callback when new device is passed to this driver.
* This function is the body of the test: it shall register new child
* (named `clone') that shall be driven by the same task. When the clone
* is added, it registers another child (named `child') that is also driven
* by this task. The conditions ensure that we do not recurse indefinitely.
* When successful, the device tree shall contain following fragment:
*
* /virtual/test1
* /virtual/test1/clone
* /virtual/test1/clone/child
*
* and devman shall not deadlock.
*
*
* @param dev New device.
* @return Error code reporting success of the operation.
*/
static int test1_dev_add(ddf_dev_t *dev)
{
ddf_fun_t *fun_a;
test1_t *test1;
int rc;
ddf_msg(LVL_DEBUG, "dev_add(name=\"%s\", handle=%d)",
dev->name, (int) dev->handle);
test1 = ddf_dev_data_alloc(dev, sizeof(test1_t));
if (test1 == NULL) {
ddf_msg(LVL_ERROR, "Failed allocating soft state.\n");
return ENOMEM;
}
fun_a = ddf_fun_create(dev, fun_exposed, "a");
if (fun_a == NULL) {
ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
return ENOMEM;
}
test1->fun_a = fun_a;
rc = ddf_fun_bind(fun_a);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
ddf_fun_destroy(fun_a);
return rc;
}
ddf_fun_add_to_category(fun_a, "virtual");
if (str_cmp(dev->name, "null") == 0) {
fun_a->ops = &char_device_ops;
ddf_fun_add_to_category(fun_a, "virt-null");
} else if (str_cmp(dev->name, "test1") == 0) {
(void) register_fun_verbose(dev,
"cloning myself ;-)", "clone",
"virtual&test1", 10, EOK, &test1->clone);
(void) register_fun_verbose(dev,
"cloning myself twice ;-)", "clone",
"virtual&test1", 10, EEXISTS, NULL);
} else if (str_cmp(dev->name, "clone") == 0) {
(void) register_fun_verbose(dev,
"run by the same task", "child",
"virtual&test1&child", 10, EOK, &test1->child);
}
ddf_msg(LVL_DEBUG, "Device `%s' accepted.", dev->name);
return EOK;
}
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;
}
/** Add the root device.
*
* @param dev Device which is root of the whole device tree
* (both of HW and pseudo devices).
*
* @return Zero on success, negative error number otherwise.
*
*/
static int rootamdm37x_dev_add(ddf_dev_t *dev)
{
assert(dev);
amdm37x_t *device = ddf_dev_data_alloc(dev, sizeof(amdm37x_t));
if (!device)
return ENOMEM;
int ret = amdm37x_init(device, DEBUG_CM);
if (ret != EOK) {
ddf_msg(LVL_FATAL, "Failed to setup hw access!.\n");
return ret;
}
/* Set dplls to ON and automatic */
amdm37x_setup_dpll_on_autoidle(device);
/* Enable function and interface clocks */
amdm37x_usb_clocks_set(device, true);
/* Init TLL */
ret = amdm37x_usb_tll_init(device);
if (ret != EOK) {
ddf_msg(LVL_FATAL, "Failed to init USB TLL!.\n");
amdm37x_usb_clocks_set(device, false);
return ret;
}
/* Register functions */
if (rootamdm37x_add_fun(dev, "ohci", "usb/host=ohci", &ohci) != EOK)
ddf_msg(LVL_ERROR, "Failed to add OHCI function for "
"BeagleBoard-xM platform.");
if (rootamdm37x_add_fun(dev, "ehci", "usb/host=ehci", &ehci) != EOK)
ddf_msg(LVL_ERROR, "Failed to add EHCI function for "
"BeagleBoard-xM platform.");
if (rootamdm37x_add_fun(dev, "dispc", "amdm37x&dispc", &ehci) != EOK)
ddf_msg(LVL_ERROR, "Failed to add dispc function for "
"BeagleBoard-xM platform.");
return EOK;
}
/** Allocate and initialize the driver data.
*
* @return Allocated structure or NULL.
*
*/
static nic_t *nic_create(ddf_dev_t *dev)
{
nic_t *nic_data = ddf_dev_data_alloc(dev, sizeof(nic_t));
if (nic_data == NULL)
return NULL;
/* Force zero to all uninitialized fields (e.g. added in future) */
if (nic_rxc_init(&nic_data->rx_control) != EOK) {
return NULL;
}
if (nic_wol_virtues_init(&nic_data->wol_virtues) != EOK) {
return NULL;
}
nic_data->dev = NULL;
nic_data->fun = NULL;
nic_data->state = NIC_STATE_STOPPED;
nic_data->client_session = NULL;
nic_data->irc_session = NULL;
nic_data->poll_mode = NIC_POLL_IMMEDIATE;
nic_data->default_poll_mode = NIC_POLL_IMMEDIATE;
nic_data->send_frame = NULL;
nic_data->on_activating = NULL;
nic_data->on_going_down = NULL;
nic_data->on_stopping = NULL;
nic_data->specific = NULL;
fibril_rwlock_initialize(&nic_data->main_lock);
fibril_rwlock_initialize(&nic_data->stats_lock);
fibril_rwlock_initialize(&nic_data->rxc_lock);
fibril_rwlock_initialize(&nic_data->wv_lock);
bzero(&nic_data->mac, sizeof(nic_address_t));
bzero(&nic_data->default_mac, sizeof(nic_address_t));
bzero(&nic_data->stats, sizeof(nic_device_stats_t));
return nic_data;
}
/** Initialize a new ddf driver instance
*
* @param[in] device DDF instance of the device to initialize.
* @return Error code.
*/
static int mouse_add(ddf_dev_t *device)
{
if (!device)
return EINVAL;
#define CHECK_RET_RETURN(ret, message...) \
if (ret != EOK) { \
ddf_msg(LVL_ERROR, message); \
return ret; \
} else (void)0
ps2_mouse_t *mouse = ddf_dev_data_alloc(device, sizeof(ps2_mouse_t));
int ret = (mouse == NULL) ? ENOMEM : EOK;
CHECK_RET_RETURN(ret, "Failed to allocate mouse driver instance.");
ret = ps2_mouse_init(mouse, device);
CHECK_RET_RETURN(ret,
"Failed to initialize mouse driver: %s.", str_error(ret));
ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
device->name, device->handle);
return EOK;
}
/** Initialize a new ddf driver instance of the driver
*
* @param[in] device DDF instance of the device to initialize.
* @return Error code.
*/
static int xt_kbd_add(ddf_dev_t *device)
{
if (!device)
return EINVAL;
#define CHECK_RET_RETURN(ret, message...) \
if (ret != EOK) { \
ddf_msg(LVL_ERROR, message); \
return ret; \
} else (void)0
xt_kbd_t *kbd = ddf_dev_data_alloc(device, sizeof(xt_kbd_t));
int ret = (kbd == NULL) ? ENOMEM : EOK;
CHECK_RET_RETURN(ret, "Failed to allocate XT/KBD driver instance.");
ret = xt_kbd_init(kbd, device);
CHECK_RET_RETURN(ret,
"Failed to initialize XT_KBD driver: %s.", str_error(ret));
ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
ddf_dev_get_name(device), ddf_dev_get_handle(device));
return EOK;
}
/** Initialize a new ddf driver instance of the driver
*
* @param[in] device DDF instance of the device to initialize.
*
* @return Error code.
*
*/
static int at_kbd_add(ddf_dev_t *device)
{
int rc;
if (!device)
return EINVAL;
at_kbd_t *kbd = ddf_dev_data_alloc(device, sizeof(at_kbd_t));
if (kbd == NULL) {
ddf_msg(LVL_ERROR, "Failed to allocate AT_KBD driver instance.");
return ENOMEM;
}
rc = at_kbd_init(kbd, device);
if (rc != EOK) {
ddf_msg(LVL_ERROR, "Failed to initialize AT_KBD driver: %s.",
str_error(rc));
return rc;
}
ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
ddf_dev_get_name(device), ddf_dev_get_handle(device));
return EOK;
}
static int vhc_dev_add(ddf_dev_t *dev)
{
static int vhc_count = 0;
int rc;
if (vhc_count > 0) {
return ELIMIT;
}
vhc_data_t *data = ddf_dev_data_alloc(dev, sizeof(vhc_data_t));
if (data == NULL) {
usb_log_fatal("Failed to allocate memory.\n");
return ENOMEM;
}
data->magic = 0xDEADBEEF;
rc = usb_endpoint_manager_init(&data->ep_manager, (size_t) -1,
bandwidth_count_usb11);
if (rc != EOK) {
usb_log_fatal("Failed to initialize endpoint manager.\n");
free(data);
return rc;
}
usb_device_manager_init(&data->dev_manager, USB_SPEED_MAX);
ddf_fun_t *hc = ddf_fun_create(dev, fun_exposed, "hc");
if (hc == NULL) {
usb_log_fatal("Failed to create device function.\n");
free(data);
return ENOMEM;
}
ddf_fun_set_ops(hc, &vhc_ops);
list_initialize(&data->devices);
fibril_mutex_initialize(&data->guard);
data->hub = &virtual_hub_device;
data->hc_fun = hc;
rc = ddf_fun_bind(hc);
if (rc != EOK) {
usb_log_fatal("Failed to bind HC function: %s.\n",
str_error(rc));
free(data);
return rc;
}
rc = ddf_fun_add_to_category(hc, USB_HC_CATEGORY);
if (rc != EOK) {
usb_log_fatal("Failed to add function to HC class: %s.\n",
str_error(rc));
free(data);
return rc;
}
virtual_hub_device_init(hc);
usb_log_info("Virtual USB host controller ready (dev %zu, hc %zu).\n",
(size_t) ddf_dev_get_handle(dev), (size_t) ddf_fun_get_handle(hc));
rc = vhc_virtdev_plug_hub(data, data->hub, NULL);
if (rc != EOK) {
usb_log_fatal("Failed to plug root hub: %s.\n", str_error(rc));
free(data);
return rc;
}
return EOK;
}
/** Initialize new SB16 driver instance.
*
* @param[in] device DDF instance of the device to initialize.
* @return Error code.
*/
static int sb_add_device(ddf_dev_t *device)
{
bool handler_regd = false;
const size_t irq_cmd_count = sb16_irq_code_size();
irq_cmd_t irq_cmds[irq_cmd_count];
irq_pio_range_t irq_ranges[1];
sb16_t *soft_state = ddf_dev_data_alloc(device, sizeof(sb16_t));
int rc = soft_state ? EOK : ENOMEM;
if (rc != EOK) {
ddf_log_error("Failed to allocate sb16 structure.");
goto error;
}
addr_range_t sb_regs;
addr_range_t *p_sb_regs = &sb_regs;
addr_range_t mpu_regs;
addr_range_t *p_mpu_regs = &mpu_regs;
int irq = 0, dma8 = 0, dma16 = 0;
rc = sb_get_res(device, &p_sb_regs, &p_mpu_regs, &irq, &dma8, &dma16);
if (rc != EOK) {
ddf_log_error("Failed to get resources: %s.", str_error(rc));
goto error;
}
sb16_irq_code(p_sb_regs, dma8, dma16, irq_cmds, irq_ranges);
irq_code_t irq_code = {
.cmdcount = irq_cmd_count,
.cmds = irq_cmds,
.rangecount = 1,
.ranges = irq_ranges
};
rc = register_interrupt_handler(device, irq, irq_handler, &irq_code);
if (rc != EOK) {
ddf_log_error("Failed to register irq handler: %s.",
str_error(rc));
goto error;
}
handler_regd = true;
rc = sb_enable_interrupts(device);
if (rc != EOK) {
ddf_log_error("Failed to enable interrupts: %s.",
str_error(rc));
goto error;
}
rc = sb16_init_sb16(soft_state, p_sb_regs, device, dma8, dma16);
if (rc != EOK) {
ddf_log_error("Failed to init sb16 driver: %s.",
str_error(rc));
goto error;
}
rc = sb16_init_mpu(soft_state, p_mpu_regs);
if (rc == EOK) {
ddf_fun_t *mpu_fun =
ddf_fun_create(device, fun_exposed, "midi");
if (mpu_fun) {
rc = ddf_fun_bind(mpu_fun);
if (rc != EOK)
ddf_log_error(
"Failed to bind midi function: %s.",
str_error(rc));
} else {
ddf_log_error("Failed to create midi function.");
}
} else {
ddf_log_warning("Failed to init mpu driver: %s.",
str_error(rc));
}
/* MPU state does not matter */
return EOK;
error:
if (handler_regd)
unregister_interrupt_handler(device, irq);
return rc;
}
static int sb_get_res(ddf_dev_t *device, addr_range_t **pp_sb_regs,
addr_range_t **pp_mpu_regs, int *irq, int *dma8, int *dma16)
{
assert(device);
async_sess_t *parent_sess = devman_parent_device_connect(
ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
if (!parent_sess)
return ENOMEM;
hw_res_list_parsed_t hw_res;
hw_res_list_parsed_init(&hw_res);
const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
async_hangup(parent_sess);
if (ret != EOK) {
return ret;
}
/* 1x IRQ, 1-2x DMA(8,16), 1-2x IO (MPU is separate). */
if (hw_res.irqs.count != 1 ||
(hw_res.io_ranges.count != 1 && hw_res.io_ranges.count != 2) ||
(hw_res.dma_channels.count != 1 && hw_res.dma_channels.count != 2)) {
hw_res_list_parsed_clean(&hw_res);
return EINVAL;
}
if (irq)
*irq = hw_res.irqs.irqs[0];
if (dma8) {
if (hw_res.dma_channels.channels[0] < 4) {
*dma8 = hw_res.dma_channels.channels[0];
} else {
if (hw_res.dma_channels.count == 2 &&
hw_res.dma_channels.channels[1] < 4) {
*dma8 = hw_res.dma_channels.channels[1];
}
}
}
if (dma16) {
if (hw_res.dma_channels.channels[0] > 4) {
*dma16 = hw_res.dma_channels.channels[0];
} else {
if (hw_res.dma_channels.count == 2 &&
hw_res.dma_channels.channels[1] > 4) {
*dma16 = hw_res.dma_channels.channels[1];
}
}
}
if (hw_res.io_ranges.count == 1) {
if (pp_sb_regs && *pp_sb_regs)
**pp_sb_regs = hw_res.io_ranges.ranges[0];
if (pp_mpu_regs)
*pp_mpu_regs = NULL;
} else {
const int sb =
(hw_res.io_ranges.ranges[0].size >= sizeof(sb16_regs_t))
? 0 : 1;
const int mpu = 1 - sb;
if (pp_sb_regs && *pp_sb_regs)
**pp_sb_regs = hw_res.io_ranges.ranges[sb];
if (pp_mpu_regs && *pp_mpu_regs)
**pp_mpu_regs = hw_res.io_ranges.ranges[mpu];
}
return EOK;
}
