コード例 #1
0
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);
}
コード例 #2
0
ファイル: dev.c プロジェクト: funtoo/vzctl
/** 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;
}
コード例 #3
0
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);
}
コード例 #4
0
ファイル: char_module_all.c プロジェクト: davidweber/bb-misc
int init_module(void)
{
  int status = 0;

  printk("%s - %s\n", MODULE_NAME, __FUNCTION__);

  status = dev_create(&dev_config, &driver_funcs);

  return status;
}
コード例 #5
0
ファイル: dev_wic_serial.c プロジェクト: GNS3/dynamips
/* 
 * 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);
}
コード例 #6
0
ファイル: device.c プロジェクト: AtomSoftTech/retrobsd
/* 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;
}
コード例 #7
0
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);
}
コード例 #8
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);
    }
}
コード例 #9
0
ファイル: devfs.c プロジェクト: Ted-Chang/matrix
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;
}
コード例 #10
0
ファイル: device.c プロジェクト: AtomSoftTech/retrobsd
/* 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;
}
コード例 #11
0
ファイル: wiimote-pad.c プロジェクト: BadDude/wiimote-pad
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;
}
コード例 #12
0
ファイル: cmd_reg.c プロジェクト: jinxinzheng/GSConferencing
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;
}