cross-compile/android/libusb-1.0.patch

   1 diff -urp libusb-1.0.9.orig/libusb/io.c libusb-1.0.9/libusb/io.c
   2 --- libusb-1.0.9.orig/libusb/io.c       2013-08-28 14:33:15.000000000 +0200
   3 +++ libusb-1.0.9/libusb/io.c    2013-08-28 14:31:25.000000000 +0200
   4 @@ -36,6 +36,14 @@
   5
   6  #include "libusbi.h"
   7
   8 +#ifndef TIMESPEC_TO_TIMEVAL
   9 +#define TIMESPEC_TO_TIMEVAL(tv, ts)                                     \
  10 +        do {                                                            \
  11 +                (tv)->tv_sec = (ts)->tv_sec;                            \
  12 +                (tv)->tv_usec = (ts)->tv_nsec / 1000;                   \
  13 +        } while (0)
  14 +#endif
  15 +
  16  /**
  17   * \page io Synchronous and asynchronous device I/O
  18   *
  19 --- libusb-1.0.19.orig/libusb/os/linux_usbfs.c  2014-05-30 11:18:28.000000000 +0200
  20 +++ libusb-1.0.19/libusb/os/linux_usbfs.c       2016-11-26 15:38:21.199383120 +0100
  21 @@ -37,11 +37,31 @@
  22  #include <sys/types.h>
  23  #include <sys/utsname.h>
  24  #include <unistd.h>
  25 +#ifdef __ANDROID__
  26 +#include <jni.h>
  27 +#endif
  28
  29  #include "libusb.h"
  30  #include "libusbi.h"
  31  #include "linux_usbfs.h"
  32
  33 +#ifdef __ANDROID__
  34 +static JavaVM *g_jvm = NULL;
  35 +static jclass usb_helper_class;
  36 +static jclass usb_event_listener_class;
  37 +static jmethodID usb_helper_open_mid;
  38 +static jmethodID usb_helper_start_event_monitor_mid;
  39 +static jmethodID usb_helper_stop_event_monitor_mid;
  40 +static jmethodID usb_helper_scan_devices_mid;
  41 +static jmethodID usb_event_listener_init_mid;
  42 +static int usb_helper_open(const char *pathname, int flags);
  43 +static int usb_helper_start_event_monitor(void);
  44 +static int usb_helper_stop_event_monitor(void);
  45 +static int usb_helper_scan_devices (struct libusb_context *ctx);
  46 +static void usb_helper_hotplug_poll(void);
  47 +static void usb_helper_on_usb_device_action(JNIEnv *env, jobject self, jstring name, jboolean removed);
  48 +#endif
  49 +
  50  /* sysfs vs usbfs:
  51   * opening a usbfs node causes the device to be resumed, so we attempt to
  52   * avoid this during enumeration.
  53 @@ -193,6 +213,11 @@
  54                 snprintf(path, PATH_MAX, "%s/%03d/%03d",
  55                         usbfs_path, dev->bus_number, dev->device_address);
  56
  57 +#ifdef __ANDROID__
  58 +       if (g_jvm)
  59 +               fd = usb_helper_open(path, mode);
  60 +       else
  61 +#endif
  62         fd = open(path, mode);
  63         if (fd != -1)
  64                 return fd; /* Success */
  65 @@ -369,6 +394,13 @@
  66         struct stat statbuf;
  67         int r;
  68
  69 +#ifdef __ANDROID__
  70 +       if (g_jvm) {
  71 +               usbfs_path = "/dev/bus/usb";
  72 +               sysfs_can_relate_devices = 0;
  73 +               sysfs_has_descriptors = 0;
  74 +       } else
  75 +#endif
  76         usbfs_path = find_usbfs_path();
  77         if (!usbfs_path) {
  78                 usbi_err(ctx, "could not find usbfs");
  79 @@ -467,6 +499,10 @@
  80
  81  static int linux_start_event_monitor(void)
  82  {
  83 +#ifdef __ANDROID__
  84 +       if (g_jvm)
  85 +               return usb_helper_start_event_monitor();
  86 +#endif
  87  #if defined(USE_UDEV)
  88         return linux_udev_start_event_monitor();
  89  #else
  90 @@ -476,6 +512,10 @@
  91
  92  static int linux_stop_event_monitor(void)
  93  {
  94 +#ifdef __ANDROID__
  95 +       if (g_jvm)
  96 +               return usb_helper_stop_event_monitor();
  97 +#endif
  98  #if defined(USE_UDEV)
  99         return linux_udev_stop_event_monitor();
 100  #else
 101 @@ -489,6 +529,11 @@
 102
 103         usbi_mutex_static_lock(&linux_hotplug_lock);
 104
 105 +#ifdef __ANDROID__
 106 +       if (g_jvm)
 107 +               ret = usb_helper_scan_devices(ctx);
 108 +       else
 109 +#endif
 110  #if defined(USE_UDEV)
 111         ret = linux_udev_scan_devices(ctx);
 112  #else
 113 @@ -502,6 +547,11 @@
 114
 115  static void op_hotplug_poll(void)
 116  {
 117 +#ifdef __ANDROID__
 118 +       if (g_jvm)
 119 +               usb_helper_hotplug_poll();
 120 +       else
 121 +#endif
 122  #if defined(USE_UDEV)
 123         linux_udev_hotplug_poll();
 124  #else
 125 @@ -994,6 +1044,10 @@
 126         /* XXX -- can we figure out the topology when using usbfs? */
 127         if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
 128                 /* either using usbfs or finding the parent of a root hub */
 129 +#ifdef __ANDROID__
 130 +               if (g_jvm)
 131 +                       dev->port_number = dev->device_address;
 132 +#endif
 133                 return LIBUSB_SUCCESS;
 134         }
 135
 136 @@ -2693,3 +2747,262 @@
 137         .transfer_priv_size = sizeof(struct linux_transfer_priv),
 138         .add_iso_packet_size = 0,
 139  };
 140 +
 141 +#ifdef __ANDROID__
 142 +jint JNI_OnLoad(JavaVM *vm, void *reserved)
 143 +{
 144 +       static JNINativeMethod jni_method = {
 145 +               "onUsbDeviceAction",
 146 +               "(Ljava/lang/String;Z)V",
 147 +               (void*)usb_helper_on_usb_device_action
 148 +       };
 149 +
 150 +       JNIEnv* env;
 151 +       g_jvm = vm;
 152 +       if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
 153 +               return -1;
 154 +       }
 155 +
 156 +       jclass helper = (*env)->FindClass(env, "org/sigrok/androidutils/UsbHelper");
 157 +       jclass event_listener = (*env)->FindClass(env, "org/sigrok/androidutils/UsbEventListenerStub");
 158 +
 159 +       if (helper && event_listener) {
 160 +
 161 +               usb_helper_class = (jclass)(*env)->NewGlobalRef(env, helper);
 162 +
 163 +               usb_helper_open_mid = (*env)->GetStaticMethodID(env, helper, "open",
 164 +                                                               "(Ljava/lang/String;I)I");
 165 +               usb_helper_start_event_monitor_mid = (*env)->GetStaticMethodID(env, helper, "startEventMonitor",
 166 +                                                                              "(Lorg/sigrok/androidutils/UsbEventListener;)V");
 167 +               usb_helper_stop_event_monitor_mid = (*env)->GetStaticMethodID(env, helper, "stopEventMonitor",
 168 +                                                                             "()V");
 169 +               usb_helper_scan_devices_mid = (*env)->GetStaticMethodID(env, helper, "scanDevices",
 170 +                                                                       "()[Ljava/lang/String;");
 171 +               (*env)->DeleteLocalRef(env, helper);
 172 +
 173 +               usb_event_listener_class = (jclass)(*env)->NewGlobalRef(env, event_listener);
 174 +               usb_event_listener_init_mid = (*env)->GetMethodID(env, event_listener, "<init>",
 175 +                                                                       "()V");
 176 +               if ((*env)->RegisterNatives(env, event_listener, &jni_method, 1) < 0) {
 177 +                       if ((*env)->ExceptionCheck(env)) {
 178 +                               (*env)->ExceptionClear(env);
 179 +                       }
 180 +                       g_jvm = NULL;
 181 +               }
 182 +
 183 +               (*env)->DeleteLocalRef(env, event_listener);
 184 +
 185 +       } else {
 186 +               if ((*env)->ExceptionCheck(env)) {
 187 +                       (*env)->ExceptionClear(env);
 188 +               }
 189 +               g_jvm = NULL;
 190 +       }
 191 +
 192 +       return JNI_VERSION_1_6;
 193 +}
 194 +
 195 +void JNI_OnUnload(JavaVM *vm, void *reserved)
 196 +{
 197 +       JNIEnv* env;
 198 +       if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
 199 +               return;
 200 +       }
 201 +
 202 +       jclass helper = usb_helper_class;
 203 +       jclass event_listener = usb_event_listener_class;
 204 +       usb_helper_class = NULL;
 205 +       usb_event_listener_class = NULL;
 206 +       if (helper)
 207 +               (*env)->DeleteGlobalRef(env, helper);
 208 +       if (event_listener) {
 209 +               (*env)->UnregisterNatives(env, event_listener);
 210 +               (*env)->DeleteGlobalRef(env, event_listener);
 211 +       }
 212 +       g_jvm = NULL;
 213 +}
 214 +
 215 +static int usb_helper_open(const char *pathname, int flags)
 216 +{
 217 +       JNIEnv* env;
 218 +       int res;
 219 +       jint st;
 220 +       int do_detach = 0;
 221 +
 222 +       if (g_jvm == NULL) {
 223 +               return -1;
 224 +       }
 225 +       st = (*g_jvm)->GetEnv(g_jvm, (void **)&env, JNI_VERSION_1_6);
 226 +
 227 +       if (st == JNI_EDETACHED) {
 228 +               st = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 229 +               do_detach = 1;
 230 +       }
 231 +
 232 +       if (st != JNI_OK) {
 233 +               return -1;
 234 +       }
 235 +
 236 +       jstring string = (*env)->NewStringUTF(env, pathname);
 237 +       res = (*env)->CallStaticIntMethod(env, usb_helper_class, usb_helper_open_mid, string, (jint)flags);
 238 +       (*env)->DeleteLocalRef(env, string);
 239 +
 240 +       if (do_detach) {
 241 +               (*g_jvm)->DetachCurrentThread(g_jvm);
 242 +       }
 243 +
 244 +       if (res >= 0) {
 245 +               /* Rewind so that descriptors can be read */
 246 +               lseek(res, SEEK_SET, 0);
 247 +       }
 248 +
 249 +       return res;
 250 +}
 251 +
 252 +static int usb_helper_start_event_monitor(void)
 253 +{
 254 +       JNIEnv* env;
 255 +       jint st;
 256 +       int do_detach = 0;
 257 +       int res = 0;
 258 +       jobject usb_event_listener;
 259 +
 260 +       if (g_jvm == NULL) {
 261 +               return LIBUSB_ERROR_OTHER;
 262 +       }
 263 +       st = (*g_jvm)->GetEnv(g_jvm, (void **)&env, JNI_VERSION_1_6);
 264 +
 265 +       if (st == JNI_EDETACHED) {
 266 +               st = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 267 +               do_detach = 1;
 268 +       }
 269 +
 270 +       if (st != JNI_OK) {
 271 +               return LIBUSB_ERROR_OTHER;
 272 +       }
 273 +
 274 +       usb_event_listener = (*env)->NewObject(env, usb_event_listener_class, usb_event_listener_init_mid);
 275 +       if (usb_event_listener == NULL)
 276 +               res = LIBUSB_ERROR_OTHER;
 277 +       else {
 278 +               (*env)->CallStaticVoidMethod(env, usb_helper_class, usb_helper_start_event_monitor_mid, usb_event_listener);
 279 +               (*env)->DeleteLocalRef(env, usb_event_listener);
 280 +       }
 281 +
 282 +       if (do_detach) {
 283 +               (*g_jvm)->DetachCurrentThread(g_jvm);
 284 +       }
 285 +
 286 +       return res;
 287 +}
 288 +
 289 +static int usb_helper_stop_event_monitor(void)
 290 +{
 291 +       JNIEnv* env;
 292 +       jint st;
 293 +       int do_detach = 0;
 294 +
 295 +       if (g_jvm == NULL) {
 296 +               return LIBUSB_ERROR_OTHER;
 297 +       }
 298 +       st = (*g_jvm)->GetEnv(g_jvm, (void **)&env, JNI_VERSION_1_6);
 299 +
 300 +       if (st == JNI_EDETACHED) {
 301 +               st = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 302 +               do_detach = 1;
 303 +       }
 304 +
 305 +       if (st != JNI_OK) {
 306 +               return LIBUSB_ERROR_OTHER;
 307 +       }
 308 +
 309 +       (*env)->CallStaticVoidMethod(env, usb_helper_class, usb_helper_stop_event_monitor_mid);
 310 +
 311 +       if (do_detach) {
 312 +               (*g_jvm)->DetachCurrentThread(g_jvm);
 313 +       }
 314 +
 315 +       return 0;
 316 +}
 317 +
 318 +static int usb_helper_scan_devices (struct libusb_context *ctx)
 319 +{
 320 +       JNIEnv* env;
 321 +       int res = 0;
 322 +       jint st;
 323 +       int do_detach = 0;
 324 +
 325 +       if (g_jvm == NULL) {
 326 +               return LIBUSB_ERROR_OTHER;
 327 +       }
 328 +       st = (*g_jvm)->GetEnv(g_jvm, (void **)&env, JNI_VERSION_1_6);
 329 +
 330 +       if (st == JNI_EDETACHED) {
 331 +               st = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 332 +               do_detach = 1;
 333 +       }
 334 +
 335 +       if (st != JNI_OK) {
 336 +               return LIBUSB_ERROR_OTHER;
 337 +       }
 338 +
 339 +       jobject arr = (*env)->CallStaticObjectMethod(env, usb_helper_class, usb_helper_scan_devices_mid);
 340 +
 341 +       if (arr == NULL)
 342 +               res = LIBUSB_ERROR_OTHER;
 343 +       else {
 344 +               jsize i, len = (*env)->GetArrayLength(env, arr);
 345 +               for (i=0; i<len; i++) {
 346 +                       jobject str = (*env)->GetObjectArrayElement(env, arr, i);
 347 +                       if (str) {
 348 +                               const char *ustr = (*env)->GetStringUTFChars(env, str, NULL);
 349 +                               if (ustr) {
 350 +                                       unsigned busnum, devaddr;
 351 +                                       if (2 != sscanf(ustr, "/dev/bus/usb/%u/%u",
 352 +                                                       &busnum, &devaddr) ||
 353 +                                           linux_enumerate_device(ctx, busnum, devaddr, NULL)) {
 354 +                                               usbi_dbg("failed to enumerate device %s", ustr);
 355 +                                       }
 356 +                                       (*env)->ReleaseStringUTFChars(env, str, ustr);
 357 +                               } else
 358 +                                       res = LIBUSB_ERROR_OTHER;
 359 +                               (*env)->DeleteLocalRef(env, str);
 360 +                       } else
 361 +                               res = LIBUSB_ERROR_OTHER;
 362 +                       if (res)
 363 +                               break;
 364 +               }
 365 +               (*env)->DeleteLocalRef(env, arr);
 366 +       }
 367 +
 368 +       if (do_detach) {
 369 +               (*g_jvm)->DetachCurrentThread(g_jvm);
 370 +       }
 371 +
 372 +       return res;
 373 +}
 374 +
 375 +static void usb_helper_hotplug_poll(void)
 376 +{
 377 +}
 378 +
 379 +static void usb_helper_on_usb_device_action(JNIEnv *env, jobject self, jstring name, jboolean removed)
 380 +{
 381 +       usbi_mutex_static_lock(&linux_hotplug_lock);
 382 +       if (name) {
 383 +               const char *ustr = (*env)->GetStringUTFChars(env, name, NULL);
 384 +               if (ustr) {
 385 +                       unsigned busnum, devaddr;
 386 +                       if (2 == sscanf(ustr, "/dev/bus/usb/%u/%u",
 387 +                                       &busnum, &devaddr)) {
 388 +                               if (removed)
 389 +                                       linux_device_disconnected(busnum, devaddr, NULL);
 390 +                               else
 391 +                                       linux_hotplug_enumerate(busnum, devaddr, NULL);
 392 +                       }
 393 +                       (*env)->ReleaseStringUTFChars(env, name, ustr);
 394 +               }
 395 +       }
 396 +       usbi_mutex_static_unlock(&linux_hotplug_lock);
 397 +}
 398 +#endif