static int lsusb_device_added(const char *dev_name, void *client_data)
{
struct usb_device *dev = usb_device_open(dev_name);
if (!dev) {
fprintf(stderr, "can't open device %s: %s\n", dev_name, strerror(errno));
return 0;
}
if (verbose) {
struct usb_descriptor_iter iter;
struct usb_descriptor_header *desc;
printf("%s:\n", dev_name);
usb_descriptor_iter_init(dev, &iter);
while ((desc = usb_descriptor_iter_next(&iter)) != NULL)
lsusb_parse_descriptor(dev, desc);
} else {
uint16_t vid, pid;
char *mfg_name, *product_name, *serial;
vid = usb_device_get_vendor_id(dev);
pid = usb_device_get_product_id(dev);
mfg_name = usb_device_get_manufacturer_name(dev);
product_name = usb_device_get_product_name(dev);
serial = usb_device_get_serial(dev);
printf("%s: %04x:%04x %s %s %s\n", dev_name, vid, pid,
mfg_name, product_name, serial);
free(mfg_name);
free(product_name);
free(serial);
}
usb_device_close(dev);
return 0;
}
// Callback for notification when new USB devices are attached. Return true to exit from usb_host_run.
int usb_device_added (const char * devname, void * client_data) {
logd ("\n");
//logd ("client_data: %p devname: %s", client_data, devname);
logd ("devname: %s", devname);
uint16_t usb_vid, usb_pid;
int ret;
//int unused = (int) client_data;
if (ena_su_perm) { // Set Permission w/ SU:
char cmd [256] = "su -c chmod 777 ";
strlcat (cmd, devname, sizeof (cmd));
//strlcat (cmd, " 2>&1 > /sdcard/res", sizeof (cmd));
errno = 0;
ret = system (cmd); // !! Binaries like ssd that write to stdout cause C system() to crash !
logd ("system() ret: %d errno: %d (%s)", ret, errno, strerror (errno));
}
struct usb_device * device = usb_device_open (devname);
if (! device) {
loge ("usb_device_open failed");
return (0); // 0 = Leave usb_host_run() running
}
usb_vid = usb_device_get_vendor_id (device);
usb_pid = usb_device_get_product_id (device);
char * usb_ser = usb_device_get_serial (device);
logd ("usb_vid: 0x%x (%d - %s) usb_pid: 0x%x usb_ser: %s", usb_vid, usb_vid, usb_vid_get (usb_vid), usb_pid, usb_ser);
if (current_device != NULL) { // If we already have a device, just ignore
logd ("Ignoring have current_device: %p", current_device);
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
if (usb_vid != USB_VID_GOO || usb_pid >= USB_PID_ACC_MIN || usb_pid <= USB_PID_ACC_MAX) { // If not in Google Accessory mode...
logd ("Found new device - attempting to switch to accessory mode");
uint16_t protocol = -1;
errno = 0;
ret = usb_device_control_transfer (device, USB_DIR_IN | USB_TYPE_VENDOR, ACC_REQ_GET_PROTOCOL, 0, 0, & protocol, sizeof (protocol), 1000);
if (ret < 0) {
loge ("No Acc OAP protocol ret: %d errno: %d", ret, errno);
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
if (protocol < 2) {
loge ("Acc OAP protocol version %d", protocol);
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
logd ("Acc OAP protocol version %d", protocol);
send_string (device, ACC_IDX_MAN, AAP_VAL_MAN); // Send Acc strings
send_string (device, ACC_IDX_MOD, AAP_VAL_MOD);
//send_string (device, ACC_IDX_DES, AAP_VAL_DES);
//send_string (device, ACC_IDX_VER, AAP_VAL_VER);
//send_string (device, ACC_IDX_URI, AAP_VAL_URI);
//send_string (device, ACC_IDX_SER, AAP_VAL_SER);
errno = 0;
ret = usb_device_control_transfer (device, USB_DIR_OUT | USB_TYPE_VENDOR, ACC_REQ_START, 0, 0, NULL, 0, 1000);
if (ret < 0)
loge ("Acc Start ret: %d errno: %d", ret, errno);
else
logd ("Acc Start ret: %d", ret);
}
logd ("Found android device in accessory mode");
//pthread_mutex_lock (& device_mutex);
//pthread_cond_broadcast (& device_cond);
//pthread_mutex_unlock (& device_mutex);
struct usb_descriptor_iter iter;
struct usb_descriptor_header * desc = NULL;
struct usb_interface_descriptor * intf = NULL;
struct usb_endpoint_descriptor * ep = NULL;
usb_descriptor_iter_init (device, & iter); // Init for iterating USB descriptors
read_ep = 255;
write_ep = 255;
while ((desc = usb_descriptor_iter_next (& iter)) != NULL) {
if (0);
else if (desc->bDescriptorType == LIBUSB_DT_DEVICE) {
logd ("Device desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_CONFIG) {
logd ("Config desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_STRING) {
logd ("String desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_HID) {
logd ("HID desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_REPORT) {
logd ("HID Report desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_PHYSICAL) {
logd ("Physical desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_HUB) {
logd ("Hub desc: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_INTERFACE) {
intf = (struct usb_interface_descriptor *) desc;
logd ("Interface desc/intf: %p", desc);
}
else if (desc->bDescriptorType == LIBUSB_DT_ENDPOINT) {
logd ("Endpoint desc/ep: %p", desc);
ep = (struct usb_endpoint_descriptor *) desc;
uint8_t ep_addr = ep->bEndpointAddress;
if ((ep_addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) {
if (read_ep == 255) {
read_ep = ep_addr;
logd ("Set as first read endpoint ep_addr: %d");
}
else
loge ("Ignored already have read endpoint ep_addr: %d");
}
else {
if (write_ep == 255) {
write_ep = ep_addr;
logd ("Set as first write endpoint ep_addr: %d");
}
else
loge ("Ignored already have write endpoint ep_addr: %d");
}
}
else
loge ("Unknown desc->bDescriptorType: %d", desc->bDescriptorType);
}
if (! intf) {
loge ("interface not found");
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
if (read_ep == 255 || write_ep == 255) {
loge ("Read and/or write endpoints not found");
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
errno = 0;
ret = usb_device_claim_interface (device, intf->bInterfaceNumber);
if (ret) {
loge ("Error usb_device_claim_interface() errno: %d", errno);
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
current_device = device;
loge ("Success usb_device_claim_interface() : Can start AA protocol now");
//ret = hu_aap_start ();
byte vr_buf [] = {0, 3, 0, 6, 0, 1, 0, 1, 0, 1}; // Version Request
//ret = hu_aap_usb_send (vr_buf, sizeof (vr_buf), 1000); // Send Version Request
errno = 0;
ret = hu_bulk_send (vr_buf, sizeof (vr_buf));
if (ret) {
loge ("Error hu_bulk_send() ret: %d errno: %d (%s)", ret, errno, strerror (errno));
usb_device_close (device);
return (0); // 0 = Leave usb_host_run() running
}
logd ("Success hu_bulk_send()");
return (0); // 0 = Leave usb_host_run() running
}
