Пример #1
0
/*************************************************************************
* FUNCTION
*  custom_usb_create
*
* DESCRIPTION
*  Customize usb create function.
*  Return KAL_FALSE directly if usb should not be created.
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool custom_usb_create(comptask_handler_struct **handle)
{
#ifdef __USB_ENABLE__
   return usb_create(handle);
#else
   return KAL_FALSE;
#endif
}
Пример #2
0
static USBDevice *usb_serial_init(USBBus *bus, const char *filename)
{
    USBDevice *dev;
    CharDriverState *cdrv;
    uint32_t vendorid = 0, productid = 0;
    char label[32];
    static int index;

    while (*filename && *filename != ':') {
        const char *p;
        char *e;
        if (strstart(filename, "vendorid=", &p)) {
            vendorid = strtol(p, &e, 16);
            if (e == p || (*e && *e != ',' && *e != ':')) {
                error_report("bogus vendor ID %s", p);
                return NULL;
            }
            filename = e;
        } else if (strstart(filename, "productid=", &p)) {
            productid = strtol(p, &e, 16);
            if (e == p || (*e && *e != ',' && *e != ':')) {
                error_report("bogus product ID %s", p);
                return NULL;
            }
            filename = e;
        } else {
            error_report("unrecognized serial USB option %s", filename);
            return NULL;
        }
        while(*filename == ',')
            filename++;
    }
    if (!*filename) {
        error_report("character device specification needed");
        return NULL;
    }
    filename++;

    snprintf(label, sizeof(label), "usbserial%d", index++);
    cdrv = qemu_chr_new(label, filename, NULL);
    if (!cdrv)
        return NULL;

    dev = usb_create(bus, "usb-serial");
    if (!dev) {
        return NULL;
    }
    qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
    if (vendorid)
        qdev_prop_set_uint16(&dev->qdev, "vendorid", vendorid);
    if (productid)
        qdev_prop_set_uint16(&dev->qdev, "productid", productid);
    qdev_init_nofail(&dev->qdev);

    return dev;
}
Пример #3
0
static USBDevice *usb_msd_init(const char *filename)
{
    static int nr=0;
    char id[8];
    QemuOpts *opts;
    DriveInfo *dinfo;
    USBDevice *dev;
    int fatal_error;
    const char *p1;
    char fmt[32];

    /* parse -usbdevice disk: syntax into drive opts */
    snprintf(id, sizeof(id), "usb%d", nr++);
    opts = qemu_opts_create(&qemu_drive_opts, id, 0);

    p1 = strchr(filename, ':');
    if (p1++) {
        const char *p2;

        if (strstart(filename, "format=", &p2)) {
            int len = MIN(p1 - p2, sizeof(fmt));
            pstrcpy(fmt, len, p2);
            qemu_opt_set(opts, "format", fmt);
        } else if (*filename != ':') {
            printf("unrecognized USB mass-storage option %s\n", filename);
            return NULL;
        }
        filename = p1;
    }
    if (!*filename) {
        printf("block device specification needed\n");
        return NULL;
    }
    qemu_opt_set(opts, "file", filename);
    qemu_opt_set(opts, "if", "none");

    /* create host drive */
    dinfo = drive_init(opts, NULL, &fatal_error);
    if (!dinfo) {
        qemu_opts_del(opts);
        return NULL;
    }

    /* create guest device */
    dev = usb_create(NULL /* FIXME */, "usb-storage");
    if (!dev) {
        return NULL;
    }
    qdev_prop_set_drive(&dev->qdev, "drive", dinfo);
    if (qdev_init(&dev->qdev) < 0)
        return NULL;

    return dev;
}
Пример #4
0
static USBDevice *usb_braille_init(USBBus *bus, const char *unused)
{
    USBDevice *dev;
    CharDriverState *cdrv;

    cdrv = qemu_chr_new("braille", "braille", NULL);
    if (!cdrv)
        return NULL;

    dev = usb_create(bus, "usb-braille");
    qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
    return dev;
}
Пример #5
0
USBDevice *usb_host_device_open(USBBus *bus, const char *devname)
{
    struct USBAutoFilter filter;
    USBDevice *dev;
    char *p;

    dev = usb_create(bus, "usb-host");

    if (strstr(devname, "auto:")) {
        if (parse_filter(devname, &filter) < 0) {
            goto fail;
        }
    } else {
        p = strchr(devname, '.');
        if (p) {
            filter.bus_num    = strtoul(devname, NULL, 0);
            filter.addr       = strtoul(p + 1, NULL, 0);
            filter.vendor_id  = 0;
            filter.product_id = 0;
        } else {
            p = strchr(devname, ':');
            if (p) {
                filter.bus_num    = 0;
                filter.addr       = 0;
                filter.vendor_id  = strtoul(devname, NULL, 16);
                filter.product_id = strtoul(p + 1, NULL, 16);
            } else {
                goto fail;
            }
        }
    }

    qdev_prop_set_uint32(&dev->qdev, "hostbus",   filter.bus_num);
    qdev_prop_set_uint32(&dev->qdev, "hostaddr",  filter.addr);
    qdev_prop_set_uint32(&dev->qdev, "vendorid",  filter.vendor_id);
    qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
    return dev;

fail:
    object_unparent(OBJECT(dev));
    return NULL;
}
Пример #6
0
/*-----------------------------------------------------------------------------
 * Name      :  usb_create_from_uri
 * Purpose   :  Create USB port from URI string
 * Inputs    :  p   : port structure
 *              uri : URI string
 * Outputs   :  <>
 * Return    :  APS_OK or error code
 * -----------------------------------------------------------------------------*/
int usb_create_from_uri(aps_port_t *p,struct aps_uri *su)
{
	libusb_device * dev;
	libusb_device_handle * h;
	int r;
	ssize_t cnt;
	int i;
	const char *vidstr;
	const char *pidstr;
	int vid, pid;

	p->set.usb.busnum = 0;
	p->set.usb.devaddr = 0;

	vidstr = uri_get_opt(su,"vid");
	pidstr = uri_get_opt(su,"pid");

#ifdef DEBUG
	fprintf(stderr, "DEBUG: in %s()\n", __func__);
#endif
	if (devcnt == 0)
	{
		return APS_USB_DEVICE_NOT_FOUND;
	}

	if (vidstr == 0 || pidstr == 0)
	{
		return APS_INVALID_URI;
	}

	if (sscanf(vidstr,"%i",&vid)!=1) {
		return APS_INVALID_URI;
	}
	if (sscanf(pidstr,"%i",&pid)!=1) {
		return APS_INVALID_URI;
	}

	i = 0;
	while ((dev = devs[i]) != NULL)
	{
		struct libusb_device_descriptor desc;

		r = libusb_get_device_descriptor(dev, &desc);
		if (r < 0)
		{
			fprintf(stderr, "ERROR: failed to get device descriptor");
			libusb_free_device_list(devs, 1);
			libusb_exit(NULL);
			return APS_USB_DEVICE_NOT_FOUND;
		}

		//if (desc.idVendor == APS_VENDOR_ID || desc.idVendor == APS_VENDOR_ID0)
		if (desc.idVendor == vid && desc.idProduct == pid)
		{
#ifdef DEBUG
			fprintf(stderr, "DEBUG: ok, aps printer found...\n");
#endif
			break;
		}
		i ++;
	}

	if (dev == 0)
	{
#ifdef DEBUG
		fprintf(stderr, "DEBUG: aps printer not found, exiting\n");
#endif
		libusb_free_device_list(devs, 1);
		libusb_exit(NULL);
		devs = 0;
		devcnt = 0;
		return APS_USB_DEVICE_NOT_FOUND;
	}
#ifdef DEBUG
	fprintf(stderr, "DEBUG: printer at bus: %i\n", libusb_get_bus_number(dev));
	fprintf(stderr, "DEBUG: printer at address: %i\n", libusb_get_device_address(dev));
#endif
	/* shopov(04072011) - added */
	p->set.usb.busnum = libusb_get_bus_number(dev);
	p->set.usb.devaddr = libusb_get_device_address(dev);
	return APS_OK;
	/* shopov(04072011) - end added */
#if 0	

	if (libusb_open(dev, &h))
	{
		fprintf(stderr, "DEBUG: aps printer not found, exiting\n");
		libusb_free_device_list(devs, 1);
		libusb_exit(NULL);
		devs = 0;
		devcnt = 0;
		return APS_USB_DEVICE_NOT_FOUND;
	}
	r = libusb_kernel_driver_active(h, 0);
	if (r != 0 && r != 1)
	{
close_and_return:		
		libusb_close(h);
		fprintf(stderr, "DEBUG: aps printer not found, exiting\n");
		libusb_free_device_list(devs, 1);
		libusb_exit(NULL);
		devs = 0;
		devcnt = 0;
		return APS_IO_ERROR;
	}
	p->set.usb.was_kernel_driver_attached = r;
	if (r)
	{
		r = libusb_detach_kernel_driver(h, 0);
		if (r != 0)
			goto close_and_return;
	}
	r = libusb_claim_interface(h, 0);
	if (r != 0)
		goto close_and_return;

	p->set.usb.pdev = dev;
	p->set.usb.hdev = h;

	return APS_OK;
#endif


#if 0
	struct stat st;
	const char *device;
	const char *usbfs;
	const char *path;
	const char *vidstr;
	const char *pidstr;

	/*get device name*/
	device = uri_get_device(su);

	printf("Device:%s\n",device);

	if (stat(device,&st)<0) {
		return APS_IO_ERROR;
	}

	printf("stats ok!:\n");

	if (S_ISCHR(st.st_mode)) {
		printf("S_ISCHR =============ok!:\n");
		/*build connection path from device name*/
		return usb_create(p,device);
	}
	else if (S_ISDIR(st.st_mode)) {
		printf("S_ISDIR ok!:\n");
		usbfs = device;
	}
	else {
		printf("Ke dall !  ok!:\n");
		return APS_INVALID_URI;
	}

	/*get path, vendor ID and product ID parameters*/
	path = uri_get_opt(su,"path");
	vidstr = uri_get_opt(su,"vid");
	pidstr = uri_get_opt(su,"pid");

	if (path!=NULL) {
		/*create USB port from connection path*/
		/*just copy path into port structure*/

		/*set usbfs parameter*/
		if (strlen(usbfs)>sizeof(p->set.usb.usbfs)-1) {
			return APS_NAME_TOO_LONG;
		}
		else {
			strcpy(p->set.usb.usbfs,usbfs);
		}

		/*copy connection path*/
		if (strlen(path)>sizeof(p->set.usb.path)-1) {
			return APS_NAME_TOO_LONG;
		}
		else {
			strcpy(p->set.usb.path,path);
		}
	}
	else if (vidstr!=NULL && pidstr!=NULL) {
		/*create USB port from (vendor ID,product ID) pair*/
		/*build connection path*/

		int vid;
		int pid;

		if (sscanf(vidstr,"%i",&vid)!=1) {
			return APS_INVALID_URI;
		}
		if (sscanf(pidstr,"%i",&pid)!=1) {
			return APS_INVALID_URI;
		}

		return usb_create_from_id(p,usbfs,vid,pid);
	}
	else {
		return APS_INVALID_URI;
	}

	return APS_OK;
#endif
	return APS_OK;
}