int dev_sw_init (vm_instance_t * vm, char *name, m_pa_t paddr, m_uint32_t len) { struct sw_data *d; /* allocate the private data structure */ if (!(d = malloc (sizeof (*d)))) { fprintf (stderr, "SW: unable to create device.\n"); return (-1); } memset (d, 0, sizeof (*d)); if (!(d->dev = dev_create (name))) goto err_dev_create; d->dev->priv_data = d; d->dev->phys_addr = paddr; d->dev->phys_len = len; d->sw_ptr = (m_uint8_t *) (m_iptr_t) (&sw_table[0]); d->sw_size = len; d->dev->handler = dev_sw_access; d->dev->flags = VDEVICE_FLAG_NO_MTS_MMAP; vm_bind_device (vm, d->dev); dev_sw_init_defaultvalue (); return (0); err_dev_create: free (d); return (-1); }
/** Allow/disallow access to devices on host system from CT. * * @param h CT handler. * @param veid CT ID. * @param root CT root. * @param dev devices list. * @return 0 on success. */ int vps_set_devperm(vps_handler *h, envid_t veid, const char *root, dev_param *dev) { int ret = 0; dev_res *res; list_head_t *dev_h = &dev->dev; if (list_empty(dev_h)) return 0; if (!vps_is_run(h, veid)) { logger(-1, 0, "Unable to apply devperm: " "container is not running"); return VZ_VE_NOT_RUNNING; } logger(0, 0, "Setting devices"); list_for_each(res, dev_h, list) { if (res->name) if ((ret = dev_create(root, res))) goto out; if ((ret = set_devperm(h, veid, res))) goto out; } out: return ret; }
int dev_pic32_uart_init (vm_instance_t *vm, char *name, unsigned paddr, unsigned irq, vtty_t *vtty) { struct pic32_uart_data *d; /* allocate the private data structure */ d = malloc (sizeof (*d)); if (!d) { fprintf (stderr, "PIC32 UART: unable to create device.\n"); return (-1); } memset (d, 0, sizeof (*d)); d->dev = dev_create (name); if (!d->dev) { free (d); return (-1); } d->dev->priv_data = d; d->dev->phys_addr = paddr; d->dev->phys_len = UART_REG_SIZE; d->dev->flags = VDEVICE_FLAG_NO_MTS_MMAP; d->vm = vm; (*d).vtty = vtty; d->irq = irq; vtty->priv_data = d; d->dev->handler = dev_pic32_uart_access; d->dev->reset_handler = dev_pic32_uart_reset; (*d).vtty->read_notifier = pic32_tty_con_input; d->uart_timer = vp_new_timer (rt_clock, dev_pic32_uart_cb, d); vp_mod_timer (d->uart_timer, vp_get_clock (rt_clock) + UART_TIME_OUT); vm_bind_device (vm, d->dev); return (0); }
int init_module(void) { int status = 0; printk("%s - %s\n", MODULE_NAME, __FUNCTION__); status = dev_create(&dev_config, &driver_funcs); return status; }
/* * dev_wic_serial_init() * * Generic WIC Serial initialization code. */ struct wic_serial_data * dev_wic_serial_init(vm_instance_t *vm,char *name,u_int model, m_uint64_t paddr,m_uint32_t len) { struct wic_serial_data *d; struct vdevice *dev; /* Allocate the private data structure for WIC */ if (!(d = malloc(sizeof(*d)))) { fprintf(stderr,"%s (WIC-SERIAL): out of memory\n",name); return NULL; } memset(d,0,sizeof(*d)); /* Create the device itself */ if (!(dev = dev_create(name))) { fprintf(stderr,"%s (WIC): unable to create device.\n",name); free(d); return NULL; } d->name = name; d->vm = vm; dev_init(&d->dev); d->dev.name = name; d->dev.priv_data = d; d->dev.phys_addr = paddr; d->dev.phys_len = len; switch(model) { case WIC_SERIAL_MODEL_1T: d->dev.handler = dev_wic1t_access; break; case WIC_SERIAL_MODEL_2T: d->dev.handler = dev_wic2t_access; break; default: fprintf(stderr,"%s (WIC-SERIAL): unknown model %u\n",name,model); free(d); return NULL; } /* Map this device to the VM */ vm_bind_device(vm,&d->dev); return(d); }
/* Remap a device at specified physical address */ struct vdevice *dev_remap (char *name, struct vdevice *orig, m_pa_t paddr, m_uint32_t len) { struct vdevice *dev; if (!(dev = dev_create (name))) return NULL; dev->phys_addr = paddr; dev->phys_len = len; dev->flags = orig->flags | VDEVICE_FLAG_REMAP; dev->fd = orig->fd; dev->host_addr = orig->host_addr; dev->handler = orig->handler; //dev->sparse_map = orig->sparse_map; return dev; }
int dev_pic32_rtcc_init (vm_instance_t *vm, char *name, unsigned paddr) { pic32_t *pic32 = (pic32_t *) vm->hw_data; pic32->rtcdev = dev_create (name); if (! pic32->rtcdev) return (-1); pic32->rtcdev->priv_data = pic32; pic32->rtcdev->phys_addr = paddr; pic32->rtcdev->phys_len = RTCC_REG_SIZE; pic32->rtcdev->handler = dev_pic32_rtcc_access; pic32->rtcdev->reset_handler = dev_pic32_rtcc_reset; pic32->rtcdev->flags = VDEVICE_FLAG_NO_MTS_MMAP; vm_bind_device (vm, pic32->rtcdev); return (0); }
static void dev_refresh(const char *udi) { const char *name = hal_name(udi); virNodeDeviceObjPtr dev; nodeDeviceLock(driverState); dev = virNodeDeviceFindByName(&driverState->devs, name); if (dev) { /* Simply "rediscover" device -- incrementally handling changes * to sub-capabilities (like net.80203) is nasty ... so avoid it. */ virNodeDeviceObjRemove(&driverState->devs, dev); } else VIR_DEBUG("no device named %s", name); nodeDeviceUnlock(driverState); if (dev) { dev_create(udi); } }
static int devfs_read_node(struct vfs_mount *mnt, ino_t id, struct vfs_node **np) { int rc = -1, i; struct vfs_node *node; struct dev *dev; ASSERT(np != NULL); for (i = 0; i < NR_MAX_DEVS; i++) { if (_devfs_nodes[i].ino == id) { // TODO: devfs node should has a context with it node = vfs_node_alloc(mnt, _devfs_nodes[i].type, &_devfs_node_ops, NULL); if (!node) { rc = ENOMEM; break; } node->ino = id; node->mask = _devfs_nodes[i].mask; node->length = 0; strncpy(node->name, _devfs_nodes[i].name, 128); rc = dev_create(_devfs_nodes[i].dev_id, 0, NULL, &dev); if (rc != 0) { DEBUG(DL_WRN, ("open dev(%s:%x) failed.\n", _devfs_nodes[i].name, _devfs_nodes[i].dev_id)); break; } node->data = dev; *np = node; rc = 0; break; } } return rc; }
/* Create a RAM device */ struct vdevice *dev_create_ram (vm_instance_t * vm, char *name, m_pa_t paddr, m_uint32_t len) { struct vdevice *dev; if (!(dev = dev_create (name))) return NULL; dev->phys_addr = paddr; dev->phys_len = len; //dev->flags = VDEVICE_FLAG_CACHING; dev->host_addr = (m_iptr_t) m_memalign (4096, dev->phys_len); if (!dev->host_addr) { free (dev); return NULL; } vm_bind_device (vm, dev); return dev; }
int main(int argc, char *argv[]) { int ret; size_t j; fd_set fds[1]; atexit(destroy_all_devs); signal(SIGINT, sig_exit); if (argc > 1) { dev->device = argv[1]; ret = dev_create(dev); if (ret) { fprintf(stderr, "could not %s (%d): %s\n", "associate", ret, strerror(ret)); return ret; } } else { /* No device specified. Since the Linux kernel exposes the * controller also as a joystick (without axes), we peek at * all available joysticks looking for one which is a Wiimote */ switch (glob(js_glob, GLOB_NOSORT, NULL, &js_devs)) { case GLOB_ABORTED: case GLOB_NOMATCH: case GLOB_NOSPACE: fputs("no joysticks found\n", stderr); exit(ENODEV); } for (j = 0; j < js_devs.gl_pathc; ++j) { dev->device = js_devs.gl_pathv[j]; ret = dev_create(dev); if (!ret) break; /* found */ printf("skipping %s (%d): %s\n", dev->device, ret, strerror(ret)); dev->device = NULL; } if (!dev->device) { fputs("no wiimote found\n", stderr); exit(ENODEV); } } dev->uinput = open(uinput_path, O_WRONLY | O_NONBLOCK); err_check(dev->uinput, "open uinput"); dev_init(dev); do { memset(&no_wait, 0, sizeof(no_wait)); FD_ZERO(fds); FD_SET(dev->fd, fds); if (last_signal) break; ret = select(dev->fd + 1, fds, NULL, NULL, NULL); err_check(ret, "poll wiimote fd"); if (ret > 0) { ret = wiimote_poll(dev); err_check(ret, "process wiimote data"); } } while (1); return ret; }
static int cmd_reg(struct cmd *cmd) { int a=0; char *p; struct device *d; struct db_device *dd; char sum[64]; unsigned int n; int type; char *pass; int port; char *bcast; int did = cmd->device_id; char buf[CMD_MAX]; NEXT_ARG(p); type = atoi(p); NEXT_ARG(p); pass = p; NEXT_ARG(p); port = atoi(p); NEXT_ARG(p); bcast = p; /* authenticate the passwd based on id and type */ n = (unsigned int)cmd->device_id ^ (unsigned int)type; cksum(&n, sizeof n, sum); if (strcmp(pass, sum) != 0) { trace_warn("authenticate fail\n"); return 1; } if (port <= 0) return 1; dd = md_find_device(did); if( dd ) { /* mark it online even if it's disabled. * needed for the manager to identify online devs. */ dd->online = 1; if( !dd->enabled ) { return ERR_DEV_DISABLED; } } d = get_device(did); if( !d ) { d = dev_create(did); } d->type = type; d->addr = *cmd->saddr; d->addr.sin_port = htons(port); d->fileaddr = d->addr; d->fileaddr.sin_port = htons(port+1); if (strcmp("none", bcast) == 0) d->bcast.sin_addr.s_addr = 0; else { d->bcast.sin_addr.s_addr = inet_addr(bcast); d->bcast.sin_port = htons(BRCAST_PORT); } dev_update_data(d); if (dev_register(d) != 0) { /* existing dev ok */ } dev_activate(d); if( is_ptc(d) ) { /* re-set ptc if it's restarted. */ ptc_go_current(); } if( d->type == DEVTYPE_CHAIR ) { manage_notify_chair(d); } get_client_info(buf, d); REP_ADD(cmd, "OK"); REP_ADD(cmd, buf); REP_END(cmd); return 0; }