int vmm_netdev_register(struct vmm_netdev * ndev)
{
struct vmm_classdev *cd;
if (ndev == NULL) {
return VMM_EFAIL;
}
if (ndev->read == NULL || ndev->write == NULL) {
return VMM_EFAIL;
}
cd = vmm_malloc(sizeof(struct vmm_classdev));
if (!cd) {
return VMM_EFAIL;
}
INIT_LIST_HEAD(&cd->head);
vmm_strcpy(cd->name, ndev->name);
cd->dev = ndev->dev;
cd->priv = ndev;
vmm_devdrv_register_classdev(VMM_NETDEV_CLASS_NAME, cd);
return VMM_OK;
}
int vmm_chardev_register(struct vmm_chardev * cdev)
{
int rc;
struct vmm_classdev *cd;
if (!(cdev && cdev->read && cdev->write)) {
return VMM_EFAIL;
}
cd = vmm_malloc(sizeof(struct vmm_classdev));
if (!cd) {
return VMM_EFAIL;
}
vmm_memset(cd, 0, sizeof(struct vmm_classdev));
INIT_LIST_HEAD(&cd->head);
vmm_strcpy(cd->name, cdev->name);
cd->dev = cdev->dev;
cd->priv = cdev;
rc = vmm_devdrv_register_classdev(VMM_CHARDEV_CLASS_NAME, cd);
if (rc != VMM_OK) {
vmm_free(cd);
}
return rc;
}
void libfdt_node_parse_recursive(vmm_devtree_node_t * node,
char **data_ptr, char *str_buf)
{
vmm_devtree_node_t *child;
vmm_devtree_attr_t *attr;
if (LIBFDT_DATA32(*data_ptr) != FDT_BEGIN_NODE)
return;
*data_ptr += sizeof(u32);
node->name = vmm_malloc(vmm_strlen(*data_ptr) + 1);
vmm_strcpy(node->name, *data_ptr);
node->type = VMM_DEVTREE_NODETYPE_UNKNOWN;
node->priv = NULL;
*data_ptr += vmm_strlen(*data_ptr) + 1;
while ((u32) (*data_ptr) % sizeof(u32) != 0)
(*data_ptr)++;
while (LIBFDT_DATA32(*data_ptr) != FDT_END_NODE) {
switch (LIBFDT_DATA32(*data_ptr)) {
case FDT_PROP:
*data_ptr += sizeof(u32);
attr = vmm_malloc(sizeof(vmm_devtree_attr_t));
INIT_LIST_HEAD(&attr->head);
attr->len = LIBFDT_DATA32(*data_ptr);
*data_ptr += sizeof(u32);
attr->name = &str_buf[LIBFDT_DATA32(*data_ptr)];
*data_ptr += sizeof(u32);
attr->value = vmm_malloc(attr->len);
vmm_memcpy(attr->value, *data_ptr, attr->len);
*data_ptr += attr->len;
while ((u32) (*data_ptr) % sizeof(u32) != 0)
(*data_ptr)++;
list_add_tail(&node->attr_list, &attr->head);
break;
case FDT_NOP:
*data_ptr += sizeof(u32);
break;
case FDT_BEGIN_NODE:
child = vmm_malloc(sizeof(vmm_devtree_node_t));
INIT_LIST_HEAD(&child->head);
INIT_LIST_HEAD(&child->attr_list);
INIT_LIST_HEAD(&child->child_list);
child->parent = node;
libfdt_node_parse_recursive(child, data_ptr, str_buf);
list_add_tail(&node->child_list, &child->head);
break;
default:
return;
break;
};
}
*data_ptr += sizeof(u32);
return;
}
static int ne2k_driver_probe(struct vmm_driver *dev, const struct vmm_devid *devid)
{
int rc;
struct vmm_netdev *ndev;
struct nic_priv_data *priv_data;
ndev = vmm_malloc(sizeof(struct vmm_netdev));
if(!ndev) {
rc = VMM_EFAIL;
goto free_nothing;
}
vmm_memset(ndev,0, sizeof(struct vmm_netdev));
priv_data = vmm_malloc(sizeof(struct nic_priv_data));
if(!priv_data) {
rc = VMM_EFAIL;
goto free_chardev;
}
vmm_memset(priv_data,0, sizeof(struct nic_priv_data));
if (ne2k_init(priv_data)) {
rc = VMM_EFAIL;
goto free_chardev;
}
priv_data->txrx_thread = vmm_hyperthread_create("ne2k-isa-driver", dp83902a_poll, priv_data);
if (priv_data == NULL) {
rc = VMM_EFAIL;
goto free_chardev;
}
vmm_hyperthread_run(priv_data->txrx_thread);
vmm_strcpy(ndev->name, dev->node->name);
ndev->dev = dev;
ndev->ioctl = NULL;
ndev->read = ne2k_read;
ndev->write = ne2k_write;
ndev->priv = (void *)priv_data;
rc = vmm_netdev_register(ndev);
if(rc) {
goto free_port;
}
dev->priv = (void *)ndev;
return VMM_OK;
free_port:
vmm_free(priv_data);
free_chardev:
vmm_free(ndev);
free_nothing:
return rc;
}
static int cmd_vcpu_list(struct vmm_chardev *cdev, int dummy)
{
int id, count;
char state[10];
char path[256];
struct vmm_vcpu *vcpu;
vmm_cprintf(cdev, "----------------------------------------"
"----------------------------------------\n");
vmm_cprintf(cdev, "| %-5s| %-6s| %-9s| %-16s| %-33s|\n",
"ID ", "Prio", "State", "Name", "Device Path");
vmm_cprintf(cdev, "----------------------------------------"
"----------------------------------------\n");
count = vmm_manager_vcpu_count();
for (id = 0; id < count; id++) {
vcpu = vmm_manager_vcpu(id);
switch (vcpu->state) {
case VMM_VCPU_STATE_UNKNOWN:
vmm_strcpy(state, "Unknown");
break;
case VMM_VCPU_STATE_RESET:
vmm_strcpy(state, "Reset");
break;
case VMM_VCPU_STATE_READY:
vmm_strcpy(state, "Ready");
break;
case VMM_VCPU_STATE_RUNNING:
vmm_strcpy(state, "Running");
break;
case VMM_VCPU_STATE_PAUSED:
vmm_strcpy(state, "Paused");
break;
case VMM_VCPU_STATE_HALTED:
vmm_strcpy(state, "Halted");
break;
default:
vmm_strcpy(state, "Invalid");
break;
}
if (vcpu->node) {
vmm_devtree_getpath(path, vcpu->node);
vmm_cprintf(cdev, "| %-5d| %-6d| %-9s| %-16s| %-33s|\n",
id, vcpu->priority,
state, vcpu->name, path);
} else {
vmm_cprintf(cdev, "| %-5d| %-6d| %-9s| %-16s| %-33s|\n",
id, vcpu->priority,
state, vcpu->name, "(NA)");
}
}
vmm_cprintf(cdev, "----------------------------------------"
"----------------------------------------\n");
return VMM_OK;
}
static int cmd_profile_count_iterator(void *data, const char *name,
unsigned long addr)
{
struct count_record *ptr = data;
u32 index = kallsyms_get_symbol_pos(addr, NULL, NULL);
u32 count = vmm_profiler_get_function_count(addr);
u64 time = vmm_profiler_get_function_total_time(addr);
ptr += index;
/* It would be nice to have the strncpy variant */
vmm_strcpy(ptr->function_name, name);
ptr->function_name[39] = 0;
ptr->count = count;
ptr->total_time = time;
if (count) {
ptr->time_per_call = vmm_udiv64(time, (u64)count);
}
return VMM_OK;
}
int vmm_netdev_init(void)
{
int rc;
struct vmm_class *c;
c = vmm_malloc(sizeof(struct vmm_class));
if (!c) {
return VMM_EFAIL;
}
INIT_LIST_HEAD(&c->head);
vmm_strcpy(c->name, VMM_NETDEV_CLASS_NAME);
INIT_LIST_HEAD(&c->classdev_list);
rc = vmm_devdrv_register_class(c);
if (rc) {
vmm_free(c);
return rc;
}
return VMM_OK;
}
int __init vmm_chardev_init(void)
{
int rc;
struct vmm_class *c;
c = vmm_malloc(sizeof(struct vmm_class));
if (!c) {
return VMM_EFAIL;
}
vmm_memset(c, 0, sizeof(struct vmm_class));
INIT_LIST_HEAD(&c->head);
vmm_strcpy(c->name, VMM_CHARDEV_CLASS_NAME);
INIT_LIST_HEAD(&c->classdev_list);
rc = vmm_devdrv_register_class(c);
if (rc != VMM_OK) {
vmm_free(c);
}
return rc;
}
static int __init vmm_netdev_init(void)
{
int rc;
struct vmm_class *c;
vmm_printf("Initialize Networking Device Framework\n");
c = vmm_malloc(sizeof(struct vmm_class));
if (!c) {
return VMM_EFAIL;
}
INIT_LIST_HEAD(&c->head);
vmm_strcpy(c->name, VMM_NETDEV_CLASS_NAME);
INIT_LIST_HEAD(&c->classdev_list);
rc = vmm_devdrv_register_class(c);
if (rc) {
vmm_free(c);
return rc;
}
return VMM_OK;
}
static int uart_driver_probe(struct vmm_device *dev,const struct vmm_devid *devid)
{
int rc;
const char *attr;
struct vmm_chardev *cd;
struct uart_port *port;
cd = vmm_malloc(sizeof(struct vmm_chardev));
if(!cd) {
rc = VMM_EFAIL;
goto free_nothing;
}
vmm_memset(cd, 0, sizeof(struct vmm_chardev));
port = vmm_malloc(sizeof(struct uart_port));
if(!port) {
rc = VMM_EFAIL;
goto free_chardev;
}
vmm_memset(port, 0, sizeof(struct uart_port));
vmm_strcpy(cd->name, dev->node->name);
cd->dev = dev;
cd->ioctl = NULL;
cd->read = uart_read;
cd->write = uart_write;
cd->priv = port;
rc = vmm_devdrv_ioremap(dev, &port->base, 0);
if(rc) {
goto free_port;
}
attr = vmm_devtree_attrval(dev->node, "reg_align");
if (attr) {
port->reg_align = *((u32 *)attr);
} else {
port->reg_align = 1;
}
attr = vmm_devtree_attrval(dev->node, "reg_offset");
if (attr) {
port->base += *((u32 *)attr);
}
attr = vmm_devtree_attrval(dev->node, "baudrate");
if(!attr) {
rc = VMM_EFAIL;
goto free_port;
}
port->baudrate = *((u32 *)attr);
port->input_clock = vmm_devdrv_clock_rate(dev);
/* Call low-level init function */
uart_lowlevel_init(port->base, port->reg_align,
port->baudrate, port->input_clock);
rc = vmm_chardev_register(cd);
if(rc) {
goto free_port;
}
return VMM_OK;
free_port:
vmm_free(port);
free_chardev:
vmm_free(cd);
free_nothing:
return rc;
}
