// Open a device by vendor/product id. If more than one device
// matches, return the first.
func (ctx *Context) Open(vendor, product int) (*DeviceHandle, *UsbError) {
handle := &DeviceHandle{ctx, nil, 0, make(map[byte]*Interface, 0)}
dev := C.libusb_open_device_with_vid_pid(ctx.ctx, C.uint16_t(vendor), C.uint16_t(product))
if dev == nil {
return nil, UsbErrorMisc
}
handle.handle = dev
return handle, nil
}
// First returns the first supported device attached to the host. Unlike Walk,
// the returned Device is opened automatically. This function exists primarily
// for testing.
func First() (*Device, error) {
handle := C.libusb_open_device_with_vid_pid(context, idVendor, idProduct)
if handle == nil {
return nil, errors.New("no devices found")
}
if err := C.libusb_claim_interface(handle, interfaceNum); err != C.LIBUSB_SUCCESS {
C.libusb_close(handle)
return nil, &libusbError{err}
}
return &Device{
dev: C.libusb_get_device(handle),
handle: handle,
}, nil
}
func Start(color chan byte, output chan guinput.KeyEvent) *C.struct_libusb_device_handle {
C.libusb_init(nil)
fmt.Println(KEYMAP[0x21])
key_device_handle := C.libusb_open_device_with_vid_pid(nil, 0x046d, 0xc22d)
//detach any necessary kernel drivers from MY keyboard
if C.libusb_kernel_driver_active(key_device_handle, 0) == 1 {
log.Print("kernel driver active on main interface")
e := C.libusb_detach_kernel_driver(key_device_handle, 0)
if e != 0 {
log.Fatal("Can't detach kernel driver")
}
}
if C.libusb_kernel_driver_active(key_device_handle, 1) == 1 {
fmt.Println("kernel driver active")
e := C.libusb_detach_kernel_driver(key_device_handle, 1)
if e != 0 {
log.Fatal("Can't detach kernel driver")
}
}
//Claim the interfaces we'll be listening on
r := C.libusb_claim_interface(key_device_handle, 0)
if r != 0 {
log.Fatal("Can't claim main interface")
}
r = C.libusb_claim_interface(key_device_handle, 1)
if r != 0 {
log.Fatal("Can't claim special interface")
}
log.Print("Starting libusb goroutines\n")
go ColorChange(key_device_handle, color)
//go LCDChange(key_device_handle, lcd)
go NormalKeyMonitor(key_device_handle, output)
go SpecialKeyMonitor(key_device_handle, output)
log.Print("Libusb Goroutines started\n")
return key_device_handle
}
// OpenDeviceWithVidPid opens Device from specific VendorId and ProductId.
// If there are any errors, it'll returns at second value.
func (c *Context) OpenDeviceWithVidPid(vid, pid int) (*Device, error) {
handle := C.libusb_open_device_with_vid_pid(c.ctx, (C.uint16_t)(vid), (C.uint16_t)(pid))
if handle == nil {
return nil, ERROR_NOT_FOUND
}
dev := C.libusb_get_device(handle)
if dev == nil {
return nil, ERROR_NO_DEVICE
}
desc, err := newDescriptor(dev)
// return an error from nil-handle and nil-device
if err != nil {
return nil, err
}
device := newDevice(handle, desc)
return device, nil
}
func StartLibUsb() error {
Connected = true
key_device_handle := C.libusb_open_device_with_vid_pid(nil, 0x046d, 0xc22d)
if key_device_handle != nil {
if C.libusb_kernel_driver_active(key_device_handle, 1) == 1 {
e := C.libusb_detach_kernel_driver(key_device_handle, 1)
if e != 0 {
log.Fatal("Can't detach kernel driver")
}
}
r := C.libusb_claim_interface(key_device_handle, 1)
if r != 0 {
log.Fatal("Can't claim special interface")
}
keyboardHandle = key_device_handle
return nil
}
return errors.New("could not open driver")
}
