[qemu.git] / hw / usb / host-legacy.c

/*
 * Linux host USB redirector
 *
 * Copyright (c) 2005 Fabrice Bellard
 *
 * Copyright (c) 2008 Max Krasnyansky
 *      Support for host device auto connect & disconnect
 *      Major rewrite to support fully async operation
 *
 * Copyright 2008 TJ <[email protected]>
 *      Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
 *      to the legacy /proc/bus/usb USB device discovery and handling
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include "qemu-common.h"
#include "hw/usb.h"
#include "hw/usb/host.h"

/*
 * Autoconnect filter
 * Format:
 *    auto:bus:dev[:vid:pid]
 *    auto:bus.dev[:vid:pid]
 *
 *    bus  - bus number    (dec, * means any)
 *    dev  - device number (dec, * means any)
 *    vid  - vendor id     (hex, * means any)
 *    pid  - product id    (hex, * means any)
 *
 *    See 'lsusb' output.
 */
static int parse_filter(const char *spec, struct USBAutoFilter *f)
{
    enum { BUS, DEV, VID, PID, DONE };
    const char *p = spec;
    int i;

    f->bus_num    = 0;
    f->addr       = 0;
    f->vendor_id  = 0;
    f->product_id = 0;

    for (i = BUS; i < DONE; i++) {
        p = strpbrk(p, ":.");
        if (!p) {
            break;
        }
        p++;

        if (*p == '*') {
            continue;
        }
        switch (i) {
        case BUS:
            f->bus_num = strtol(p, NULL, 10);
            break;
        case DEV:
            f->addr    = strtol(p, NULL, 10);
            break;
        case VID:
            f->vendor_id  = strtol(p, NULL, 16);
            break;
        case PID:
            f->product_id = strtol(p, NULL, 16);
            break;
        }
    }

    if (i < DEV) {
        fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
        return -1;
    }

    return 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;
}

static void usb_host_register_types(void)
{
    usb_legacy_register("usb-host", "host", usb_host_device_open);
}

type_init(usb_host_register_types)
Commit	Line	Data
4075975d GH	1	/*
	2	* Linux host USB redirector
	3	*
	4	* Copyright (c) 2005 Fabrice Bellard
	5	*
	6	* Copyright (c) 2008 Max Krasnyansky
	7	* Support for host device auto connect & disconnect
	8	* Major rewrite to support fully async operation
	9	*
	10	* Copyright 2008 TJ <[email protected]>
	11	* Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
	12	* to the legacy /proc/bus/usb USB device discovery and handling
	13	*
	14	* Permission is hereby granted, free of charge, to any person obtaining a copy
	15	* of this software and associated documentation files (the "Software"), to deal
	16	* in the Software without restriction, including without limitation the rights
	17	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	18	* copies of the Software, and to permit persons to whom the Software is
	19	* furnished to do so, subject to the following conditions:
	20	*
	21	* The above copyright notice and this permission notice shall be included in
	22	* all copies or substantial portions of the Software.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	25	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	26	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	27	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	28	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	29	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	30	* THE SOFTWARE.
	31	*/
	32
e532b2e0	33	#include "qemu/osdep.h"
4075975d GH	34	#include "qemu-common.h"
	35	#include "hw/usb.h"
	36	#include "hw/usb/host.h"
	37
	38	/*
	39	* Autoconnect filter
	40	* Format:
	41	* auto:bus:dev[:vid:pid]
	42	* auto:bus.dev[:vid:pid]
	43	*
	44	* bus - bus number (dec, * means any)
	45	* dev - device number (dec, * means any)
	46	* vid - vendor id (hex, * means any)
	47	* pid - product id (hex, * means any)
	48	*
	49	* See 'lsusb' output.
	50	*/
	51	static int parse_filter(const char spec, struct USBAutoFilter f)
	52	{
	53	enum { BUS, DEV, VID, PID, DONE };
	54	const char *p = spec;
	55	int i;
	56
	57	f->bus_num = 0;
	58	f->addr = 0;
	59	f->vendor_id = 0;
	60	f->product_id = 0;
	61
	62	for (i = BUS; i < DONE; i++) {
	63	p = strpbrk(p, ":.");
	64	if (!p) {
	65	break;
	66	}
	67	p++;
	68
	69	if (p == '') {
	70	continue;
	71	}
	72	switch (i) {
	73	case BUS:
	74	f->bus_num = strtol(p, NULL, 10);
	75	break;
	76	case DEV:
	77	f->addr = strtol(p, NULL, 10);
	78	break;
	79	case VID:
	80	f->vendor_id = strtol(p, NULL, 16);
	81	break;
	82	case PID:
	83	f->product_id = strtol(p, NULL, 16);
	84	break;
	85	}
	86	}
	87
	88	if (i < DEV) {
	89	fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
	90	return -1;
	91	}
	92
	93	return 0;
	94	}
	95
	96	USBDevice usb_host_device_open(USBBus bus, const char *devname)
	97	{
98	struct USBAutoFilter filter;
99	USBDevice *dev;
100	char *p;
101
102	dev = usb_create(bus, "usb-host");
103
104	if (strstr(devname, "auto:")) {
105	if (parse_filter(devname, &filter) < 0) {
106	goto fail;
107	}
108	} else {
109	p = strchr(devname, '.');
110	if (p) {
111	filter.bus_num = strtoul(devname, NULL, 0);
112	filter.addr = strtoul(p + 1, NULL, 0);
113	filter.vendor_id = 0;
114	filter.product_id = 0;
115	} else {
116	p = strchr(devname, ':');
117	if (p) {
118	filter.bus_num = 0;
119	filter.addr = 0;
120	filter.vendor_id = strtoul(devname, NULL, 16);
121	filter.product_id = strtoul(p + 1, NULL, 16);
122	} else {
123	goto fail;
124	}
125	}
126	}
127
128	qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
129	qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
130	qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
131	qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
4075975d GH	132	return dev;
	133
	134	fail:
02a5c4c9	135	object_unparent(OBJECT(dev));
4075975d GH	136	return NULL;
	137	}
	138
	139	static void usb_host_register_types(void)
	140	{
	141	usb_legacy_register("usb-host", "host", usb_host_device_open);
	142	}
	143
	144	type_init(usb_host_register_types)