libuuu/usbhotplug.cpp

   1 /*
   2 * Copyright 2018 NXP.
   3 *
   4 * Redistribution and use in source and binary forms, with or without modification,
   5 * are permitted provided that the following conditions are met:
   6 *
   7 * Redistributions of source code must retain the above copyright notice, this
   8 * list of conditions and the following disclaimer.
   9 *
  10 * Redistributions in binary form must reproduce the above copyright notice, this
  11 * list of conditions and the following disclaimer in the documentation and/or
  12 * other materials provided with the distribution.
  13 *
  14 * Neither the name of the NXP Semiconductor nor the names of its
  15 * contributors may be used to endorse or promote products derived from this
  16 * software without specific prior written permission.
  17 *
  18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28 * POSSIBILITY OF SUCH DAMAGE.
  29 *
  30 */
  31
  32 /*
  33  * Windows libusb don't support hotplug yet
  34  * Will polling devices list every 100ms
  35  */
  36
  37 #include <thread>
  38 #include <atomic>
  39 #include <mutex>
  40 #include <utility>
  41 #include <algorithm>
  42 #include <stdexcept>
  43 #include "libusb.h"
  44 #include "liberror.h"
  45 #include "config.h"
  46 #include "cmd.h"
  47 #include "libcomm.h"
  48 #include "libuuu.h"
  49 #include "rominfo.h"
  50 #include "vector"
  51 #include <time.h>
  52 #include <iostream>
  53
  54 using chrono::milliseconds;
  55 using chrono::operator ""ms;
  56 using chrono::seconds;
  57 using chrono::operator ""s;
  58
  59 static atomic<seconds> g_wait_usb_timeout{-1s};
  60 static atomic<milliseconds> g_usb_poll_period{200ms};
  61 static atomic<seconds> g_wait_next_usb_timeout{-1s};
  62
  63 enum KnownDeviceState {
  64         NoKnownDevice,
  65         KnownDeviceToDo,
  66         KnownDeviceDone,
  67         WaitNextKnownDevice,
  68 };
  69 static atomic<KnownDeviceState> g_known_device_state{NoKnownDevice};
  70
  71 class CAutoDeInit
  72 {
  73 public:
  74         CAutoDeInit()
  75         {
  76                 if (libusb_init(nullptr) < 0)
  77                                 throw runtime_error{ "Call libusb_init failure" };
  78         }
  79         ~CAutoDeInit()
  80         {
  81                 libusb_exit(nullptr);
  82         }
  83 } g_autoDeInit;
  84
  85 class CAutoList
  86 {
  87 public:
  88         libusb_device **list = nullptr;
  89
  90         CAutoList(libusb_device **list)
  91         {
  92                 this->list = list;
  93                 m_rc = -1;
  94         }
  95
  96         CAutoList(CAutoList &&other)
  97         {
  98                 this->list = other.list;
  99                 this->m_rc = other.m_rc;
 100                 other.list = nullptr;
 101         }
 102
 103         CAutoList()
 104         {
 105                 m_rc = libusb_get_device_list(nullptr, &list);
 106                 if (m_rc < 0) {
 107                         set_last_err_string(std::string("libusb_get_device_list failed: ") +
 108                                                                 libusb_strerror(static_cast<libusb_error>(m_rc)));
 109                 }
 110         }
 111
 112         ~CAutoList()
 113         {
 114                 if (list != nullptr) {
 115                         libusb_free_device_list(list, 1);
 116                 }
 117         }
 118
 119         CAutoList& operator=(CAutoList &&other)
 120         {
 121                 this->list = other.list;
 122                 this->m_rc = other.m_rc;
 123                 other.list = nullptr;
 124                 return *this;
 125         }
 126
 127         CAutoList& operator=(const CAutoList&) = delete;        // Prevent copy, allow move only
 128         CAutoList(const CAutoList&) = delete;   // Prevent copy, allow move only
 129
 130         bool good() const
 131         {
 132                 return m_rc >= 0;
 133         }
 134
 135 private:
 136         int m_rc = 0;
 137 };
 138
 139 struct filter {
 140         vector<string> list;
 141         mutex lock;
 142
 143         void push_back(string filter)
 144         {
 145                 lock_guard<mutex> guard{lock};
 146                 list.emplace_back(std::move(filter));
 147         }
 148 };
 149
 150 static struct: public filter {
 151         bool is_valid(const string& path)
 152         {
 153                 lock_guard<mutex> guard{lock};
 154                 if (list.empty())
 155                         return true;
 156
 157                 auto end = list.end();
 158                 auto pos = find(list.begin(), end, path);
 159                 return pos != end;
 160         }
 161 } g_filter_usbpath;
 162
 163
 164 static struct: public filter {
 165         bool is_valid(const string& serial_no)
 166         {
 167                 lock_guard<mutex> guard{lock};
 168                 if (list.empty())
 169                         return true;
 170
 171                 if (serial_no.empty())
 172                         return false;
 173
 174                 for(auto it: list) {
 175                         if (compare_str(serial_no.substr(0, it.length()), it, true))
 176                                 return true;
 177                 }
 178
 179                 return false;
 180         }
 181 } g_filter_usbserial_no;
 182
 183 struct Timer
 184 {
 185         using Clock = chrono::steady_clock;
 186         Clock::time_point start;
 187
 188         explicit Timer(Clock::time_point start) : start{start} {}
 189         Timer() : Timer{Clock::now()} {}
 190
 191         bool is_elapsed(Clock::duration interval) const
 192         {
 193                 return (Clock::now() - start) >= interval;
 194         }
 195
 196         void reset(Clock::time_point start)
 197         {
 198                 this->start = start;
 199         }
 200
 201         void reset()
 202         {
 203                 reset(Clock::now());
 204         }
 205 };
 206
 207 #ifdef _MSC_VER
 208 #define TRY_SUDO
 209 #else
 210 #define TRY_SUDO ",Try sudo uuu"
 211 #endif
 212
 213 static string get_device_path(libusb_device *dev)
 214 {
 215         uint8_t path[8];
 216
 217         int bus = libusb_get_bus_number(dev);
 218
 219         string_ex str;
 220
 221         str.format("%d:", bus);
 222
 223         int ret = libusb_get_port_numbers(dev, path, sizeof(path));
 224         if (ret < 0)
 225                 return "";
 226
 227         string_ex s;
 228         s.format("%d", path[0]);
 229         str.append(s);
 230
 231         for (int j = 1; j < ret; j++)
 232         {
 233                 s.format("%d", path[j]);
 234                 str.append(s);
 235         }
 236         return str;
 237 }
 238
 239 #define SERIAL_NO_MAX 512
 240
 241 static string get_device_serial_no(libusb_device *dev, struct libusb_device_descriptor *desc, ConfigItem *item)
 242 {
 243         string serial;
 244         struct libusb_device_handle *dev_handle = NULL;
 245         int sid = desc->iSerialNumber;
 246         int ret = 0;
 247
 248         if (!sid) {
 249                 const ROM_INFO *info= search_rom_info(item);
 250                 if (info)
 251                         sid = info->serial_idx;
 252         }
 253
 254         serial.resize(SERIAL_NO_MAX);
 255         libusb_open(dev, &dev_handle);
 256         if (sid && dev_handle)
 257                 ret = libusb_get_string_descriptor_ascii(dev_handle, sid, (unsigned char*)serial.c_str(), SERIAL_NO_MAX);
 258         libusb_close(dev_handle);
 259         if(ret >= 0)
 260                 serial.resize(ret);
 261
 262         return str_to_upper(serial);
 263 }
 264
 265 static string get_device_serial_no(libusb_device *dev)
 266 {
 267         string str;
 268
 269         struct libusb_device_descriptor desc;
 270         int r = libusb_get_device_descriptor(dev, &desc);
 271         if (r < 0) {
 272                 set_last_err_string("failure get device descriptor");
 273                 return str;
 274         }
 275
 276         ConfigItem *item = get_config()->find(desc.idVendor, desc.idProduct, desc.bcdDevice);
 277
 278         return get_device_serial_no(dev, &desc, item);
 279 }
 280
 281 static int open_libusb(libusb_device *dev, void **usb_device_handle)
 282 {
 283         int retry = 10;
 284
 285         while (retry)
 286         {
 287                 retry--;
 288
 289                 /* work around windows open device failure 1/10
 290                  * sometime HID device detect need some time, refresh list
 291                  * to make sure HID driver installed.
 292                  *
 293                  * On linux, udev rules may need some time to kick in,
 294                  * so also retry on -EACCES.
 295                  */
 296                 CAutoList l;
 297
 298                 int ret;
 299                 if ((ret = libusb_open(dev, (libusb_device_handle **)(usb_device_handle))) < 0)
 300                 {
 301                         if ((ret != LIBUSB_ERROR_NOT_SUPPORTED && ret != LIBUSB_ERROR_ACCESS)
 302                             || (retry == 0))
 303                         {
 304                                 set_last_err_string("Failure open usb device" TRY_SUDO);
 305                                 return -1;
 306                         }
 307                         this_thread::sleep_for(200ms);
 308                 }
 309                 else
 310                 {
 311                         return 0;
 312                 }
 313         }
 314
 315         return -1;
 316 }
 317
 318 /**
 319  Thread function. Didn't call this function directly.
 320  Unbalance libusb_unref_device.
 321  Before start thread, need call libusb_ref_device to dev is free
 322
 323  libusb_get_list()
 324  libusb_ref_device        // avoid free at libusb_free_list if run_usb_cmd have not open device in time.
 325  thread start run_usb_cmds;
 326  libusb_free_list()
 327 */
 328 static int run_usb_cmds(ConfigItem *item, libusb_device *dev, short bcddevice)
 329 {
 330         int ret;
 331         uuu_notify nt;
 332         nt.type = uuu_notify::NOTIFY_DEV_ATTACH;
 333
 334         string str;
 335         str = get_device_path(dev);
 336         str += "-";
 337         str += get_device_serial_no(dev);
 338         nt.str = (char*)str.c_str();
 339         call_notify(nt);
 340
 341         CmdUsbCtx ctx;
 342         ctx.m_config_item = item;
 343         ctx.m_current_bcd = bcddevice;
 344
 345         if ((ret = open_libusb(dev, &(ctx.m_dev))))
 346         {
 347                 nt.type = uuu_notify::NOTIFY_CMD_END;
 348                 nt.status = -1;
 349                 call_notify(nt);
 350                 return ret;
 351         }
 352
 353         ret = run_cmds(item->m_protocol.c_str(), &ctx);
 354         g_known_device_state = KnownDeviceDone;
 355
 356         nt.type = uuu_notify::NOTIFY_THREAD_EXIT;
 357         call_notify(nt);
 358
 359         libusb_unref_device(dev); //ref_device when start thread
 360         clear_env();
 361         return ret;
 362 }
 363
 364 static int usb_add(libusb_device *dev)
 365 {
 366         struct libusb_device_descriptor desc;
 367         int r = libusb_get_device_descriptor(dev, &desc);
 368         if (r < 0) {
 369                 set_last_err_string("failure get device descriptor");
 370                 return r;
 371         }
 372
 373         string str;
 374         str = get_device_path(dev);
 375         if (!g_filter_usbpath.is_valid(str))
 376                 return -1;
 377
 378         ConfigItem *item = get_config()->find(desc.idVendor, desc.idProduct, desc.bcdDevice);
 379
 380         if (item)
 381         {
 382                 string serial = get_device_serial_no(dev, &desc, item);
 383                 if (!g_filter_usbserial_no.is_valid(serial))
 384                         return -1;
 385
 386                 g_known_device_state = KnownDeviceToDo;
 387
 388                 /*
 389                  * start new thread, need increase dev ref number.
 390                  * otherwise polling thread, free_device_list free device if open device call after free_device_list.
 391                  */
 392                 libusb_ref_device(dev);
 393
 394                 std::thread(run_usb_cmds, item, dev, desc.bcdDevice).detach();
 395         }
 396         return 0;
 397 }
 398
 399 static int usb_remove(libusb_device * /*dev*/)
 400 {
 401
 402         return 0;
 403 }
 404
 405 void compare_list(libusb_device ** old, libusb_device **nw)
 406 {
 407         libusb_device * dev;
 408         int i = 0;
 409
 410         if (old == nullptr)
 411         {
 412                 while ((dev = nw[i++]) != nullptr)
 413                 {
 414                         usb_add(dev);
 415                 }
 416                 return;
 417         }
 418
 419         while ((dev = nw[i++]) != nullptr)
 420         {
 421                 libusb_device * p;
 422                 int j = 0;
 423                 while ((p = old[j++]) != nullptr)
 424                 {
 425                         if (p == dev)
 426                                 break;//find it.
 427                 };
 428                 if (p != dev)
 429                         usb_add(dev);
 430         }
 431
 432         i = 0;
 433         while ((dev = old[i++]) != nullptr)
 434         {
 435                 libusb_device * p;
 436                 int j = 0;
 437                 while ((p = nw[j++]) != nullptr)
 438                 {
 439                         if (p == dev)
 440                                 break;//find it.
 441                 };
 442                 if (p != dev)
 443                         usb_remove(dev);
 444         }
 445 }
 446
 447 static int check_usb_timeout(Timer& usb_timer)
 448 {
 449         auto known_device_state = g_known_device_state.load();
 450         if (known_device_state == KnownDeviceDone)
 451         {
 452                 g_known_device_state = known_device_state = WaitNextKnownDevice;
 453                 usb_timer.reset();
 454         }
 455
 456         auto usb_timeout = g_wait_usb_timeout.load();
 457         if (usb_timeout >= 0s && known_device_state == NoKnownDevice)
 458         {
 459                 if (usb_timer.is_elapsed(usb_timeout))
 460                 {
 461                         set_last_err_string("Timeout: Wait for Known USB Device");
 462                         return -1;
 463                 }
 464         }
 465
 466         usb_timeout = g_wait_next_usb_timeout.load();
 467         if (usb_timeout >= 0s && g_known_device_state == WaitNextKnownDevice)
 468         {
 469                 if (usb_timer.is_elapsed(usb_timeout))
 470                 {
 471                         set_last_err_string("Timeout: Wait for next USB Device");
 472                         return -1;
 473                 }
 474         }
 475
 476         return 0;
 477 }
 478
 479 int polling_usb(std::atomic<int>& bexit)
 480 {
 481         if (run_cmds("CFG:", nullptr))
 482                 return -1;
 483
 484         Timer usb_timer;
 485
 486         CAutoList oldlist(nullptr);
 487
 488         while(!bexit)
 489         {
 490                 CAutoList newlist;
 491                 if (!newlist.good())
 492                 {
 493                         return -1;
 494                 }
 495
 496                 compare_list(oldlist.list, newlist.list);
 497
 498                 std::swap(oldlist, newlist);
 499
 500                 this_thread::sleep_for(g_usb_poll_period.load());
 501
 502                 if (check_usb_timeout(usb_timer))
 503                         return -1;
 504         }
 505
 506         return 0;
 507 }
 508
 509 CmdUsbCtx::~CmdUsbCtx()
 510 {
 511         if (m_dev)
 512         {
 513                 libusb_close((libusb_device_handle*)m_dev);
 514                 m_dev = 0;
 515         }
 516 }
 517
 518 int CmdUsbCtx::look_for_match_device(const char *pro)
 519 {
 520         if (run_cmds("CFG:", nullptr))
 521                 return -1;
 522
 523         Timer usb_timer;
 524
 525         while (1)
 526         {
 527                 CAutoList l;
 528
 529                 if (!l.good()) {
 530                         break;
 531                 }
 532
 533                 size_t i = 0;
 534                 libusb_device *dev;
 535
 536                 while ((dev = l.list[i++]) != nullptr)
 537                 {
 538                         struct libusb_device_descriptor desc;
 539                         int r = libusb_get_device_descriptor(dev, &desc);
 540                         if (r < 0) {
 541                                 set_last_err_string("failure get device descriptor");
 542                                 return -1;
 543                         }
 544                         string str = get_device_path(dev);
 545
 546                         if (!g_filter_usbpath.is_valid(str))
 547                                 continue;
 548
 549                         ConfigItem *item = get_config()->find(desc.idVendor, desc.idProduct, desc.bcdDevice);
 550
 551                         string serial_no = get_device_serial_no(dev, &desc, item);
 552                         if (!g_filter_usbserial_no.is_valid(serial_no))
 553                                 continue;
 554
 555                         if (item && item->m_protocol == str_to_upper(pro))
 556                                 {
 557                                         uuu_notify nt;
 558                                         nt.type = uuu_notify::NOTIFY_DEV_ATTACH;
 559                                         m_config_item = item;
 560                                         m_current_bcd = desc.bcdDevice;
 561
 562                                         int ret;
 563                                         if ((ret = open_libusb(dev, &(m_dev))))
 564                                                 return ret;
 565
 566                                         nt.str = (char*)str.c_str();
 567                                         call_notify(nt);
 568
 569                                         return 0;
 570                                 }
 571                 }
 572
 573                 this_thread::sleep_for(200ms);
 574
 575                 uuu_notify nt;
 576                 nt.type = nt.NOTIFY_WAIT_FOR;
 577                 nt.str = (char*)"Wait for Known USB";
 578                 call_notify(nt);
 579
 580                 if (check_usb_timeout(usb_timer))
 581                         return -1;
 582         }
 583
 584         return -1;
 585 }
 586
 587 int uuu_add_usbpath_filter(const char *path)
 588 {
 589         g_filter_usbpath.push_back(path);
 590         return 0;
 591 }
 592
 593 int uuu_add_usbserial_no_filter(const char *serial_no)
 594 {
 595         g_filter_usbserial_no.push_back(serial_no);
 596         return 0;
 597 }
 598
 599 int uuu_for_each_devices(uuu_ls_usb_devices fn, void *p)
 600 {
 601         CAutoList l;
 602         size_t i = 0;
 603         libusb_device *dev;
 604
 605         if (!l.good()) {
 606                 return -1;
 607         }
 608
 609         while ((dev = l.list[i++]) != nullptr)
 610         {
 611                 struct libusb_device_descriptor desc;
 612                 int r = libusb_get_device_descriptor(dev, &desc);
 613                 if (r < 0) {
 614                         set_last_err_string("failure get device descriptor");
 615                         return -1;
 616                 }
 617                 string str = get_device_path(dev);
 618
 619                 ConfigItem *item = get_config()->find(desc.idVendor, desc.idProduct, desc.bcdDevice);
 620                 if (item)
 621                 {
 622                         string serial = get_device_serial_no(dev, &desc, item);
 623                         if (fn(str.c_str(), item->m_chip.c_str(), item->m_protocol.c_str(), desc.idVendor, desc.idProduct, desc.bcdDevice, serial.c_str(), p))
 624                         {
 625                                 set_last_err_string("call back return error");
 626                                 return -1;
 627                         }
 628                 }
 629         }
 630
 631         return 0;
 632 }
 633
 634 int uuu_set_wait_timeout(int timeout_in_seconds)
 635 {
 636         g_wait_usb_timeout = seconds{timeout_in_seconds};
 637         return 0;
 638 }
 639
 640 void uuu_set_poll_period(int period_in_milliseconds)
 641 {
 642         g_usb_poll_period = milliseconds{period_in_milliseconds};
 643 }
 644
 645 int uuu_set_wait_next_timeout(int timeout_in_seconds)
 646 {
 647         g_wait_next_usb_timeout = seconds{timeout_in_seconds};
 648         return 0;
 649 }