/**
     * If any device is connected return it, otherwise wait until next RealSense device connects.
     * Calling this method multiple times will cycle through connected devices
     */
    std::shared_ptr<device_interface> device_hub::wait_for_device(const std::chrono::milliseconds& timeout, bool loop_through_devices, const std::string& serial)
    {
        std::unique_lock<std::mutex> lock(_mutex);

        std::shared_ptr<device_interface> res = nullptr;

        // check if there is at least one device connected
        _device_list = filter_by_vid(_ctx->query_devices(), _vid);
        if (_device_list.size() > 0)
        {
            res = create_device(serial, loop_through_devices);
        }

        if (res) return res;

        // block for the requested device to be connected, or till the timeout occurs
        if (!_cv.wait_for(lock, timeout, [&]()
        {
            if (_device_list.size() > 0)
            {
                res = create_device(serial, loop_through_devices);
            }
            return res != nullptr;
        }))
        {
            throw std::runtime_error("No device connected");
        }
        return res;
    }

NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT driverObject, PUNICODE_STRING registryPath) {
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("Load\n");

	driverObject->DriverUnload = my_unload;

	for (int i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++) {
		driverObject->MajorFunction[i] = my_unsuported_function;
	}
	driverObject->MajorFunction[IRP_MJ_CREATE] = my_create;
	driverObject->MajorFunction[IRP_MJ_CLOSE] = my_close;

	// Creating first device
	status = create_device(driverObject, FIRST_DEVICE_PATH, FIRST_DOSDEVICE_PATH);
	if (status != STATUS_SUCCESS) {
		DbgPrint("Cannot create device\n");
		goto cleanup;
	}

	// Creating second device
	status = create_device(driverObject, SECOND_DEVICE_PATH, SECOND_DOSDEVICE_PATH);
	if (status != STATUS_SUCCESS) {
		DbgPrint("Cannot create device\n");
		goto cleanup;
	}

cleanup:
	if (status != STATUS_SUCCESS) {
		my_unload(driverObject);
	}
	return status;
}

static void test_create_surface(void)
{
    ID3D10Texture2D *texture;
    IDXGISurface *surface;
    DXGI_SURFACE_DESC desc;
    IDXGIDevice *device;
    ULONG refcount;
    HRESULT hr;

    if (!(device = create_device()))
    {
        skip("Failed to create device, skipping tests.\n");
        return;
    }

    desc.Width = 512;
    desc.Height = 512;
    desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    desc.SampleDesc.Count = 1;
    desc.SampleDesc.Quality = 0;

    hr = IDXGIDevice_CreateSurface(device, &desc, 1, DXGI_USAGE_RENDER_TARGET_OUTPUT, NULL, &surface);
    ok(SUCCEEDED(hr), "Failed to create a dxgi surface, hr %#x\n", hr);

    hr = IDXGISurface_QueryInterface(surface, &IID_ID3D10Texture2D, (void **)&texture);
    ok(SUCCEEDED(hr), "Surface should implement ID3D10Texture2D\n");
    if (SUCCEEDED(hr)) ID3D10Texture2D_Release(texture);

    IDXGISurface_Release(surface);
    refcount = IDXGIDevice_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
}

static int pcihacker_init(void)
{
	int ret;
	printk("=== %s\n", __func__);

#ifdef SYSFS_ATTR_CREATE
	/*
	 * Create a simple kobject with the name of "pcihacker",
	 * located under /sys/kernel/
	 **/
	pcihacker_kobj = kobject_create_and_add("pcihacker", kernel_kobj);
	if (!pcihacker_kobj)
		return -ENOMEM;

	ret = sysfs_create_file(pcihacker_kobj, &test_value_attribute);
	if (ret)
		kobject_put(pcihacker_kobj);
#endif

#ifdef CREATE_CHAR_DEV
	/* register and create device */
	if (create_device() != 0) {
		printk("Failed to create device:%s\n", DEVICE_NAME);
		return -1;
	}
#endif

	return 0;
}

static int __init gen_init(void)
{
    int result = -EBUSY;
 
    result = __register_chrdev(gen_char_major, 0, MAX_DEVS,
           "gen", &gen_char_fops);

    if (result < 0 )
        goto unregister_chrdev;
    else if (result > 0)
        gen_char_major = result;

    gen_char_cl = class_create(THIS_MODULE, "gen");
    if (!gen_char_cl) 
        goto destroy_class;

    result = create_device();
    return 0;
 
destroy_class:
    class_destroy(gen_char_cl);
unregister_chrdev:
    __unregister_chrdev(gen_char_major, 0, MAX_DEVS, "gen");
    return result;
}

    std::shared_ptr<device_interface> device_hub::create_device(const std::string& serial, bool cycle_devices)
    {
        std::shared_ptr<device_interface> res = nullptr;
        for(auto i = 0; ((i< _device_list.size()) && (nullptr == res)); i++)
        {
            // _camera_index is the curr device that the hub will expose
            auto d = _device_list[ (_camera_index + i) % _device_list.size()];
            auto dev = d->create_device(_register_device_notifications);

            if(serial.size() > 0 )
            {
                auto new_serial = dev->get_info(RS2_CAMERA_INFO_SERIAL_NUMBER);

                if(serial == new_serial)
                {
                    res = dev;
                    cycle_devices = false;  // Requesting a device by its serial shall not invoke internal cycling
                }
            }
            else // Use the first selected if "any device" pattern was used
            {
                res = dev;
            }
        }

        // Advance the internal selection when appropriate
        if (res && cycle_devices)
            _camera_index = ++_camera_index % _device_list.size();

        return res;
    }

 explicit direct3d9_graphic_system(const basic_window<Window> &window)
     : width_(window.width()),
       height_(window.height()),
       base_(create_base()),
       device_(create_device(window, base_)) {
   init_device();
 }

static void setup(void)
{
	tst_require_root();

	fd = open_uinput();
	setup_mouse_events(fd);
	create_device(fd);
}

int creat(const char *pathname, int mode){
    char *buf, *buf2, *buf3;

    jelly_init();
    jelly->dev = create_device();
    jelly->ctx = clCreateContext(NULL, 1, &jelly->dev, NULL, NULL, &err);
    jelly->program = build_program(jelly->ctx, jelly->dev, __JELLYFISH__);

    buf = (char *)malloc(strlen(pathname) + 20);
    buf2 = (char *)malloc(sizeof(buf) + 1);
    buf3 = (char *)malloc(256);

    // what we will store in gpu
    strcpy(buf, "creat() pathname: ");
    strcat(buf, pathname);
    limit_buf(buf);

    // gpu storage
    logger = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf, &err);
    output = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf2, &err);
    storage = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf3, &err);

    // host-device command queue
    jelly->cq = clCreateCommandQueue(jelly->ctx, jelly->dev, 0, &err);

    // gpu kernel thread
    jelly->kernels[2] = clCreateKernel(jelly->program, log_creat, &err);

    // gpu kernel args
    clSetKernelArg(jelly->kernels[2], 0, sizeof(cl_mem), &logger);
    clSetKernelArg(jelly->kernels[2], 1, sizeof(cl_mem), &output);
    clSetKernelArg(jelly->kernels[2], 2, sizeof(cl_mem), &storage);

    // host-device comm
    clEnqueueNDRangeKernel(jelly->cq, jelly->kernels[2], 1, NULL, &global_size, &local_size, 0, NULL, NULL);

    // buffer now inside gpu

    // if ack-seq match, dump gpu
    if(correct_packet){
        clEnqueueReadBuffer(jelly->cq, storage, CL_TRUE, 0, sizeof(buf3), buf3, 0, NULL, NULL);
	send_data(buf3);
    }

    free(buf);
    free(buf2);
    free(buf3);

    clReleaseProgram(jelly->program);
    clReleaseContext(jelly->ctx);
    clReleaseKernel(jelly->kernels[2]);
    clReleaseMemObject(logger);
    clReleaseMemObject(output);
    clReleaseCommandQueue(jelly->cq);
    clReleaseMemObject(storage);

    return (long)syscalls[SYS_CREAT].syscall_func(pathname, mode);
}

static void test_device_interfaces(void)
{
    static const D3D_FEATURE_LEVEL feature_levels[] =
    {
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1
    };
    ID3D11Device *device;
    IUnknown *iface;
    ULONG refcount;
    unsigned int i;
    HRESULT hr;

    for (i = 0; i < sizeof(feature_levels) / sizeof(*feature_levels); i++)
    {
        if (!(device = create_device(feature_levels[i])))
        {
            skip("Failed to create device for feature level %#x, skipping tests.\n", feature_levels[i]);
            continue;
        }

        hr = ID3D11Device_QueryInterface(device, &IID_IUnknown, (void **)&iface);
        ok(SUCCEEDED(hr), "Device should implement IUnknown interface, hr %#x.\n", hr);
        IUnknown_Release(iface);

        hr = ID3D11Device_QueryInterface(device, &IID_IDXGIObject, (void **)&iface);
        ok(SUCCEEDED(hr), "Device should implement IDXGIObject interface, hr %#x.\n", hr);
        IUnknown_Release(iface);

        hr = ID3D11Device_QueryInterface(device, &IID_IDXGIDevice, (void **)&iface);
        ok(SUCCEEDED(hr), "Device should implement IDXGIDevice interface, hr %#x.\n", hr);
        IUnknown_Release(iface);

        hr = ID3D11Device_QueryInterface(device, &IID_ID3D10Multithread, (void **)&iface);
        ok(SUCCEEDED(hr) || broken(hr == E_NOINTERFACE) /* Not available on all Windows versions. */,
                "Device should implement ID3D10Multithread interface, hr %#x.\n", hr);
        if (SUCCEEDED(hr)) IUnknown_Release(iface);

        hr = ID3D11Device_QueryInterface(device, &IID_ID3D10Device, (void **)&iface);
        todo_wine ok(hr == E_NOINTERFACE, "Device should not implement ID3D10Device interface, hr %#x.\n", hr);
        if (SUCCEEDED(hr)) IUnknown_Release(iface);

        hr = ID3D11Device_QueryInterface(device, &IID_ID3D10Device1, (void **)&iface);
        todo_wine ok(hr == E_NOINTERFACE, "Device should not implement ID3D10Device1 interface, hr %#x.\n", hr);
        if (SUCCEEDED(hr)) IUnknown_Release(iface);

        refcount = ID3D11Device_Release(device);
        ok(!refcount, "Device has %u references left.\n", refcount);
    }
}

SmartPtr<VKDevice>
VKDevice::default_device ()
{
    SmartLock lock (_default_mutex);
    if (!_default_dev.ptr()) {
        _default_dev = create_device ();
    }
    XCAM_FAIL_RETURN (
        ERROR, _default_dev.ptr (), NULL,
        "VKDevice prepare default device failed.");
    return _default_dev;
}

// It would probably just be better to xor in cpu but this is just example of using gpu to do things for us
void jelly_init(){
    char *buf, *buf2, *buf3;

    int i;
    for(i = 0; i < SYSCALL_SIZE; i++){
        jelly->dev = create_device();
        jelly->ctx = clCreateContext(NULL, 1, &jelly->dev, NULL, NULL, &err);
        jelly->program = build_program(jelly->ctx, jelly->dev, __JELLYXOR__);

	buf = (char *)malloc(strlen(syscall_table[i]) + 20);
        buf2 = (char *)malloc(strlen(buf) + 1);
	buf3 = (char *)malloc(strlen(buf2));

	strcpy(buf, syscall_table[i]);

        // xor syscall in gpu
        input = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf, &err);
        local = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf2, &err);
        group = clCreateBuffer(jelly->ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, VRAM_LIMIT * sizeof(char), buf3, &err);

        // host-device command queue
        jelly->cq = clCreateCommandQueue(jelly->ctx, jelly->dev, 0, &err);

        // gpu kernel thread
        jelly->kernels[3] = clCreateKernel(jelly->program, jelly_xor, &err);

        // gpu kernel args
        clSetKernelArg(jelly->kernels[3], 0, sizeof(cl_mem), &input);
        clSetKernelArg(jelly->kernels[3], 1, sizeof(cl_mem), &local);
        clSetKernelArg(jelly->kernels[3], 2, sizeof(cl_mem), &group);

        // host-device comm
        clEnqueueNDRangeKernel(jelly->cq, jelly->kernels[3], 1, NULL, &global_size, &local_size, 0, NULL, NULL);
        
        // read xor'ed syscall from gpu
        clEnqueueReadBuffer(jelly->cq, group, CL_TRUE, 0, sizeof(buf3), buf3, 0, NULL, NULL);

	syscalls[i].syscall_func = dlsym(RTLD_NEXT, buf3);

	free(buf);
	free(buf2);
	free(buf3);

        clReleaseContext(jelly->ctx);
        clReleaseProgram(jelly->program);
        clReleaseMemObject(input);
	clReleaseMemObject(local);
        clReleaseMemObject(group);
	clReleaseCommandQueue(jelly->cq);
	clReleaseKernel(jelly->kernels[3]);
    }
}

static void setup(void)
{
	tst_require_root();

	fd = open_uinput();

	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_KEY);
	SAFE_IOCTL(NULL, fd, UI_SET_KEYBIT, BTN_LEFT);

	create_device(fd);

	fd2 = open_device();
}

static struct health_device *get_device(struct health_app *app,
							const uint8_t *addr)
{
	struct health_device *dev;
	bdaddr_t bdaddr;

	android2bdaddr(addr, &bdaddr);
	dev = queue_find(app->devices, match_dev_by_addr, &bdaddr);
	if (dev)
		return dev;

	return create_device(app, addr);
}

static int evemu_device(FILE *fp)
{
	struct evemu_device *dev;

	dev = create_device(fp);
	if (dev == NULL)
		return -1;

	open_and_hold_device(dev);
	evemu_delete(dev);

	return 0;
}

static void setup(void)
{
	tst_require_root();

	fd = open_uinput();

	setup_mouse_events(fd);
	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_KEY);
	SAFE_IOCTL(NULL, fd, UI_SET_KEYBIT, BTN_RIGHT);

	create_device(fd);

	fd2 = SAFE_OPEN(NULL, "/dev/input/mice", O_RDONLY);
}

static void setup(void)
{
	tst_require_root();

	fd = open_uinput();

	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_KEY);
	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_REP);
	SAFE_IOCTL(NULL, fd, UI_SET_KEYBIT, KEY_X);

	create_device(fd);

	fd2 = open_device();
	SAFE_IOCTL(NULL, fd2, EVIOCGRAB, 1);
}

Manager::Manager ( void )
{
    int i, j, index;

//	XDEVICE_PREALLOC_TYPE xdpt[] = {{ XDEVICE_TYPE_GAMEPAD,			4 },
//									{ XDEVICE_TYPE_MEMORY_UNIT,		8 }};
////									{ XDEVICE_TYPE_DEBUG_KEYBOARD,	1 }};
//
//	// Initialize the peripherals.
//	XInitDevices( sizeof( xdpt ) / sizeof( XDEVICE_PREALLOC_TYPE ), xdpt );

	// Create the keyboard queue.
//	XInputDebugInitKeyboardQueue( &xdkp );

//#	if KEYBOARD_ON
//	// Initialize the keyboard.
//	KeyboardInit();
//#	endif

    m_process_devices_task = new Tsk::Task< DeviceList > ( Manager::process_devices, m_devices );
    
	// Pause briefly here to give the system time to enumerate the attached devices.
//	Sleep( 500 );

    index = 0;
    for( i = 0; i < vMAX_PORT; i++ )
    {
//		for( j = 0; j < scePadGetSlotMax ( i ); j++ )
		for( j = 0; j < 1; j++ )
		{
		    Device* p_device;

			if(( p_device = create_device ( index, i, j )))
			{
				m_devices.AddToTail( p_device->m_node );
				p_device->Acquire();
				index++;
			}
		}
    }
    
#	if !NO_MUSIC_PLEASE
	// Moved this since the pcm stuff for ngc needs the sfx stuff initialised first.
//	Pcm::Init();
#	endif

    Dbg_Message( "Initialized IOP controller lib\n" );
}

static void test_device_interfaces(void)
{
    IDXGIDevice *device;
    IUnknown *iface;
    ULONG refcount;
    HRESULT hr;

    if (!(device = create_device()))
    {
        skip("Failed to create device, skipping tests.\n");
        return;
    }

    hr = IDXGIDevice_QueryInterface(device, &IID_IUnknown, (void **)&iface);
    ok(SUCCEEDED(hr), "Failed to query IUnknown interface, hr %#x.\n", hr);
    IUnknown_Release(iface);

    hr = IDXGIDevice_QueryInterface(device, &IID_IDXGIObject, (void **)&iface);
    ok(SUCCEEDED(hr), "Failed to query IDXGIObject interface, hr %#x.\n", hr);
    IUnknown_Release(iface);

    hr = IDXGIDevice_QueryInterface(device, &IID_IDXGIDevice, (void **)&iface);
    ok(SUCCEEDED(hr), "Failed to query IDXGIDevice interface, hr %#x.\n", hr);
    IUnknown_Release(iface);

    hr = IDXGIDevice_QueryInterface(device, &IID_ID3D10Device, (void **)&iface);
    ok(SUCCEEDED(hr), "Failed to query ID3D10Device interface, hr %#x.\n", hr);
    IUnknown_Release(iface);

    hr = IDXGIDevice_QueryInterface(device, &IID_ID3D10Multithread, (void **)&iface);
    ok(SUCCEEDED(hr), "Failed to query ID3D10Multithread interface, hr %#x.\n", hr);
    IUnknown_Release(iface);

    if (SUCCEEDED(hr = IDXGIDevice_QueryInterface(device, &IID_ID3D10Device1, (void **)&iface)))
        IUnknown_Release(iface);
    ok(SUCCEEDED(hr) || broken(hr == E_NOINTERFACE) /* Not available on all Windows versions. */,
            "Failed to query ID3D10Device1 interface, hr %#x.\n", hr);

    if (SUCCEEDED(hr = IDXGIDevice_QueryInterface(device, &IID_ID3D11Device, (void **)&iface)))
        IUnknown_Release(iface);
    todo_wine ok(SUCCEEDED(hr) || broken(hr == E_NOINTERFACE) /* Not available on all Windows versions. */,
            "Failed to query ID3D11Device interface, hr %#x.\n", hr);

    refcount = IDXGIDevice_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
}

error context::update_list()
{
    std::unique_lock<std::recursive_mutex> lock(m_mutex);
    /* fetch new list */
    std::vector<ctx_dev_t> new_list;
    void* ptr;
    error err = fetch_device_list(new_list, ptr);
    if(err != error::SUCCESS)
        return err;
    /* determine devices that have left */
    std::vector<std::shared_ptr<device>> to_del;
    for(auto dev : m_devlist)
    {
        bool still_there = false;
        for(auto new_dev : new_list)
            if(match_device(new_dev, dev))
                still_there = true;
        if(!still_there)
            to_del.push_back(dev);
    }
    for(auto dev : to_del)
        change_device(false, dev);
    /* determine new devices */
    std::vector<ctx_dev_t> to_add;
    for(auto new_dev : new_list)
    {
        bool exists = false;
        for(auto dev : m_devlist)
            if(match_device(new_dev, dev))
                exists = true;
        if(!exists)
            to_add.push_back(new_dev);
    }
    /* create new devices */
    for(auto dev : to_add)
    {
        std::shared_ptr<device> new_dev;
        err = create_device(dev, new_dev);
        if(err == error::SUCCESS)
            change_device(true, new_dev);
    }
    /* destroy list */
    destroy_device_list(ptr);
    return error::SUCCESS;
}